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