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