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