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