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