Merge commit '581281e242609a222233a2e5538b89dfb88fb18e'
[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     if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
556         int err;
557         s->context_reinit = 0;
558         s->height = s1->height;
559         s->width  = s1->width;
560         if ((err = ff_MPV_common_frame_size_change(s)) < 0)
561             return err;
562     }
563
564     s->avctx->coded_height  = s1->avctx->coded_height;
565     s->avctx->coded_width   = s1->avctx->coded_width;
566     s->avctx->width         = s1->avctx->width;
567     s->avctx->height        = s1->avctx->height;
568
569     s->coded_picture_number = s1->coded_picture_number;
570     s->picture_number       = s1->picture_number;
571     s->input_picture_number = s1->input_picture_number;
572
573     memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
574     memcpy(&s->last_picture, &s1->last_picture,
575            (char *) &s1->last_picture_ptr - (char *) &s1->last_picture);
576
577     s->last_picture_ptr    = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
578     s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
579     s->next_picture_ptr    = REBASE_PICTURE(s1->next_picture_ptr,    s, s1);
580
581     // Error/bug resilience
582     s->next_p_frame_damaged = s1->next_p_frame_damaged;
583     s->workaround_bugs      = s1->workaround_bugs;
584     s->padding_bug_score    = s1->padding_bug_score;
585
586     // MPEG4 timing info
587     memcpy(&s->time_increment_bits, &s1->time_increment_bits,
588            (char *) &s1->shape - (char *) &s1->time_increment_bits);
589
590     // B-frame info
591     s->max_b_frames = s1->max_b_frames;
592     s->low_delay    = s1->low_delay;
593     s->dropable     = s1->dropable;
594
595     // DivX handling (doesn't work)
596     s->divx_packed  = s1->divx_packed;
597
598     if (s1->bitstream_buffer) {
599         if (s1->bitstream_buffer_size +
600             FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
601             av_fast_malloc(&s->bitstream_buffer,
602                            &s->allocated_bitstream_buffer_size,
603                            s1->allocated_bitstream_buffer_size);
604             s->bitstream_buffer_size = s1->bitstream_buffer_size;
605         memcpy(s->bitstream_buffer, s1->bitstream_buffer,
606                s1->bitstream_buffer_size);
607         memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
608                FF_INPUT_BUFFER_PADDING_SIZE);
609     }
610
611     // MPEG2/interlacing info
612     memcpy(&s->progressive_sequence, &s1->progressive_sequence,
613            (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
614
615     if (!s1->first_field) {
616         s->last_pict_type = s1->pict_type;
617         if (s1->current_picture_ptr)
618             s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
619
620         if (s1->pict_type != AV_PICTURE_TYPE_B) {
621             s->last_non_b_pict_type = s1->pict_type;
622         }
623     }
624
625     return 0;
626 }
627
628 /**
629  * Set the given MpegEncContext to common defaults
630  * (same for encoding and decoding).
631  * The changed fields will not depend upon the
632  * prior state of the MpegEncContext.
633  */
634 void ff_MPV_common_defaults(MpegEncContext *s)
635 {
636     s->y_dc_scale_table      =
637     s->c_dc_scale_table      = ff_mpeg1_dc_scale_table;
638     s->chroma_qscale_table   = ff_default_chroma_qscale_table;
639     s->progressive_frame     = 1;
640     s->progressive_sequence  = 1;
641     s->picture_structure     = PICT_FRAME;
642
643     s->coded_picture_number  = 0;
644     s->picture_number        = 0;
645     s->input_picture_number  = 0;
646
647     s->picture_in_gop_number = 0;
648
649     s->f_code                = 1;
650     s->b_code                = 1;
651
652     s->picture_range_start   = 0;
653     s->picture_range_end     = MAX_PICTURE_COUNT;
654
655     s->slice_context_count   = 1;
656 }
657
658 /**
659  * Set the given MpegEncContext to defaults for decoding.
660  * the changed fields will not depend upon
661  * the prior state of the MpegEncContext.
662  */
663 void ff_MPV_decode_defaults(MpegEncContext *s)
664 {
665     ff_MPV_common_defaults(s);
666 }
667
668 /**
669  * Initialize and allocates MpegEncContext fields dependent on the resolution.
670  */
671 static int init_context_frame(MpegEncContext *s)
672 {
673     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
674
675     s->mb_width   = (s->width + 15) / 16;
676     s->mb_stride  = s->mb_width + 1;
677     s->b8_stride  = s->mb_width * 2 + 1;
678     s->b4_stride  = s->mb_width * 4 + 1;
679     mb_array_size = s->mb_height * s->mb_stride;
680     mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
681
682     /* set default edge pos, will be overriden
683      * in decode_header if needed */
684     s->h_edge_pos = s->mb_width * 16;
685     s->v_edge_pos = s->mb_height * 16;
686
687     s->mb_num     = s->mb_width * s->mb_height;
688
689     s->block_wrap[0] =
690     s->block_wrap[1] =
691     s->block_wrap[2] =
692     s->block_wrap[3] = s->b8_stride;
693     s->block_wrap[4] =
694     s->block_wrap[5] = s->mb_stride;
695
696     y_size  = s->b8_stride * (2 * s->mb_height + 1);
697     c_size  = s->mb_stride * (s->mb_height + 1);
698     yc_size = y_size + 2   * c_size;
699
700     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
701     for (y = 0; y < s->mb_height; y++)
702         for (x = 0; x < s->mb_width; x++)
703             s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
704
705     s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
706
707     if (s->encoding) {
708         /* Allocate MV tables */
709         FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,                 mv_table_size * 2 * sizeof(int16_t), fail)
710         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
711         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
712         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
713         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
714         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,          mv_table_size * 2 * sizeof(int16_t), fail)
715         s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;
716         s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;
717         s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;
718         s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
719         s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
720         s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;
721
722         /* Allocate MB type table */
723         FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
724
725         FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
726
727         FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
728                          mb_array_size * sizeof(float), fail);
729         FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
730                          mb_array_size * sizeof(float), fail);
731
732     }
733
734     FF_ALLOC_OR_GOTO(s->avctx, s->er_temp_buffer,
735                      mb_array_size * sizeof(uint8_t), fail);
736     FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table,
737                       mb_array_size * sizeof(uint8_t), fail);
738
739     if (s->codec_id == AV_CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)) {
740         /* interlaced direct mode decoding tables */
741         for (i = 0; i < 2; i++) {
742             int j, k;
743             for (j = 0; j < 2; j++) {
744                 for (k = 0; k < 2; k++) {
745                     FF_ALLOCZ_OR_GOTO(s->avctx,
746                                       s->b_field_mv_table_base[i][j][k],
747                                       mv_table_size * 2 * sizeof(int16_t),
748                                       fail);
749                     s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
750                                                    s->mb_stride + 1;
751                 }
752                 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
753                 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
754                 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
755             }
756             FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
757         }
758     }
759     if (s->out_format == FMT_H263) {
760         /* cbp values */
761         FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
762         s->coded_block = s->coded_block_base + s->b8_stride + 1;
763
764         /* cbp, ac_pred, pred_dir */
765         FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table     , mb_array_size * sizeof(uint8_t), fail);
766         FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
767     }
768
769     if (s->h263_pred || s->h263_plus || !s->encoding) {
770         /* dc values */
771         // MN: we need these for  error resilience of intra-frames
772         FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
773         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
774         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
775         s->dc_val[2] = s->dc_val[1] + c_size;
776         for (i = 0; i < yc_size; i++)
777             s->dc_val_base[i] = 1024;
778     }
779
780     /* which mb is a intra block */
781     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
782     memset(s->mbintra_table, 1, mb_array_size);
783
784     /* init macroblock skip table */
785     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
786     // Note the + 1 is for  a quicker mpeg4 slice_end detection
787
788     return 0;
789 fail:
790     return AVERROR(ENOMEM);
791 }
792
793 /**
794  * init common structure for both encoder and decoder.
795  * this assumes that some variables like width/height are already set
796  */
797 av_cold int ff_MPV_common_init(MpegEncContext *s)
798 {
799     int i, err;
800     int nb_slices = (HAVE_THREADS &&
801                      s->avctx->active_thread_type & FF_THREAD_SLICE) ?
802                     s->avctx->thread_count : 1;
803
804     if (s->encoding && s->avctx->slices)
805         nb_slices = s->avctx->slices;
806
807     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
808         s->mb_height = (s->height + 31) / 32 * 2;
809     else if (s->codec_id != AV_CODEC_ID_H264)
810         s->mb_height = (s->height + 15) / 16;
811
812     if (s->avctx->pix_fmt == PIX_FMT_NONE) {
813         av_log(s->avctx, AV_LOG_ERROR,
814                "decoding to PIX_FMT_NONE is not supported.\n");
815         return -1;
816     }
817
818     if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
819         int max_slices;
820         if (s->mb_height)
821             max_slices = FFMIN(MAX_THREADS, s->mb_height);
822         else
823             max_slices = MAX_THREADS;
824         av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
825                " reducing to %d\n", nb_slices, max_slices);
826         nb_slices = max_slices;
827     }
828
829     if ((s->width || s->height) &&
830         av_image_check_size(s->width, s->height, 0, s->avctx))
831         return -1;
832
833     ff_dct_common_init(s);
834
835     s->flags  = s->avctx->flags;
836     s->flags2 = s->avctx->flags2;
837
838         /* set chroma shifts */
839         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift,
840                                       &s->chroma_y_shift);
841
842     /* convert fourcc to upper case */
843     s->codec_tag        = avpriv_toupper4(s->avctx->codec_tag);
844     s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
845
846     s->avctx->coded_frame = &s->current_picture.f;
847
848     if (s->encoding) {
849         if (s->msmpeg4_version) {
850             FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
851                                 2 * 2 * (MAX_LEVEL + 1) *
852                                 (MAX_RUN + 1) * 2 * sizeof(int), fail);
853         }
854         FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
855
856         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix,          64 * 32   * sizeof(int), fail)
857         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix,   64 * 32   * sizeof(int), fail)
858         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix,          64 * 32   * sizeof(int), fail)
859         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16,        64 * 32 * 2 * sizeof(uint16_t), fail)
860         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
861         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16,        64 * 32 * 2 * sizeof(uint16_t), fail)
862         FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,           MAX_PICTURE_COUNT * sizeof(Picture *), fail)
863         FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), fail)
864
865         if (s->avctx->noise_reduction) {
866             FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail);
867         }
868     }
869
870     s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
871     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
872                       s->picture_count * sizeof(Picture), fail);
873     for (i = 0; i < s->picture_count; i++) {
874         avcodec_get_frame_defaults(&s->picture[i].f);
875     }
876
877         if ((err = init_context_frame(s)))
878             goto fail;
879
880         s->parse_context.state = -1;
881
882         s->context_initialized = 1;
883         s->thread_context[0]   = s;
884
885 //     if (s->width && s->height) {
886         if (nb_slices > 1) {
887             for (i = 1; i < nb_slices; i++) {
888                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
889                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
890             }
891
892             for (i = 0; i < nb_slices; i++) {
893                 if (init_duplicate_context(s->thread_context[i], s) < 0)
894                     goto fail;
895                     s->thread_context[i]->start_mb_y =
896                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
897                     s->thread_context[i]->end_mb_y   =
898                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
899             }
900         } else {
901             if (init_duplicate_context(s, s) < 0)
902                 goto fail;
903             s->start_mb_y = 0;
904             s->end_mb_y   = s->mb_height;
905         }
906         s->slice_context_count = nb_slices;
907 //     }
908
909     return 0;
910  fail:
911     ff_MPV_common_end(s);
912     return -1;
913 }
914
915 /**
916  * Frees and resets MpegEncContext fields depending on the resolution.
917  * Is used during resolution changes to avoid a full reinitialization of the
918  * codec.
919  */
920 static int free_context_frame(MpegEncContext *s)
921 {
922     int i, j, k;
923
924     av_freep(&s->mb_type);
925     av_freep(&s->p_mv_table_base);
926     av_freep(&s->b_forw_mv_table_base);
927     av_freep(&s->b_back_mv_table_base);
928     av_freep(&s->b_bidir_forw_mv_table_base);
929     av_freep(&s->b_bidir_back_mv_table_base);
930     av_freep(&s->b_direct_mv_table_base);
931     s->p_mv_table            = NULL;
932     s->b_forw_mv_table       = NULL;
933     s->b_back_mv_table       = NULL;
934     s->b_bidir_forw_mv_table = NULL;
935     s->b_bidir_back_mv_table = NULL;
936     s->b_direct_mv_table     = NULL;
937     for (i = 0; i < 2; i++) {
938         for (j = 0; j < 2; j++) {
939             for (k = 0; k < 2; k++) {
940                 av_freep(&s->b_field_mv_table_base[i][j][k]);
941                 s->b_field_mv_table[i][j][k] = NULL;
942             }
943             av_freep(&s->b_field_select_table[i][j]);
944             av_freep(&s->p_field_mv_table_base[i][j]);
945             s->p_field_mv_table[i][j] = NULL;
946         }
947         av_freep(&s->p_field_select_table[i]);
948     }
949
950     av_freep(&s->dc_val_base);
951     av_freep(&s->coded_block_base);
952     av_freep(&s->mbintra_table);
953     av_freep(&s->cbp_table);
954     av_freep(&s->pred_dir_table);
955
956     av_freep(&s->mbskip_table);
957
958     av_freep(&s->error_status_table);
959     av_freep(&s->er_temp_buffer);
960     av_freep(&s->mb_index2xy);
961     av_freep(&s->lambda_table);
962
963     av_freep(&s->cplx_tab);
964     av_freep(&s->bits_tab);
965
966     s->linesize = s->uvlinesize = 0;
967
968     for (i = 0; i < 3; i++)
969         av_freep(&s->visualization_buffer[i]);
970
971     if (!(s->avctx->active_thread_type & FF_THREAD_FRAME))
972         avcodec_default_free_buffers(s->avctx);
973
974     return 0;
975 }
976
977 int ff_MPV_common_frame_size_change(MpegEncContext *s)
978 {
979     int i, err = 0;
980
981     if (s->slice_context_count > 1) {
982         for (i = 0; i < s->slice_context_count; i++) {
983             free_duplicate_context(s->thread_context[i]);
984         }
985         for (i = 1; i < s->slice_context_count; i++) {
986             av_freep(&s->thread_context[i]);
987         }
988     } else
989         free_duplicate_context(s);
990
991     free_context_frame(s);
992
993     if (s->picture)
994         for (i = 0; i < s->picture_count; i++) {
995                 s->picture[i].needs_realloc = 1;
996         }
997
998     s->last_picture_ptr         =
999     s->next_picture_ptr         =
1000     s->current_picture_ptr      = NULL;
1001
1002     // init
1003     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1004         s->mb_height = (s->height + 31) / 32 * 2;
1005     else if (s->codec_id != AV_CODEC_ID_H264)
1006         s->mb_height = (s->height + 15) / 16;
1007
1008     if ((s->width || s->height) &&
1009         av_image_check_size(s->width, s->height, 0, s->avctx))
1010         return AVERROR_INVALIDDATA;
1011
1012     if ((err = init_context_frame(s)))
1013         goto fail;
1014
1015     s->thread_context[0]   = s;
1016
1017     if (s->width && s->height) {
1018         int nb_slices = s->slice_context_count;
1019         if (nb_slices > 1) {
1020             for (i = 1; i < nb_slices; i++) {
1021                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1022                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1023             }
1024
1025             for (i = 0; i < nb_slices; i++) {
1026                 if (init_duplicate_context(s->thread_context[i], s) < 0)
1027                     goto fail;
1028                     s->thread_context[i]->start_mb_y =
1029                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1030                     s->thread_context[i]->end_mb_y   =
1031                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1032             }
1033         } else {
1034             if (init_duplicate_context(s, s) < 0)
1035                 goto fail;
1036             s->start_mb_y = 0;
1037             s->end_mb_y   = s->mb_height;
1038         }
1039         s->slice_context_count = nb_slices;
1040     }
1041
1042     return 0;
1043  fail:
1044     ff_MPV_common_end(s);
1045     return err;
1046 }
1047
1048 /* init common structure for both encoder and decoder */
1049 void ff_MPV_common_end(MpegEncContext *s)
1050 {
1051     int i;
1052
1053     if (s->slice_context_count > 1) {
1054         for (i = 0; i < s->slice_context_count; i++) {
1055             free_duplicate_context(s->thread_context[i]);
1056         }
1057         for (i = 1; i < s->slice_context_count; i++) {
1058             av_freep(&s->thread_context[i]);
1059         }
1060         s->slice_context_count = 1;
1061     } else free_duplicate_context(s);
1062
1063     av_freep(&s->parse_context.buffer);
1064     s->parse_context.buffer_size = 0;
1065
1066     av_freep(&s->bitstream_buffer);
1067     s->allocated_bitstream_buffer_size = 0;
1068
1069     av_freep(&s->avctx->stats_out);
1070     av_freep(&s->ac_stats);
1071
1072     if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
1073     if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1074     s->q_chroma_intra_matrix=   NULL;
1075     s->q_chroma_intra_matrix16= NULL;
1076     av_freep(&s->q_intra_matrix);
1077     av_freep(&s->q_inter_matrix);
1078     av_freep(&s->q_intra_matrix16);
1079     av_freep(&s->q_inter_matrix16);
1080     av_freep(&s->input_picture);
1081     av_freep(&s->reordered_input_picture);
1082     av_freep(&s->dct_offset);
1083
1084     if (s->picture && !s->avctx->internal->is_copy) {
1085         for (i = 0; i < s->picture_count; i++) {
1086             free_picture(s, &s->picture[i]);
1087         }
1088     }
1089     av_freep(&s->picture);
1090
1091     free_context_frame(s);
1092
1093     s->context_initialized      = 0;
1094     s->last_picture_ptr         =
1095     s->next_picture_ptr         =
1096     s->current_picture_ptr      = NULL;
1097     s->linesize = s->uvlinesize = 0;
1098 }
1099
1100 void ff_init_rl(RLTable *rl,
1101                 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1102 {
1103     int8_t  max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1104     uint8_t index_run[MAX_RUN + 1];
1105     int last, run, level, start, end, i;
1106
1107     /* If table is static, we can quit if rl->max_level[0] is not NULL */
1108     if (static_store && rl->max_level[0])
1109         return;
1110
1111     /* compute max_level[], max_run[] and index_run[] */
1112     for (last = 0; last < 2; last++) {
1113         if (last == 0) {
1114             start = 0;
1115             end = rl->last;
1116         } else {
1117             start = rl->last;
1118             end = rl->n;
1119         }
1120
1121         memset(max_level, 0, MAX_RUN + 1);
1122         memset(max_run, 0, MAX_LEVEL + 1);
1123         memset(index_run, rl->n, MAX_RUN + 1);
1124         for (i = start; i < end; i++) {
1125             run   = rl->table_run[i];
1126             level = rl->table_level[i];
1127             if (index_run[run] == rl->n)
1128                 index_run[run] = i;
1129             if (level > max_level[run])
1130                 max_level[run] = level;
1131             if (run > max_run[level])
1132                 max_run[level] = run;
1133         }
1134         if (static_store)
1135             rl->max_level[last] = static_store[last];
1136         else
1137             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1138         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1139         if (static_store)
1140             rl->max_run[last]   = static_store[last] + MAX_RUN + 1;
1141         else
1142             rl->max_run[last]   = av_malloc(MAX_LEVEL + 1);
1143         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1144         if (static_store)
1145             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1146         else
1147             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1148         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1149     }
1150 }
1151
1152 void ff_init_vlc_rl(RLTable *rl)
1153 {
1154     int i, q;
1155
1156     for (q = 0; q < 32; q++) {
1157         int qmul = q * 2;
1158         int qadd = (q - 1) | 1;
1159
1160         if (q == 0) {
1161             qmul = 1;
1162             qadd = 0;
1163         }
1164         for (i = 0; i < rl->vlc.table_size; i++) {
1165             int code = rl->vlc.table[i][0];
1166             int len  = rl->vlc.table[i][1];
1167             int level, run;
1168
1169             if (len == 0) { // illegal code
1170                 run   = 66;
1171                 level = MAX_LEVEL;
1172             } else if (len < 0) { // more bits needed
1173                 run   = 0;
1174                 level = code;
1175             } else {
1176                 if (code == rl->n) { // esc
1177                     run   = 66;
1178                     level =  0;
1179                 } else {
1180                     run   = rl->table_run[code] + 1;
1181                     level = rl->table_level[code] * qmul + qadd;
1182                     if (code >= rl->last) run += 192;
1183                 }
1184             }
1185             rl->rl_vlc[q][i].len   = len;
1186             rl->rl_vlc[q][i].level = level;
1187             rl->rl_vlc[q][i].run   = run;
1188         }
1189     }
1190 }
1191
1192 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1193 {
1194     int i;
1195
1196     /* release non reference frames */
1197     for (i = 0; i < s->picture_count; i++) {
1198         if (s->picture[i].f.data[0] && !s->picture[i].f.reference &&
1199             (!s->picture[i].owner2 || s->picture[i].owner2 == s) &&
1200             (remove_current || &s->picture[i] !=  s->current_picture_ptr)
1201             /* && s->picture[i].type!= FF_BUFFER_TYPE_SHARED */) {
1202             free_frame_buffer(s, &s->picture[i]);
1203         }
1204     }
1205 }
1206
1207 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1208 {
1209     if (pic->f.data[0] == NULL)
1210         return 1;
1211     if (pic->needs_realloc)
1212         if (!pic->owner2 || pic->owner2 == s)
1213             return 1;
1214     return 0;
1215 }
1216
1217 static int find_unused_picture(MpegEncContext *s, int shared)
1218 {
1219     int i;
1220
1221     if (shared) {
1222         for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1223             if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
1224                 return i;
1225         }
1226     } else {
1227         for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1228             if (pic_is_unused(s, &s->picture[i]) && s->picture[i].f.type != 0)
1229                 return i; // FIXME
1230         }
1231         for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1232             if (pic_is_unused(s, &s->picture[i]))
1233                 return i;
1234         }
1235     }
1236
1237     av_log(s->avctx, AV_LOG_FATAL,
1238            "Internal error, picture buffer overflow\n");
1239     /* We could return -1, but the codec would crash trying to draw into a
1240      * non-existing frame anyway. This is safer than waiting for a random crash.
1241      * Also the return of this is never useful, an encoder must only allocate
1242      * as much as allowed in the specification. This has no relationship to how
1243      * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1244      * enough for such valid streams).
1245      * Plus, a decoder has to check stream validity and remove frames if too
1246      * many reference frames are around. Waiting for "OOM" is not correct at
1247      * all. Similarly, missing reference frames have to be replaced by
1248      * interpolated/MC frames, anything else is a bug in the codec ...
1249      */
1250     abort();
1251     return -1;
1252 }
1253
1254 int ff_find_unused_picture(MpegEncContext *s, int shared)
1255 {
1256     int ret = find_unused_picture(s, shared);
1257
1258     if (ret >= 0 && ret < s->picture_range_end) {
1259         if (s->picture[ret].needs_realloc) {
1260             s->picture[ret].needs_realloc = 0;
1261             free_picture(s, &s->picture[ret]);
1262             avcodec_get_frame_defaults(&s->picture[ret].f);
1263         }
1264     }
1265     return ret;
1266 }
1267
1268 static void update_noise_reduction(MpegEncContext *s)
1269 {
1270     int intra, i;
1271
1272     for (intra = 0; intra < 2; intra++) {
1273         if (s->dct_count[intra] > (1 << 16)) {
1274             for (i = 0; i < 64; i++) {
1275                 s->dct_error_sum[intra][i] >>= 1;
1276             }
1277             s->dct_count[intra] >>= 1;
1278         }
1279
1280         for (i = 0; i < 64; i++) {
1281             s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1282                                        s->dct_count[intra] +
1283                                        s->dct_error_sum[intra][i] / 2) /
1284                                       (s->dct_error_sum[intra][i] + 1);
1285         }
1286     }
1287 }
1288
1289 /**
1290  * generic function for encode/decode called after coding/decoding
1291  * the header and before a frame is coded/decoded.
1292  */
1293 int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1294 {
1295     int i;
1296     Picture *pic;
1297     s->mb_skipped = 0;
1298
1299     if (!ff_thread_can_start_frame(avctx)) {
1300         av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1301         return -1;
1302     }
1303
1304     /* mark & release old frames */
1305     if (s->out_format != FMT_H264 || s->codec_id == AV_CODEC_ID_SVQ3) {
1306         if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1307             s->last_picture_ptr != s->next_picture_ptr &&
1308             s->last_picture_ptr->f.data[0]) {
1309             if (s->last_picture_ptr->owner2 == s)
1310                 free_frame_buffer(s, s->last_picture_ptr);
1311         }
1312
1313         /* release forgotten pictures */
1314         /* if (mpeg124/h263) */
1315         if (!s->encoding) {
1316             for (i = 0; i < s->picture_count; i++) {
1317                 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] &&
1318                     &s->picture[i] != s->last_picture_ptr &&
1319                     &s->picture[i] != s->next_picture_ptr &&
1320                     s->picture[i].f.reference && !s->picture[i].needs_realloc) {
1321                     if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1322                         av_log(avctx, AV_LOG_ERROR,
1323                                "releasing zombie picture\n");
1324                     free_frame_buffer(s, &s->picture[i]);
1325                 }
1326             }
1327         }
1328     }
1329
1330     if (!s->encoding) {
1331         ff_release_unused_pictures(s, 1);
1332
1333         if (s->current_picture_ptr &&
1334             s->current_picture_ptr->f.data[0] == NULL) {
1335             // we already have a unused image
1336             // (maybe it was set before reading the header)
1337             pic = s->current_picture_ptr;
1338         } else {
1339             i   = ff_find_unused_picture(s, 0);
1340             if (i < 0) {
1341                 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1342                 return i;
1343             }
1344             pic = &s->picture[i];
1345         }
1346
1347         pic->f.reference = 0;
1348         if (!s->dropable) {
1349             if (s->codec_id == AV_CODEC_ID_H264)
1350                 pic->f.reference = s->picture_structure;
1351             else if (s->pict_type != AV_PICTURE_TYPE_B)
1352                 pic->f.reference = 3;
1353         }
1354
1355         pic->f.coded_picture_number = s->coded_picture_number++;
1356
1357         if (ff_alloc_picture(s, pic, 0) < 0)
1358             return -1;
1359
1360         s->current_picture_ptr = pic;
1361         // FIXME use only the vars from current_pic
1362         s->current_picture_ptr->f.top_field_first = s->top_field_first;
1363         if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1364             s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1365             if (s->picture_structure != PICT_FRAME)
1366                 s->current_picture_ptr->f.top_field_first =
1367                     (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1368         }
1369         s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1370                                                      !s->progressive_sequence;
1371         s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
1372     }
1373
1374     s->current_picture_ptr->f.pict_type = s->pict_type;
1375     // if (s->flags && CODEC_FLAG_QSCALE)
1376     //     s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1377     s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1378
1379     ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1380
1381     if (s->pict_type != AV_PICTURE_TYPE_B) {
1382         s->last_picture_ptr = s->next_picture_ptr;
1383         if (!s->dropable)
1384             s->next_picture_ptr = s->current_picture_ptr;
1385     }
1386     /* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1387            s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1388            s->last_picture_ptr    ? s->last_picture_ptr->f.data[0]    : NULL,
1389            s->next_picture_ptr    ? s->next_picture_ptr->f.data[0]    : NULL,
1390            s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1391            s->pict_type, s->dropable); */
1392
1393     if (s->codec_id != AV_CODEC_ID_H264) {
1394         if ((s->last_picture_ptr == NULL ||
1395              s->last_picture_ptr->f.data[0] == NULL) &&
1396             (s->pict_type != AV_PICTURE_TYPE_I ||
1397              s->picture_structure != PICT_FRAME)) {
1398             if (s->pict_type != AV_PICTURE_TYPE_I)
1399                 av_log(avctx, AV_LOG_ERROR,
1400                        "warning: first frame is no keyframe\n");
1401             else if (s->picture_structure != PICT_FRAME)
1402                 av_log(avctx, AV_LOG_INFO,
1403                        "allocate dummy last picture for field based first keyframe\n");
1404
1405             /* Allocate a dummy frame */
1406             i = ff_find_unused_picture(s, 0);
1407             if (i < 0) {
1408                 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1409                 return i;
1410             }
1411             s->last_picture_ptr = &s->picture[i];
1412             s->last_picture_ptr->f.key_frame = 0;
1413             if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1414                 s->last_picture_ptr = NULL;
1415                 return -1;
1416             }
1417
1418             if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1419                 for(i=0; i<avctx->height; i++)
1420                     memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);
1421             }
1422
1423             ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 0);
1424             ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 1);
1425             s->last_picture_ptr->f.reference = 3;
1426         }
1427         if ((s->next_picture_ptr == NULL ||
1428              s->next_picture_ptr->f.data[0] == NULL) &&
1429             s->pict_type == AV_PICTURE_TYPE_B) {
1430             /* Allocate a dummy frame */
1431             i = ff_find_unused_picture(s, 0);
1432             if (i < 0) {
1433                 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1434                 return i;
1435             }
1436             s->next_picture_ptr = &s->picture[i];
1437             s->next_picture_ptr->f.key_frame = 0;
1438             if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1439                 s->next_picture_ptr = NULL;
1440                 return -1;
1441             }
1442             ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 0);
1443             ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 1);
1444             s->next_picture_ptr->f.reference = 3;
1445         }
1446     }
1447
1448     if (s->last_picture_ptr)
1449         ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1450     if (s->next_picture_ptr)
1451         ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1452
1453     if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME) &&
1454         (s->out_format != FMT_H264 || s->codec_id == AV_CODEC_ID_SVQ3)) {
1455         if (s->next_picture_ptr)
1456             s->next_picture_ptr->owner2 = s;
1457         if (s->last_picture_ptr)
1458             s->last_picture_ptr->owner2 = s;
1459     }
1460
1461     assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1462                                                  s->last_picture_ptr->f.data[0]));
1463
1464     if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1465         int i;
1466         for (i = 0; i < 4; i++) {
1467             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1468                 s->current_picture.f.data[i] +=
1469                     s->current_picture.f.linesize[i];
1470             }
1471             s->current_picture.f.linesize[i] *= 2;
1472             s->last_picture.f.linesize[i]    *= 2;
1473             s->next_picture.f.linesize[i]    *= 2;
1474         }
1475     }
1476
1477     s->err_recognition = avctx->err_recognition;
1478
1479     /* set dequantizer, we can't do it during init as
1480      * it might change for mpeg4 and we can't do it in the header
1481      * decode as init is not called for mpeg4 there yet */
1482     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1483         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1484         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1485     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1486         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1487         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1488     } else {
1489         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1490         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1491     }
1492
1493     if (s->dct_error_sum) {
1494         assert(s->avctx->noise_reduction && s->encoding);
1495         update_noise_reduction(s);
1496     }
1497
1498     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1499         return ff_xvmc_field_start(s, avctx);
1500
1501     return 0;
1502 }
1503
1504 /* generic function for encode/decode called after a
1505  * frame has been coded/decoded. */
1506 void ff_MPV_frame_end(MpegEncContext *s)
1507 {
1508     int i;
1509     /* redraw edges for the frame if decoding didn't complete */
1510     // just to make sure that all data is rendered.
1511     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1512         ff_xvmc_field_end(s);
1513    } else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1514               !s->avctx->hwaccel &&
1515               !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1516               s->unrestricted_mv &&
1517               s->current_picture.f.reference &&
1518               !s->intra_only &&
1519               !(s->flags & CODEC_FLAG_EMU_EDGE) &&
1520               !s->avctx->lowres
1521             ) {
1522         int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
1523         int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
1524         s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1525                           s->h_edge_pos, s->v_edge_pos,
1526                           EDGE_WIDTH, EDGE_WIDTH,
1527                           EDGE_TOP | EDGE_BOTTOM);
1528         s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1529                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1530                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1531                           EDGE_TOP | EDGE_BOTTOM);
1532         s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1533                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1534                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1535                           EDGE_TOP | EDGE_BOTTOM);
1536     }
1537
1538     emms_c();
1539
1540     s->last_pict_type                 = s->pict_type;
1541     s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1542     if (s->pict_type!= AV_PICTURE_TYPE_B) {
1543         s->last_non_b_pict_type = s->pict_type;
1544     }
1545 #if 0
1546     /* copy back current_picture variables */
1547     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1548         if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1549             s->picture[i] = s->current_picture;
1550             break;
1551         }
1552     }
1553     assert(i < MAX_PICTURE_COUNT);
1554 #endif
1555
1556     if (s->encoding) {
1557         /* release non-reference frames */
1558         for (i = 0; i < s->picture_count; i++) {
1559             if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1560                 /* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1561                 free_frame_buffer(s, &s->picture[i]);
1562             }
1563         }
1564     }
1565     // clear copies, to avoid confusion
1566 #if 0
1567     memset(&s->last_picture,    0, sizeof(Picture));
1568     memset(&s->next_picture,    0, sizeof(Picture));
1569     memset(&s->current_picture, 0, sizeof(Picture));
1570 #endif
1571     s->avctx->coded_frame = &s->current_picture_ptr->f;
1572
1573     if (s->codec_id != AV_CODEC_ID_H264 && s->current_picture.f.reference) {
1574         ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
1575     }
1576 }
1577
1578 /**
1579  * Draw a line from (ex, ey) -> (sx, sy).
1580  * @param w width of the image
1581  * @param h height of the image
1582  * @param stride stride/linesize of the image
1583  * @param color color of the arrow
1584  */
1585 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1586                       int w, int h, int stride, int color)
1587 {
1588     int x, y, fr, f;
1589
1590     sx = av_clip(sx, 0, w - 1);
1591     sy = av_clip(sy, 0, h - 1);
1592     ex = av_clip(ex, 0, w - 1);
1593     ey = av_clip(ey, 0, h - 1);
1594
1595     buf[sy * stride + sx] += color;
1596
1597     if (FFABS(ex - sx) > FFABS(ey - sy)) {
1598         if (sx > ex) {
1599             FFSWAP(int, sx, ex);
1600             FFSWAP(int, sy, ey);
1601         }
1602         buf += sx + sy * stride;
1603         ex  -= sx;
1604         f    = ((ey - sy) << 16) / ex;
1605         for(x= 0; x <= ex; x++){
1606             y  = (x * f) >> 16;
1607             fr = (x * f) & 0xFFFF;
1608             buf[y * stride + x]       += (color * (0x10000 - fr)) >> 16;
1609             if(fr) buf[(y + 1) * stride + x] += (color *            fr ) >> 16;
1610         }
1611     } else {
1612         if (sy > ey) {
1613             FFSWAP(int, sx, ex);
1614             FFSWAP(int, sy, ey);
1615         }
1616         buf += sx + sy * stride;
1617         ey  -= sy;
1618         if (ey)
1619             f = ((ex - sx) << 16) / ey;
1620         else
1621             f = 0;
1622         for(y= 0; y <= ey; y++){
1623             x  = (y*f) >> 16;
1624             fr = (y*f) & 0xFFFF;
1625             buf[y * stride + x]     += (color * (0x10000 - fr)) >> 16;
1626             if(fr) buf[y * stride + x + 1] += (color *            fr ) >> 16;
1627         }
1628     }
1629 }
1630
1631 /**
1632  * Draw an arrow from (ex, ey) -> (sx, sy).
1633  * @param w width of the image
1634  * @param h height of the image
1635  * @param stride stride/linesize of the image
1636  * @param color color of the arrow
1637  */
1638 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1639                        int ey, int w, int h, int stride, int color)
1640 {
1641     int dx,dy;
1642
1643     sx = av_clip(sx, -100, w + 100);
1644     sy = av_clip(sy, -100, h + 100);
1645     ex = av_clip(ex, -100, w + 100);
1646     ey = av_clip(ey, -100, h + 100);
1647
1648     dx = ex - sx;
1649     dy = ey - sy;
1650
1651     if (dx * dx + dy * dy > 3 * 3) {
1652         int rx =  dx + dy;
1653         int ry = -dx + dy;
1654         int length = ff_sqrt((rx * rx + ry * ry) << 8);
1655
1656         // FIXME subpixel accuracy
1657         rx = ROUNDED_DIV(rx * 3 << 4, length);
1658         ry = ROUNDED_DIV(ry * 3 << 4, length);
1659
1660         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1661         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1662     }
1663     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1664 }
1665
1666 /**
1667  * Print debugging info for the given picture.
1668  */
1669 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1670 {
1671     if (   s->avctx->hwaccel || !pict || !pict->mb_type
1672         || (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
1673         return;
1674
1675
1676     if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1677         int x,y;
1678
1679         av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1680                av_get_picture_type_char(pict->pict_type));
1681         for (y = 0; y < s->mb_height; y++) {
1682             for (x = 0; x < s->mb_width; x++) {
1683                 if (s->avctx->debug & FF_DEBUG_SKIP) {
1684                     int count = s->mbskip_table[x + y * s->mb_stride];
1685                     if (count > 9)
1686                         count = 9;
1687                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1688                 }
1689                 if (s->avctx->debug & FF_DEBUG_QP) {
1690                     av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1691                            pict->qscale_table[x + y * s->mb_stride]);
1692                 }
1693                 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1694                     int mb_type = pict->mb_type[x + y * s->mb_stride];
1695                     // Type & MV direction
1696                     if (IS_PCM(mb_type))
1697                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1698                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1699                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1700                     else if (IS_INTRA4x4(mb_type))
1701                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1702                     else if (IS_INTRA16x16(mb_type))
1703                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1704                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1705                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1706                     else if (IS_DIRECT(mb_type))
1707                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1708                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1709                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1710                     else if (IS_GMC(mb_type))
1711                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1712                     else if (IS_SKIP(mb_type))
1713                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1714                     else if (!USES_LIST(mb_type, 1))
1715                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1716                     else if (!USES_LIST(mb_type, 0))
1717                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1718                     else {
1719                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1720                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1721                     }
1722
1723                     // segmentation
1724                     if (IS_8X8(mb_type))
1725                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1726                     else if (IS_16X8(mb_type))
1727                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1728                     else if (IS_8X16(mb_type))
1729                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1730                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1731                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1732                     else
1733                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1734
1735
1736                     if (IS_INTERLACED(mb_type))
1737                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1738                     else
1739                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1740                 }
1741                 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1742             }
1743             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1744         }
1745     }
1746
1747     if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1748         (s->avctx->debug_mv)) {
1749         const int shift = 1 + s->quarter_sample;
1750         int mb_y;
1751         uint8_t *ptr;
1752         int i;
1753         int h_chroma_shift, v_chroma_shift, block_height;
1754         const int width          = s->avctx->width;
1755         const int height         = s->avctx->height;
1756         const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1757         const int mv_stride      = (s->mb_width << mv_sample_log2) +
1758                                    (s->codec_id == AV_CODEC_ID_H264 ? 0 : 1);
1759         s->low_delay = 0; // needed to see the vectors without trashing the buffers
1760
1761         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,
1762                                       &h_chroma_shift, &v_chroma_shift);
1763         for (i = 0; i < 3; i++) {
1764             size_t size= (i == 0) ? pict->linesize[i] * FFALIGN(height, 16):
1765                          pict->linesize[i] * FFALIGN(height, 16) >> v_chroma_shift;
1766             s->visualization_buffer[i]= av_realloc(s->visualization_buffer[i], size);
1767             memcpy(s->visualization_buffer[i], pict->data[i], size);
1768             pict->data[i] = s->visualization_buffer[i];
1769         }
1770         pict->type   = FF_BUFFER_TYPE_COPY;
1771         pict->opaque= NULL;
1772         ptr          = pict->data[0];
1773         block_height = 16 >> v_chroma_shift;
1774
1775         for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1776             int mb_x;
1777             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1778                 const int mb_index = mb_x + mb_y * s->mb_stride;
1779                 if ((s->avctx->debug_mv) && pict->motion_val) {
1780                     int type;
1781                     for (type = 0; type < 3; type++) {
1782                         int direction = 0;
1783                         switch (type) {
1784                         case 0:
1785                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1786                                 (pict->pict_type!= AV_PICTURE_TYPE_P))
1787                                 continue;
1788                             direction = 0;
1789                             break;
1790                         case 1:
1791                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1792                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
1793                                 continue;
1794                             direction = 0;
1795                             break;
1796                         case 2:
1797                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1798                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
1799                                 continue;
1800                             direction = 1;
1801                             break;
1802                         }
1803                         if (!USES_LIST(pict->mb_type[mb_index], direction))
1804                             continue;
1805
1806                         if (IS_8X8(pict->mb_type[mb_index])) {
1807                             int i;
1808                             for (i = 0; i < 4; i++) {
1809                                 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1810                                 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1811                                 int xy = (mb_x * 2 + (i & 1) +
1812                                           (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1813                                 int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1814                                 int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1815                                 draw_arrow(ptr, sx, sy, mx, my, width,
1816                                            height, s->linesize, 100);
1817                             }
1818                         } else if (IS_16X8(pict->mb_type[mb_index])) {
1819                             int i;
1820                             for (i = 0; i < 2; i++) {
1821                                 int sx = mb_x * 16 + 8;
1822                                 int sy = mb_y * 16 + 4 + 8 * i;
1823                                 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1824                                 int mx = (pict->motion_val[direction][xy][0] >> shift);
1825                                 int my = (pict->motion_val[direction][xy][1] >> shift);
1826
1827                                 if (IS_INTERLACED(pict->mb_type[mb_index]))
1828                                     my *= 2;
1829
1830                             draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1831                                        height, s->linesize, 100);
1832                             }
1833                         } else if (IS_8X16(pict->mb_type[mb_index])) {
1834                             int i;
1835                             for (i = 0; i < 2; i++) {
1836                                 int sx = mb_x * 16 + 4 + 8 * i;
1837                                 int sy = mb_y * 16 + 8;
1838                                 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1839                                 int mx = pict->motion_val[direction][xy][0] >> shift;
1840                                 int my = pict->motion_val[direction][xy][1] >> shift;
1841
1842                                 if (IS_INTERLACED(pict->mb_type[mb_index]))
1843                                     my *= 2;
1844
1845                                 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1846                                            height, s->linesize, 100);
1847                             }
1848                         } else {
1849                               int sx= mb_x * 16 + 8;
1850                               int sy= mb_y * 16 + 8;
1851                               int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1852                               int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1853                               int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1854                               draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1855                         }
1856                     }
1857                 }
1858                 if ((s->avctx->debug & FF_DEBUG_VIS_QP) && pict->motion_val) {
1859                     uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1860                                  0x0101010101010101ULL;
1861                     int y;
1862                     for (y = 0; y < block_height; y++) {
1863                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
1864                                       (block_height * mb_y + y) *
1865                                       pict->linesize[1]) = c;
1866                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
1867                                       (block_height * mb_y + y) *
1868                                       pict->linesize[2]) = c;
1869                     }
1870                 }
1871                 if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
1872                     pict->motion_val) {
1873                     int mb_type = pict->mb_type[mb_index];
1874                     uint64_t u,v;
1875                     int y;
1876 #define COLOR(theta, r) \
1877     u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1878     v = (int)(128 + r * sin(theta * 3.141592 / 180));
1879
1880
1881                     u = v = 128;
1882                     if (IS_PCM(mb_type)) {
1883                         COLOR(120, 48)
1884                     } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
1885                                IS_INTRA16x16(mb_type)) {
1886                         COLOR(30, 48)
1887                     } else if (IS_INTRA4x4(mb_type)) {
1888                         COLOR(90, 48)
1889                     } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
1890                         // COLOR(120, 48)
1891                     } else if (IS_DIRECT(mb_type)) {
1892                         COLOR(150, 48)
1893                     } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
1894                         COLOR(170, 48)
1895                     } else if (IS_GMC(mb_type)) {
1896                         COLOR(190, 48)
1897                     } else if (IS_SKIP(mb_type)) {
1898                         // COLOR(180, 48)
1899                     } else if (!USES_LIST(mb_type, 1)) {
1900                         COLOR(240, 48)
1901                     } else if (!USES_LIST(mb_type, 0)) {
1902                         COLOR(0, 48)
1903                     } else {
1904                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1905                         COLOR(300,48)
1906                     }
1907
1908                     u *= 0x0101010101010101ULL;
1909                     v *= 0x0101010101010101ULL;
1910                     for (y = 0; y < block_height; y++) {
1911                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
1912                                       (block_height * mb_y + y) * pict->linesize[1]) = u;
1913                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
1914                                       (block_height * mb_y + y) * pict->linesize[2]) = v;
1915                     }
1916
1917                     // segmentation
1918                     if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
1919                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
1920                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1921                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
1922                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1923                     }
1924                     if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
1925                         for (y = 0; y < 16; y++)
1926                             pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1927                                           pict->linesize[0]] ^= 0x80;
1928                     }
1929                     if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1930                         int dm = 1 << (mv_sample_log2 - 2);
1931                         for (i = 0; i < 4; i++) {
1932                             int sx = mb_x * 16 + 8 * (i & 1);
1933                             int sy = mb_y * 16 + 8 * (i >> 1);
1934                             int xy = (mb_x * 2 + (i & 1) +
1935                                      (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1936                             // FIXME bidir
1937                             int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
1938                             if (mv[0] != mv[dm] ||
1939                                 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1940                                 for (y = 0; y < 8; y++)
1941                                     pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
1942                             if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1943                                 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
1944                                               pict->linesize[0]) ^= 0x8080808080808080ULL;
1945                         }
1946                     }
1947
1948                     if (IS_INTERLACED(mb_type) &&
1949                         s->codec_id == AV_CODEC_ID_H264) {
1950                         // hmm
1951                     }
1952                 }
1953                 s->mbskip_table[mb_index] = 0;
1954             }
1955         }
1956     }
1957 }
1958
1959 static inline int hpel_motion_lowres(MpegEncContext *s,
1960                                      uint8_t *dest, uint8_t *src,
1961                                      int field_based, int field_select,
1962                                      int src_x, int src_y,
1963                                      int width, int height, int stride,
1964                                      int h_edge_pos, int v_edge_pos,
1965                                      int w, int h, h264_chroma_mc_func *pix_op,
1966                                      int motion_x, int motion_y)
1967 {
1968     const int lowres   = s->avctx->lowres;
1969     const int op_index = FFMIN(lowres, 2);
1970     const int s_mask   = (2 << lowres) - 1;
1971     int emu = 0;
1972     int sx, sy;
1973
1974     if (s->quarter_sample) {
1975         motion_x /= 2;
1976         motion_y /= 2;
1977     }
1978
1979     sx = motion_x & s_mask;
1980     sy = motion_y & s_mask;
1981     src_x += motion_x >> lowres + 1;
1982     src_y += motion_y >> lowres + 1;
1983
1984     src   += src_y * stride + src_x;
1985
1986     if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w,                 0) ||
1987         (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1988         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
1989                                 (h + 1) << field_based, src_x,
1990                                 src_y   << field_based,
1991                                 h_edge_pos,
1992                                 v_edge_pos);
1993         src = s->edge_emu_buffer;
1994         emu = 1;
1995     }
1996
1997     sx = (sx << 2) >> lowres;
1998     sy = (sy << 2) >> lowres;
1999     if (field_select)
2000         src += s->linesize;
2001     pix_op[op_index](dest, src, stride, h, sx, sy);
2002     return emu;
2003 }
2004
2005 /* apply one mpeg motion vector to the three components */
2006 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2007                                                 uint8_t *dest_y,
2008                                                 uint8_t *dest_cb,
2009                                                 uint8_t *dest_cr,
2010                                                 int field_based,
2011                                                 int bottom_field,
2012                                                 int field_select,
2013                                                 uint8_t **ref_picture,
2014                                                 h264_chroma_mc_func *pix_op,
2015                                                 int motion_x, int motion_y,
2016                                                 int h, int mb_y)
2017 {
2018     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2019     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
2020         uvsx, uvsy;
2021     const int lowres     = s->avctx->lowres;
2022     const int op_index   = FFMIN(lowres-1+s->chroma_x_shift, 2);
2023     const int block_s    = 8>>lowres;
2024     const int s_mask     = (2 << lowres) - 1;
2025     const int h_edge_pos = s->h_edge_pos >> lowres;
2026     const int v_edge_pos = s->v_edge_pos >> lowres;
2027     linesize   = s->current_picture.f.linesize[0] << field_based;
2028     uvlinesize = s->current_picture.f.linesize[1] << field_based;
2029
2030     // FIXME obviously not perfect but qpel will not work in lowres anyway
2031     if (s->quarter_sample) {
2032         motion_x /= 2;
2033         motion_y /= 2;
2034     }
2035
2036     if(field_based){
2037         motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2038     }
2039
2040     sx = motion_x & s_mask;
2041     sy = motion_y & s_mask;
2042     src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2043     src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2044
2045     if (s->out_format == FMT_H263) {
2046         uvsx    = ((motion_x >> 1) & s_mask) | (sx & 1);
2047         uvsy    = ((motion_y >> 1) & s_mask) | (sy & 1);
2048         uvsrc_x = src_x >> 1;
2049         uvsrc_y = src_y >> 1;
2050     } else if (s->out_format == FMT_H261) {
2051         // even chroma mv's are full pel in H261
2052         mx      = motion_x / 4;
2053         my      = motion_y / 4;
2054         uvsx    = (2 * mx) & s_mask;
2055         uvsy    = (2 * my) & s_mask;
2056         uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2057         uvsrc_y =    mb_y * block_s + (my >> lowres);
2058     } else {
2059         if(s->chroma_y_shift){
2060             mx      = motion_x / 2;
2061             my      = motion_y / 2;
2062             uvsx    = mx & s_mask;
2063             uvsy    = my & s_mask;
2064             uvsrc_x = s->mb_x * block_s                 + (mx >> lowres + 1);
2065             uvsrc_y =   (mb_y * block_s >> field_based) + (my >> lowres + 1);
2066         } else {
2067             if(s->chroma_x_shift){
2068             //Chroma422
2069                 mx = motion_x / 2;
2070                 uvsx = mx & s_mask;
2071                 uvsy = motion_y & s_mask;
2072                 uvsrc_y = src_y;
2073                 uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2074             } else {
2075             //Chroma444
2076                 uvsx = motion_x & s_mask;
2077                 uvsy = motion_y & s_mask;
2078                 uvsrc_x = src_x;
2079                 uvsrc_y = src_y;
2080             }
2081         }
2082     }
2083
2084     ptr_y  = ref_picture[0] + src_y   * linesize   + src_x;
2085     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2086     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2087
2088     if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s,       0) ||
2089         (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2090         s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2091                                 s->linesize, 17, 17 + field_based,
2092                                 src_x, src_y << field_based, h_edge_pos,
2093                                 v_edge_pos);
2094         ptr_y = s->edge_emu_buffer;
2095         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2096             uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
2097             s->dsp.emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9,
2098                                     9 + field_based,
2099                                     uvsrc_x, uvsrc_y << field_based,
2100                                     h_edge_pos >> 1, v_edge_pos >> 1);
2101             s->dsp.emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9,
2102                                     9 + field_based,
2103                                     uvsrc_x, uvsrc_y << field_based,
2104                                     h_edge_pos >> 1, v_edge_pos >> 1);
2105             ptr_cb = uvbuf;
2106             ptr_cr = uvbuf + 16;
2107         }
2108     }
2109
2110     // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
2111     if (bottom_field) {
2112         dest_y  += s->linesize;
2113         dest_cb += s->uvlinesize;
2114         dest_cr += s->uvlinesize;
2115     }
2116
2117     if (field_select) {
2118         ptr_y   += s->linesize;
2119         ptr_cb  += s->uvlinesize;
2120         ptr_cr  += s->uvlinesize;
2121     }
2122
2123     sx = (sx << 2) >> lowres;
2124     sy = (sy << 2) >> lowres;
2125     pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2126
2127     if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2128         uvsx = (uvsx << 2) >> lowres;
2129         uvsy = (uvsy << 2) >> lowres;
2130         if (h >> s->chroma_y_shift) {
2131             pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2132             pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2133         }
2134     }
2135     // FIXME h261 lowres loop filter
2136 }
2137
2138 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2139                                             uint8_t *dest_cb, uint8_t *dest_cr,
2140                                             uint8_t **ref_picture,
2141                                             h264_chroma_mc_func * pix_op,
2142                                             int mx, int my)
2143 {
2144     const int lowres     = s->avctx->lowres;
2145     const int op_index   = FFMIN(lowres, 2);
2146     const int block_s    = 8 >> lowres;
2147     const int s_mask     = (2 << lowres) - 1;
2148     const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2149     const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2150     int emu = 0, src_x, src_y, offset, sx, sy;
2151     uint8_t *ptr;
2152
2153     if (s->quarter_sample) {
2154         mx /= 2;
2155         my /= 2;
2156     }
2157
2158     /* In case of 8X8, we construct a single chroma motion vector
2159        with a special rounding */
2160     mx = ff_h263_round_chroma(mx);
2161     my = ff_h263_round_chroma(my);
2162
2163     sx = mx & s_mask;
2164     sy = my & s_mask;
2165     src_x = s->mb_x * block_s + (mx >> lowres + 1);
2166     src_y = s->mb_y * block_s + (my >> lowres + 1);
2167
2168     offset = src_y * s->uvlinesize + src_x;
2169     ptr = ref_picture[1] + offset;
2170     if (s->flags & CODEC_FLAG_EMU_EDGE) {
2171         if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2172             (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2173             s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
2174                                     9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2175             ptr = s->edge_emu_buffer;
2176             emu = 1;
2177         }
2178     }
2179     sx = (sx << 2) >> lowres;
2180     sy = (sy << 2) >> lowres;
2181     pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2182
2183     ptr = ref_picture[2] + offset;
2184     if (emu) {
2185         s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2186                                 src_x, src_y, h_edge_pos, v_edge_pos);
2187         ptr = s->edge_emu_buffer;
2188     }
2189     pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2190 }
2191
2192 /**
2193  * motion compensation of a single macroblock
2194  * @param s context
2195  * @param dest_y luma destination pointer
2196  * @param dest_cb chroma cb/u destination pointer
2197  * @param dest_cr chroma cr/v destination pointer
2198  * @param dir direction (0->forward, 1->backward)
2199  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2200  * @param pix_op halfpel motion compensation function (average or put normally)
2201  * the motion vectors are taken from s->mv and the MV type from s->mv_type
2202  */
2203 static inline void MPV_motion_lowres(MpegEncContext *s,
2204                                      uint8_t *dest_y, uint8_t *dest_cb,
2205                                      uint8_t *dest_cr,
2206                                      int dir, uint8_t **ref_picture,
2207                                      h264_chroma_mc_func *pix_op)
2208 {
2209     int mx, my;
2210     int mb_x, mb_y, i;
2211     const int lowres  = s->avctx->lowres;
2212     const int block_s = 8 >>lowres;
2213
2214     mb_x = s->mb_x;
2215     mb_y = s->mb_y;
2216
2217     switch (s->mv_type) {
2218     case MV_TYPE_16X16:
2219         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2220                            0, 0, 0,
2221                            ref_picture, pix_op,
2222                            s->mv[dir][0][0], s->mv[dir][0][1],
2223                            2 * block_s, mb_y);
2224         break;
2225     case MV_TYPE_8X8:
2226         mx = 0;
2227         my = 0;
2228         for (i = 0; i < 4; i++) {
2229             hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2230                                s->linesize) * block_s,
2231                                ref_picture[0], 0, 0,
2232                                (2 * mb_x + (i & 1)) * block_s,
2233                                (2 * mb_y + (i >> 1)) * block_s,
2234                                s->width, s->height, s->linesize,
2235                                s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2236                                block_s, block_s, pix_op,
2237                                s->mv[dir][i][0], s->mv[dir][i][1]);
2238
2239             mx += s->mv[dir][i][0];
2240             my += s->mv[dir][i][1];
2241         }
2242
2243         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2244             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2245                                      pix_op, mx, my);
2246         break;
2247     case MV_TYPE_FIELD:
2248         if (s->picture_structure == PICT_FRAME) {
2249             /* top field */
2250             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2251                                1, 0, s->field_select[dir][0],
2252                                ref_picture, pix_op,
2253                                s->mv[dir][0][0], s->mv[dir][0][1],
2254                                block_s, mb_y);
2255             /* bottom field */
2256             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2257                                1, 1, s->field_select[dir][1],
2258                                ref_picture, pix_op,
2259                                s->mv[dir][1][0], s->mv[dir][1][1],
2260                                block_s, mb_y);
2261         } else {
2262             if (s->picture_structure != s->field_select[dir][0] + 1 &&
2263                 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2264                 ref_picture = s->current_picture_ptr->f.data;
2265
2266             }
2267             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2268                                0, 0, s->field_select[dir][0],
2269                                ref_picture, pix_op,
2270                                s->mv[dir][0][0],
2271                                s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2272             }
2273         break;
2274     case MV_TYPE_16X8:
2275         for (i = 0; i < 2; i++) {
2276             uint8_t **ref2picture;
2277
2278             if (s->picture_structure == s->field_select[dir][i] + 1 ||
2279                 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2280                 ref2picture = ref_picture;
2281             } else {
2282                 ref2picture = s->current_picture_ptr->f.data;
2283             }
2284
2285             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2286                                0, 0, s->field_select[dir][i],
2287                                ref2picture, pix_op,
2288                                s->mv[dir][i][0], s->mv[dir][i][1] +
2289                                2 * block_s * i, block_s, mb_y >> 1);
2290
2291             dest_y  +=  2 * block_s *  s->linesize;
2292             dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2293             dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2294         }
2295         break;
2296     case MV_TYPE_DMV:
2297         if (s->picture_structure == PICT_FRAME) {
2298             for (i = 0; i < 2; i++) {
2299                 int j;
2300                 for (j = 0; j < 2; j++) {
2301                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2302                                        1, j, j ^ i,
2303                                        ref_picture, pix_op,
2304                                        s->mv[dir][2 * i + j][0],
2305                                        s->mv[dir][2 * i + j][1],
2306                                        block_s, mb_y);
2307                 }
2308                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2309             }
2310         } else {
2311             for (i = 0; i < 2; i++) {
2312                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2313                                    0, 0, s->picture_structure != i + 1,
2314                                    ref_picture, pix_op,
2315                                    s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2316                                    2 * block_s, mb_y >> 1);
2317
2318                 // after put we make avg of the same block
2319                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2320
2321                 // opposite parity is always in the same
2322                 // frame if this is second field
2323                 if (!s->first_field) {
2324                     ref_picture = s->current_picture_ptr->f.data;
2325                 }
2326             }
2327         }
2328         break;
2329     default:
2330         av_assert2(0);
2331     }
2332 }
2333
2334 /**
2335  * find the lowest MB row referenced in the MVs
2336  */
2337 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2338 {
2339     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2340     int my, off, i, mvs;
2341
2342     if (s->picture_structure != PICT_FRAME) goto unhandled;
2343
2344     switch (s->mv_type) {
2345         case MV_TYPE_16X16:
2346             mvs = 1;
2347             break;
2348         case MV_TYPE_16X8:
2349             mvs = 2;
2350             break;
2351         case MV_TYPE_8X8:
2352             mvs = 4;
2353             break;
2354         default:
2355             goto unhandled;
2356     }
2357
2358     for (i = 0; i < mvs; i++) {
2359         my = s->mv[dir][i][1]<<qpel_shift;
2360         my_max = FFMAX(my_max, my);
2361         my_min = FFMIN(my_min, my);
2362     }
2363
2364     off = (FFMAX(-my_min, my_max) + 63) >> 6;
2365
2366     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2367 unhandled:
2368     return s->mb_height-1;
2369 }
2370
2371 /* put block[] to dest[] */
2372 static inline void put_dct(MpegEncContext *s,
2373                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2374 {
2375     s->dct_unquantize_intra(s, block, i, qscale);
2376     s->dsp.idct_put (dest, line_size, block);
2377 }
2378
2379 /* add block[] to dest[] */
2380 static inline void add_dct(MpegEncContext *s,
2381                            DCTELEM *block, int i, uint8_t *dest, int line_size)
2382 {
2383     if (s->block_last_index[i] >= 0) {
2384         s->dsp.idct_add (dest, line_size, block);
2385     }
2386 }
2387
2388 static inline void add_dequant_dct(MpegEncContext *s,
2389                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2390 {
2391     if (s->block_last_index[i] >= 0) {
2392         s->dct_unquantize_inter(s, block, i, qscale);
2393
2394         s->dsp.idct_add (dest, line_size, block);
2395     }
2396 }
2397
2398 /**
2399  * Clean dc, ac, coded_block for the current non-intra MB.
2400  */
2401 void ff_clean_intra_table_entries(MpegEncContext *s)
2402 {
2403     int wrap = s->b8_stride;
2404     int xy = s->block_index[0];
2405
2406     s->dc_val[0][xy           ] =
2407     s->dc_val[0][xy + 1       ] =
2408     s->dc_val[0][xy     + wrap] =
2409     s->dc_val[0][xy + 1 + wrap] = 1024;
2410     /* ac pred */
2411     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2412     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2413     if (s->msmpeg4_version>=3) {
2414         s->coded_block[xy           ] =
2415         s->coded_block[xy + 1       ] =
2416         s->coded_block[xy     + wrap] =
2417         s->coded_block[xy + 1 + wrap] = 0;
2418     }
2419     /* chroma */
2420     wrap = s->mb_stride;
2421     xy = s->mb_x + s->mb_y * wrap;
2422     s->dc_val[1][xy] =
2423     s->dc_val[2][xy] = 1024;
2424     /* ac pred */
2425     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2426     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2427
2428     s->mbintra_table[xy]= 0;
2429 }
2430
2431 /* generic function called after a macroblock has been parsed by the
2432    decoder or after it has been encoded by the encoder.
2433
2434    Important variables used:
2435    s->mb_intra : true if intra macroblock
2436    s->mv_dir   : motion vector direction
2437    s->mv_type  : motion vector type
2438    s->mv       : motion vector
2439    s->interlaced_dct : true if interlaced dct used (mpeg2)
2440  */
2441 static av_always_inline
2442 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2443                             int lowres_flag, int is_mpeg12)
2444 {
2445     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2446     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2447         ff_xvmc_decode_mb(s);//xvmc uses pblocks
2448         return;
2449     }
2450
2451     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2452        /* save DCT coefficients */
2453        int i,j;
2454        DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2455        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2456        for(i=0; i<6; i++){
2457            for(j=0; j<64; j++){
2458                *dct++ = block[i][s->dsp.idct_permutation[j]];
2459                av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2460            }
2461            av_log(s->avctx, AV_LOG_DEBUG, "\n");
2462        }
2463     }
2464
2465     s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2466
2467     /* update DC predictors for P macroblocks */
2468     if (!s->mb_intra) {
2469         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2470             if(s->mbintra_table[mb_xy])
2471                 ff_clean_intra_table_entries(s);
2472         } else {
2473             s->last_dc[0] =
2474             s->last_dc[1] =
2475             s->last_dc[2] = 128 << s->intra_dc_precision;
2476         }
2477     }
2478     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2479         s->mbintra_table[mb_xy]=1;
2480
2481     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
2482         uint8_t *dest_y, *dest_cb, *dest_cr;
2483         int dct_linesize, dct_offset;
2484         op_pixels_func (*op_pix)[4];
2485         qpel_mc_func (*op_qpix)[16];
2486         const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2487         const int uvlinesize = s->current_picture.f.linesize[1];
2488         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2489         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2490
2491         /* avoid copy if macroblock skipped in last frame too */
2492         /* skip only during decoding as we might trash the buffers during encoding a bit */
2493         if(!s->encoding){
2494             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2495
2496             if (s->mb_skipped) {
2497                 s->mb_skipped= 0;
2498                 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2499                 *mbskip_ptr = 1;
2500             } else if(!s->current_picture.f.reference) {
2501                 *mbskip_ptr = 1;
2502             } else{
2503                 *mbskip_ptr = 0; /* not skipped */
2504             }
2505         }
2506
2507         dct_linesize = linesize << s->interlaced_dct;
2508         dct_offset   = s->interlaced_dct ? linesize : linesize * block_size;
2509
2510         if(readable){
2511             dest_y=  s->dest[0];
2512             dest_cb= s->dest[1];
2513             dest_cr= s->dest[2];
2514         }else{
2515             dest_y = s->b_scratchpad;
2516             dest_cb= s->b_scratchpad+16*linesize;
2517             dest_cr= s->b_scratchpad+32*linesize;
2518         }
2519
2520         if (!s->mb_intra) {
2521             /* motion handling */
2522             /* decoding or more than one mb_type (MC was already done otherwise) */
2523             if(!s->encoding){
2524
2525                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2526                     if (s->mv_dir & MV_DIR_FORWARD) {
2527                         ff_thread_await_progress(&s->last_picture_ptr->f,
2528                                                  ff_MPV_lowest_referenced_row(s, 0),
2529                                                  0);
2530                     }
2531                     if (s->mv_dir & MV_DIR_BACKWARD) {
2532                         ff_thread_await_progress(&s->next_picture_ptr->f,
2533                                                  ff_MPV_lowest_referenced_row(s, 1),
2534                                                  0);
2535                     }
2536                 }
2537
2538                 if(lowres_flag){
2539                     h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2540
2541                     if (s->mv_dir & MV_DIR_FORWARD) {
2542                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2543                         op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2544                     }
2545                     if (s->mv_dir & MV_DIR_BACKWARD) {
2546                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2547                     }
2548                 }else{
2549                     op_qpix= s->me.qpel_put;
2550                     if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2551                         op_pix = s->dsp.put_pixels_tab;
2552                     }else{
2553                         op_pix = s->dsp.put_no_rnd_pixels_tab;
2554                     }
2555                     if (s->mv_dir & MV_DIR_FORWARD) {
2556                         ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2557                         op_pix = s->dsp.avg_pixels_tab;
2558                         op_qpix= s->me.qpel_avg;
2559                     }
2560                     if (s->mv_dir & MV_DIR_BACKWARD) {
2561                         ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2562                     }
2563                 }
2564             }
2565
2566             /* skip dequant / idct if we are really late ;) */
2567             if(s->avctx->skip_idct){
2568                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2569                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2570                    || s->avctx->skip_idct >= AVDISCARD_ALL)
2571                     goto skip_idct;
2572             }
2573
2574             /* add dct residue */
2575             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2576                                 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2577                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2578                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2579                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2580                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2581
2582                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2583                     if (s->chroma_y_shift){
2584                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2585                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2586                     }else{
2587                         dct_linesize >>= 1;
2588                         dct_offset >>=1;
2589                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2590                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2591                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2592                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2593                     }
2594                 }
2595             } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2596                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2597                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2598                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2599                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2600
2601                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2602                     if(s->chroma_y_shift){//Chroma420
2603                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
2604                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
2605                     }else{
2606                         //chroma422
2607                         dct_linesize = uvlinesize << s->interlaced_dct;
2608                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2609
2610                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
2611                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
2612                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2613                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2614                         if(!s->chroma_x_shift){//Chroma444
2615                             add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2616                             add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2617                             add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2618                             add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2619                         }
2620                     }
2621                 }//fi gray
2622             }
2623             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2624                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2625             }
2626         } else {
2627             /* dct only in intra block */
2628             if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2629                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2630                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2631                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2632                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2633
2634                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2635                     if(s->chroma_y_shift){
2636                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2637                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2638                     }else{
2639                         dct_offset >>=1;
2640                         dct_linesize >>=1;
2641                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2642                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2643                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2644                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2645                     }
2646                 }
2647             }else{
2648                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2649                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2650                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2651                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2652
2653                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2654                     if(s->chroma_y_shift){
2655                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2656                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2657                     }else{
2658
2659                         dct_linesize = uvlinesize << s->interlaced_dct;
2660                         dct_offset   = s->interlaced_dct? uvlinesize : uvlinesize*block_size;
2661
2662                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2663                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2664                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2665                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2666                         if(!s->chroma_x_shift){//Chroma444
2667                             s->dsp.idct_put(dest_cb + block_size,              dct_linesize, block[8]);
2668                             s->dsp.idct_put(dest_cr + block_size,              dct_linesize, block[9]);
2669                             s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2670                             s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2671                         }
2672                     }
2673                 }//gray
2674             }
2675         }
2676 skip_idct:
2677         if(!readable){
2678             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2679             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2680             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2681         }
2682     }
2683 }
2684
2685 void ff_MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2686 #if !CONFIG_SMALL
2687     if(s->out_format == FMT_MPEG1) {
2688         if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2689         else                 MPV_decode_mb_internal(s, block, 0, 1);
2690     } else
2691 #endif
2692     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2693     else                  MPV_decode_mb_internal(s, block, 0, 0);
2694 }
2695
2696 /**
2697  * @param h is the normal height, this will be reduced automatically if needed for the last row
2698  */
2699 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2700     const int field_pic= s->picture_structure != PICT_FRAME;
2701     if(field_pic){
2702         h <<= 1;
2703         y <<= 1;
2704     }
2705
2706     if (!s->avctx->hwaccel
2707        && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2708        && s->unrestricted_mv
2709        && s->current_picture.f.reference
2710        && !s->intra_only
2711        && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2712         int sides = 0, edge_h;
2713         int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
2714         int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
2715         if (y==0) sides |= EDGE_TOP;
2716         if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2717
2718         edge_h= FFMIN(h, s->v_edge_pos - y);
2719
2720         s->dsp.draw_edges(s->current_picture_ptr->f.data[0] +  y         *s->linesize,
2721                           s->linesize,           s->h_edge_pos,         edge_h,
2722                           EDGE_WIDTH,            EDGE_WIDTH,            sides);
2723         s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2724                           s->uvlinesize,         s->h_edge_pos>>hshift, edge_h>>vshift,
2725                           EDGE_WIDTH>>hshift,    EDGE_WIDTH>>vshift,    sides);
2726         s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2727                           s->uvlinesize,         s->h_edge_pos>>hshift, edge_h>>vshift,
2728                           EDGE_WIDTH>>hshift,    EDGE_WIDTH>>vshift,    sides);
2729     }
2730
2731     h= FFMIN(h, s->avctx->height - y);
2732
2733     if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2734
2735     if (s->avctx->draw_horiz_band) {
2736         AVFrame *src;
2737         int offset[AV_NUM_DATA_POINTERS];
2738         int i;
2739
2740         if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2741             src = &s->current_picture_ptr->f;
2742         else if(s->last_picture_ptr)
2743             src = &s->last_picture_ptr->f;
2744         else
2745             return;
2746
2747         if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2748             for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2749                 offset[i] = 0;
2750         }else{
2751             offset[0]= y * s->linesize;
2752             offset[1]=
2753             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2754             for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2755                 offset[i] = 0;
2756         }
2757
2758         emms_c();
2759
2760         s->avctx->draw_horiz_band(s->avctx, src, offset,
2761                                   y, s->picture_structure, h);
2762     }
2763 }
2764
2765 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2766     const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2767     const int uvlinesize = s->current_picture.f.linesize[1];
2768     const int mb_size= 4 - s->avctx->lowres;
2769
2770     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2771     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2772     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2773     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2774     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2775     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;
2776     //block_index is not used by mpeg2, so it is not affected by chroma_format
2777
2778     s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) <<  mb_size);
2779     s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2780     s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2781
2782     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2783     {
2784         if(s->picture_structure==PICT_FRAME){
2785         s->dest[0] += s->mb_y *   linesize << mb_size;
2786         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2787         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2788         }else{
2789             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2790             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2791             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2792             av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2793         }
2794     }
2795 }
2796
2797 void ff_mpeg_flush(AVCodecContext *avctx){
2798     int i;
2799     MpegEncContext *s = avctx->priv_data;
2800
2801     if(s==NULL || s->picture==NULL)
2802         return;
2803
2804     for(i=0; i<s->picture_count; i++){
2805        if (s->picture[i].f.data[0] &&
2806            (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2807             s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2808         free_frame_buffer(s, &s->picture[i]);
2809     }
2810     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2811
2812     s->mb_x= s->mb_y= 0;
2813     s->closed_gop= 0;
2814
2815     s->parse_context.state= -1;
2816     s->parse_context.frame_start_found= 0;
2817     s->parse_context.overread= 0;
2818     s->parse_context.overread_index= 0;
2819     s->parse_context.index= 0;
2820     s->parse_context.last_index= 0;
2821     s->bitstream_buffer_size=0;
2822     s->pp_time=0;
2823 }
2824
2825 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2826                                    DCTELEM *block, int n, int qscale)
2827 {
2828     int i, level, nCoeffs;
2829     const uint16_t *quant_matrix;
2830
2831     nCoeffs= s->block_last_index[n];
2832
2833     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2834     /* XXX: only mpeg1 */
2835     quant_matrix = s->intra_matrix;
2836     for(i=1;i<=nCoeffs;i++) {
2837         int j= s->intra_scantable.permutated[i];
2838         level = block[j];
2839         if (level) {
2840             if (level < 0) {
2841                 level = -level;
2842                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2843                 level = (level - 1) | 1;
2844                 level = -level;
2845             } else {
2846                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2847                 level = (level - 1) | 1;
2848             }
2849             block[j] = level;
2850         }
2851     }
2852 }
2853
2854 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2855                                    DCTELEM *block, int n, int qscale)
2856 {
2857     int i, level, nCoeffs;
2858     const uint16_t *quant_matrix;
2859
2860     nCoeffs= s->block_last_index[n];
2861
2862     quant_matrix = s->inter_matrix;
2863     for(i=0; i<=nCoeffs; i++) {
2864         int j= s->intra_scantable.permutated[i];
2865         level = block[j];
2866         if (level) {
2867             if (level < 0) {
2868                 level = -level;
2869                 level = (((level << 1) + 1) * qscale *
2870                          ((int) (quant_matrix[j]))) >> 4;
2871                 level = (level - 1) | 1;
2872                 level = -level;
2873             } else {
2874                 level = (((level << 1) + 1) * qscale *
2875                          ((int) (quant_matrix[j]))) >> 4;
2876                 level = (level - 1) | 1;
2877             }
2878             block[j] = level;
2879         }
2880     }
2881 }
2882
2883 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2884                                    DCTELEM *block, int n, int qscale)
2885 {
2886     int i, level, nCoeffs;
2887     const uint16_t *quant_matrix;
2888
2889     if(s->alternate_scan) nCoeffs= 63;
2890     else nCoeffs= s->block_last_index[n];
2891
2892     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2893     quant_matrix = s->intra_matrix;
2894     for(i=1;i<=nCoeffs;i++) {
2895         int j= s->intra_scantable.permutated[i];
2896         level = block[j];
2897         if (level) {
2898             if (level < 0) {
2899                 level = -level;
2900                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2901                 level = -level;
2902             } else {
2903                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2904             }
2905             block[j] = level;
2906         }
2907     }
2908 }
2909
2910 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2911                                    DCTELEM *block, int n, int qscale)
2912 {
2913     int i, level, nCoeffs;
2914     const uint16_t *quant_matrix;
2915     int sum=-1;
2916
2917     if(s->alternate_scan) nCoeffs= 63;
2918     else nCoeffs= s->block_last_index[n];
2919
2920     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2921     sum += block[0];
2922     quant_matrix = s->intra_matrix;
2923     for(i=1;i<=nCoeffs;i++) {
2924         int j= s->intra_scantable.permutated[i];
2925         level = block[j];
2926         if (level) {
2927             if (level < 0) {
2928                 level = -level;
2929                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2930                 level = -level;
2931             } else {
2932                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2933             }
2934             block[j] = level;
2935             sum+=level;
2936         }
2937     }
2938     block[63]^=sum&1;
2939 }
2940
2941 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2942                                    DCTELEM *block, int n, int qscale)
2943 {
2944     int i, level, nCoeffs;
2945     const uint16_t *quant_matrix;
2946     int sum=-1;
2947
2948     if(s->alternate_scan) nCoeffs= 63;
2949     else nCoeffs= s->block_last_index[n];
2950
2951     quant_matrix = s->inter_matrix;
2952     for(i=0; i<=nCoeffs; i++) {
2953         int j= s->intra_scantable.permutated[i];
2954         level = block[j];
2955         if (level) {
2956             if (level < 0) {
2957                 level = -level;
2958                 level = (((level << 1) + 1) * qscale *
2959                          ((int) (quant_matrix[j]))) >> 4;
2960                 level = -level;
2961             } else {
2962                 level = (((level << 1) + 1) * qscale *
2963                          ((int) (quant_matrix[j]))) >> 4;
2964             }
2965             block[j] = level;
2966             sum+=level;
2967         }
2968     }
2969     block[63]^=sum&1;
2970 }
2971
2972 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2973                                   DCTELEM *block, int n, int qscale)
2974 {
2975     int i, level, qmul, qadd;
2976     int nCoeffs;
2977
2978     assert(s->block_last_index[n]>=0);
2979
2980     qmul = qscale << 1;
2981
2982     if (!s->h263_aic) {
2983         block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2984         qadd = (qscale - 1) | 1;
2985     }else{
2986         qadd = 0;
2987     }
2988     if(s->ac_pred)
2989         nCoeffs=63;
2990     else
2991         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2992
2993     for(i=1; i<=nCoeffs; i++) {
2994         level = block[i];
2995         if (level) {
2996             if (level < 0) {
2997                 level = level * qmul - qadd;
2998             } else {
2999                 level = level * qmul + qadd;
3000             }
3001             block[i] = level;
3002         }
3003     }
3004 }
3005
3006 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
3007                                   DCTELEM *block, int n, int qscale)
3008 {
3009     int i, level, qmul, qadd;
3010     int nCoeffs;
3011
3012     assert(s->block_last_index[n]>=0);
3013
3014     qadd = (qscale - 1) | 1;
3015     qmul = qscale << 1;
3016
3017     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3018
3019     for(i=0; i<=nCoeffs; i++) {
3020         level = block[i];
3021         if (level) {
3022             if (level < 0) {
3023                 level = level * qmul - qadd;
3024             } else {
3025                 level = level * qmul + qadd;
3026             }
3027             block[i] = level;
3028         }
3029     }
3030 }
3031
3032 /**
3033  * set qscale and update qscale dependent variables.
3034  */
3035 void ff_set_qscale(MpegEncContext * s, int qscale)
3036 {
3037     if (qscale < 1)
3038         qscale = 1;
3039     else if (qscale > 31)
3040         qscale = 31;
3041
3042     s->qscale = qscale;
3043     s->chroma_qscale= s->chroma_qscale_table[qscale];
3044
3045     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
3046     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
3047 }
3048
3049 void ff_MPV_report_decode_progress(MpegEncContext *s)
3050 {
3051     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
3052         ff_thread_report_progress(&s->current_picture_ptr->f, s->mb_y, 0);
3053 }