ff_alloc_picture: free tables in case of dimension mismatches
[ffmpeg.git] / libavcodec / mpegvideo.c
1 /*
2  * The simplest mpeg encoder (well, it was the simplest!)
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24
25 /**
26  * @file
27  * The simplest mpeg encoder (well, it was the simplest!).
28  */
29
30 #include "libavutil/avassert.h"
31 #include "libavutil/imgutils.h"
32 #include "avcodec.h"
33 #include "dsputil.h"
34 #include "h264chroma.h"
35 #include "internal.h"
36 #include "mathops.h"
37 #include "mpegvideo.h"
38 #include "mjpegenc.h"
39 #include "msmpeg4.h"
40 #include "xvmc_internal.h"
41 #include "thread.h"
42 #include <limits.h>
43
44 //#undef NDEBUG
45 //#include <assert.h>
46
47 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
48                                    int16_t *block, int n, int qscale);
49 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
50                                    int16_t *block, int n, int qscale);
51 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
52                                    int16_t *block, int n, int qscale);
53 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
54                                    int16_t *block, int n, int qscale);
55 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
56                                    int16_t *block, int n, int qscale);
57 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
58                                   int16_t *block, int n, int qscale);
59 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
60                                   int16_t *block, int n, int qscale);
61
62
63 //#define DEBUG
64
65
66 static const uint8_t ff_default_chroma_qscale_table[32] = {
67 //   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15
68      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
69     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
70 };
71
72 const uint8_t ff_mpeg1_dc_scale_table[128] = {
73 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
74     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
75     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
76     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
77     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
78     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
79     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
80     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
81     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
82 };
83
84 static const uint8_t mpeg2_dc_scale_table1[128] = {
85 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
86     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
87     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
88     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
89     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
90     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
91     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
92     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
93     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
94 };
95
96 static const uint8_t mpeg2_dc_scale_table2[128] = {
97 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
98     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
99     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
100     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
101     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
102     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
103     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
104     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
105     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
106 };
107
108 static const uint8_t mpeg2_dc_scale_table3[128] = {
109 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
110     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
111     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
112     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
113     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
114     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
115     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
116     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
117     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
118 };
119
120 const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
121     ff_mpeg1_dc_scale_table,
122     mpeg2_dc_scale_table1,
123     mpeg2_dc_scale_table2,
124     mpeg2_dc_scale_table3,
125 };
126
127 const enum AVPixelFormat ff_pixfmt_list_420[] = {
128     AV_PIX_FMT_YUV420P,
129     AV_PIX_FMT_NONE
130 };
131
132 static void mpeg_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
133                               int (*mv)[2][4][2],
134                               int mb_x, int mb_y, int mb_intra, int mb_skipped)
135 {
136     MpegEncContext *s = opaque;
137
138     s->mv_dir     = mv_dir;
139     s->mv_type    = mv_type;
140     s->mb_intra   = mb_intra;
141     s->mb_skipped = mb_skipped;
142     s->mb_x       = mb_x;
143     s->mb_y       = mb_y;
144     memcpy(s->mv, mv, sizeof(*mv));
145
146     ff_init_block_index(s);
147     ff_update_block_index(s);
148
149     s->dsp.clear_blocks(s->block[0]);
150
151     s->dest[0] = s->current_picture.f.data[0] + (s->mb_y *  16                       * s->linesize)   + s->mb_x *  16;
152     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);
153     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);
154
155     assert(ref == 0);
156     ff_MPV_decode_mb(s, s->block);
157 }
158
159 const uint8_t *avpriv_mpv_find_start_code(const uint8_t *av_restrict p,
160                                           const uint8_t *end,
161                                           uint32_t *av_restrict state)
162 {
163     int i;
164
165     assert(p <= end);
166     if (p >= end)
167         return end;
168
169     for (i = 0; i < 3; i++) {
170         uint32_t tmp = *state << 8;
171         *state = tmp + *(p++);
172         if (tmp == 0x100 || p == end)
173             return p;
174     }
175
176     while (p < end) {
177         if      (p[-1] > 1      ) p += 3;
178         else if (p[-2]          ) p += 2;
179         else if (p[-3]|(p[-1]-1)) p++;
180         else {
181             p++;
182             break;
183         }
184     }
185
186     p = FFMIN(p, end) - 4;
187     *state = AV_RB32(p);
188
189     return p + 4;
190 }
191
192 /* init common dct for both encoder and decoder */
193 av_cold int ff_dct_common_init(MpegEncContext *s)
194 {
195     ff_dsputil_init(&s->dsp, s->avctx);
196     ff_h264chroma_init(&s->h264chroma, 8); //for lowres
197     ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
198
199     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
200     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
201     s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
202     s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
203     s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
204     if (s->flags & CODEC_FLAG_BITEXACT)
205         s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
206     s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
207
208 #if ARCH_X86
209     ff_MPV_common_init_x86(s);
210 #elif ARCH_ALPHA
211     ff_MPV_common_init_axp(s);
212 #elif ARCH_ARM
213     ff_MPV_common_init_arm(s);
214 #elif HAVE_ALTIVEC
215     ff_MPV_common_init_altivec(s);
216 #elif ARCH_BFIN
217     ff_MPV_common_init_bfin(s);
218 #endif
219
220     /* load & permutate scantables
221      * note: only wmv uses different ones
222      */
223     if (s->alternate_scan) {
224         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
225         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
226     } else {
227         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
228         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
229     }
230     ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
231     ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
232
233     return 0;
234 }
235
236 int ff_mpv_frame_size_alloc(MpegEncContext *s, int linesize)
237 {
238     int alloc_size = FFALIGN(FFABS(linesize) + 64, 32);
239
240     // edge emu needs blocksize + filter length - 1
241     // (= 17x17 for  halfpel / 21x21 for  h264)
242     // VC1 computes luma and chroma simultaneously and needs 19X19 + 9x9
243     // at uvlinesize. It supports only YUV420 so 24x24 is enough
244     // linesize * interlaced * MBsize
245     FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer, alloc_size * 4 * 24,
246                       fail);
247
248     FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad, alloc_size * 4 * 16 * 2,
249                       fail)
250     s->me.temp         = s->me.scratchpad;
251     s->rd_scratchpad   = s->me.scratchpad;
252     s->b_scratchpad    = s->me.scratchpad;
253     s->obmc_scratchpad = s->me.scratchpad + 16;
254
255     return 0;
256 fail:
257     av_freep(&s->edge_emu_buffer);
258     return AVERROR(ENOMEM);
259 }
260
261 /**
262  * Allocate a frame buffer
263  */
264 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
265 {
266     int r, ret;
267
268     if (s->avctx->hwaccel) {
269         assert(!pic->hwaccel_picture_private);
270         if (s->avctx->hwaccel->priv_data_size) {
271             pic->hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
272             if (!pic->hwaccel_picture_private) {
273                 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
274                 return -1;
275             }
276         }
277     }
278
279     pic->tf.f = &pic->f;
280     if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
281         s->codec_id != AV_CODEC_ID_VC1IMAGE  &&
282         s->codec_id != AV_CODEC_ID_MSS2)
283         r = ff_thread_get_buffer(s->avctx, &pic->tf,
284                                  pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
285     else {
286         pic->f.width  = s->avctx->width;
287         pic->f.height = s->avctx->height;
288         pic->f.format = s->avctx->pix_fmt;
289         r = avcodec_default_get_buffer2(s->avctx, &pic->f, 0);
290     }
291
292     if (r < 0 || !pic->f.data[0]) {
293         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %p)\n",
294                r, pic->f.data[0]);
295         av_freep(&pic->hwaccel_picture_private);
296         return -1;
297     }
298
299     if (s->linesize && (s->linesize   != pic->f.linesize[0] ||
300                         s->uvlinesize != pic->f.linesize[1])) {
301         av_log(s->avctx, AV_LOG_ERROR,
302                "get_buffer() failed (stride changed)\n");
303         ff_mpeg_unref_picture(s, pic);
304         return -1;
305     }
306
307     if (pic->f.linesize[1] != pic->f.linesize[2]) {
308         av_log(s->avctx, AV_LOG_ERROR,
309                "get_buffer() failed (uv stride mismatch)\n");
310         ff_mpeg_unref_picture(s, pic);
311         return -1;
312     }
313
314     if (!s->edge_emu_buffer &&
315         (ret = ff_mpv_frame_size_alloc(s, pic->f.linesize[0])) < 0) {
316         av_log(s->avctx, AV_LOG_ERROR,
317                "get_buffer() failed to allocate context scratch buffers.\n");
318         ff_mpeg_unref_picture(s, pic);
319         return ret;
320     }
321
322     return 0;
323 }
324
325 static void free_picture_tables(Picture *pic)
326 {
327     int i;
328
329     av_buffer_unref(&pic->mb_var_buf);
330     av_buffer_unref(&pic->mc_mb_var_buf);
331     av_buffer_unref(&pic->mb_mean_buf);
332     av_buffer_unref(&pic->mbskip_table_buf);
333     av_buffer_unref(&pic->qscale_table_buf);
334     av_buffer_unref(&pic->mb_type_buf);
335
336     for (i = 0; i < 2; i++) {
337         av_buffer_unref(&pic->motion_val_buf[i]);
338         av_buffer_unref(&pic->ref_index_buf[i]);
339     }
340 }
341
342 static int alloc_picture_tables(MpegEncContext *s, Picture *pic)
343 {
344     const int big_mb_num    = s->mb_stride * (s->mb_height + 1) + 1;
345     const int mb_array_size = s->mb_stride * s->mb_height;
346     const int b8_array_size = s->b8_stride * s->mb_height * 2;
347     int i;
348
349
350     pic->mbskip_table_buf = av_buffer_allocz(mb_array_size + 2);
351     pic->qscale_table_buf = av_buffer_allocz(big_mb_num + s->mb_stride);
352     pic->mb_type_buf      = av_buffer_allocz((big_mb_num + s->mb_stride) *
353                                              sizeof(uint32_t));
354     if (!pic->mbskip_table_buf || !pic->qscale_table_buf || !pic->mb_type_buf)
355         return AVERROR(ENOMEM);
356
357     if (s->encoding) {
358         pic->mb_var_buf    = av_buffer_allocz(mb_array_size * sizeof(int16_t));
359         pic->mc_mb_var_buf = av_buffer_allocz(mb_array_size * sizeof(int16_t));
360         pic->mb_mean_buf   = av_buffer_allocz(mb_array_size);
361         if (!pic->mb_var_buf || !pic->mc_mb_var_buf || !pic->mb_mean_buf)
362             return AVERROR(ENOMEM);
363     }
364
365     if (s->out_format == FMT_H263 || s->encoding ||
366                (s->avctx->debug & FF_DEBUG_MV) || s->avctx->debug_mv) {
367         int mv_size        = 2 * (b8_array_size + 4) * sizeof(int16_t);
368         int ref_index_size = 4 * mb_array_size;
369
370         for (i = 0; mv_size && i < 2; i++) {
371             pic->motion_val_buf[i] = av_buffer_allocz(mv_size);
372             pic->ref_index_buf[i]  = av_buffer_allocz(ref_index_size);
373             if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i])
374                 return AVERROR(ENOMEM);
375         }
376     }
377
378     return 0;
379 }
380
381 static int make_tables_writable(Picture *pic)
382 {
383     int ret, i;
384 #define MAKE_WRITABLE(table) \
385 do {\
386     if (pic->table &&\
387        (ret = av_buffer_make_writable(&pic->table)) < 0)\
388     return ret;\
389 } while (0)
390
391     MAKE_WRITABLE(mb_var_buf);
392     MAKE_WRITABLE(mc_mb_var_buf);
393     MAKE_WRITABLE(mb_mean_buf);
394     MAKE_WRITABLE(mbskip_table_buf);
395     MAKE_WRITABLE(qscale_table_buf);
396     MAKE_WRITABLE(mb_type_buf);
397
398     for (i = 0; i < 2; i++) {
399         MAKE_WRITABLE(motion_val_buf[i]);
400         MAKE_WRITABLE(ref_index_buf[i]);
401     }
402
403     return 0;
404 }
405
406 /**
407  * Allocate a Picture.
408  * The pixels are allocated/set by calling get_buffer() if shared = 0
409  */
410 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
411 {
412     int i, ret;
413
414     if (pic->qscale_table_buf)
415         if (pic->mbskip_table_buf->size < s->mb_stride * s->mb_height + 2 ||
416             pic->qscale_table_buf->size < s->mb_stride * (s->mb_height + 1) + 1 + s->mb_stride)
417             free_picture_tables(pic);
418
419     if (shared) {
420         assert(pic->f.data[0]);
421         pic->shared = 1;
422     } else {
423         assert(!pic->f.data[0]);
424
425         if (alloc_frame_buffer(s, pic) < 0)
426             return -1;
427
428         s->linesize   = pic->f.linesize[0];
429         s->uvlinesize = pic->f.linesize[1];
430     }
431
432     if (!pic->qscale_table_buf)
433         ret = alloc_picture_tables(s, pic);
434     else
435         ret = make_tables_writable(pic);
436     if (ret < 0)
437         goto fail;
438
439     if (s->encoding) {
440         pic->mb_var    = (uint16_t*)pic->mb_var_buf->data;
441         pic->mc_mb_var = (uint16_t*)pic->mc_mb_var_buf->data;
442         pic->mb_mean   = pic->mb_mean_buf->data;
443     }
444
445     pic->mbskip_table = pic->mbskip_table_buf->data;
446     pic->qscale_table = pic->qscale_table_buf->data + 2 * s->mb_stride + 1;
447     pic->mb_type      = (uint32_t*)pic->mb_type_buf->data + 2 * s->mb_stride + 1;
448
449     if (pic->motion_val_buf[0]) {
450         for (i = 0; i < 2; i++) {
451             pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
452             pic->ref_index[i]  = pic->ref_index_buf[i]->data;
453         }
454     }
455
456     return 0;
457 fail:
458     av_log(s->avctx, AV_LOG_ERROR, "Error allocating a picture.\n");
459     ff_mpeg_unref_picture(s, pic);
460     free_picture_tables(pic);
461     return AVERROR(ENOMEM);
462 }
463
464 /**
465  * Deallocate a picture.
466  */
467 void ff_mpeg_unref_picture(MpegEncContext *s, Picture *pic)
468 {
469     int off = offsetof(Picture, mb_mean) + sizeof(pic->mb_mean);
470     pic->period_since_free = 0;
471
472     pic->tf.f = &pic->f;
473     /* WM Image / Screen codecs allocate internal buffers with different
474      * dimensions / colorspaces; ignore user-defined callbacks for these. */
475     if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
476         s->codec_id != AV_CODEC_ID_VC1IMAGE  &&
477         s->codec_id != AV_CODEC_ID_MSS2)
478         ff_thread_release_buffer(s->avctx, &pic->tf);
479     else
480         av_frame_unref(&pic->f);
481
482     av_buffer_unref(&pic->hwaccel_priv_buf);
483
484     memset((uint8_t*)pic + off, 0, sizeof(*pic) - off);
485 }
486
487 static int update_picture_tables(Picture *dst, Picture *src)
488 {
489      int i;
490
491 #define UPDATE_TABLE(table)\
492 do {\
493     if (src->table &&\
494         (!dst->table || dst->table->buffer != src->table->buffer)) {\
495         av_buffer_unref(&dst->table);\
496         dst->table = av_buffer_ref(src->table);\
497         if (!dst->table) {\
498             free_picture_tables(dst);\
499             return AVERROR(ENOMEM);\
500         }\
501     }\
502 } while (0)
503
504     UPDATE_TABLE(mb_var_buf);
505     UPDATE_TABLE(mc_mb_var_buf);
506     UPDATE_TABLE(mb_mean_buf);
507     UPDATE_TABLE(mbskip_table_buf);
508     UPDATE_TABLE(qscale_table_buf);
509     UPDATE_TABLE(mb_type_buf);
510     for (i = 0; i < 2; i++) {
511         UPDATE_TABLE(motion_val_buf[i]);
512         UPDATE_TABLE(ref_index_buf[i]);
513     }
514
515     dst->mb_var        = src->mb_var;
516     dst->mc_mb_var     = src->mc_mb_var;
517     dst->mb_mean       = src->mb_mean;
518     dst->mbskip_table  = src->mbskip_table;
519     dst->qscale_table  = src->qscale_table;
520     dst->mb_type       = src->mb_type;
521     for (i = 0; i < 2; i++) {
522         dst->motion_val[i] = src->motion_val[i];
523         dst->ref_index[i]  = src->ref_index[i];
524     }
525
526     return 0;
527 }
528
529 int ff_mpeg_ref_picture(MpegEncContext *s, Picture *dst, Picture *src)
530 {
531     int ret;
532
533     av_assert0(!dst->f.buf[0]);
534     av_assert0(src->f.buf[0]);
535
536     src->tf.f = &src->f;
537     dst->tf.f = &dst->f;
538     ret = ff_thread_ref_frame(&dst->tf, &src->tf);
539     if (ret < 0)
540         goto fail;
541
542     ret = update_picture_tables(dst, src);
543     if (ret < 0)
544         goto fail;
545
546     if (src->hwaccel_picture_private) {
547         dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
548         if (!dst->hwaccel_priv_buf)
549             goto fail;
550         dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
551     }
552
553     dst->field_picture           = src->field_picture;
554     dst->mb_var_sum              = src->mb_var_sum;
555     dst->mc_mb_var_sum           = src->mc_mb_var_sum;
556     dst->b_frame_score           = src->b_frame_score;
557     dst->needs_realloc           = src->needs_realloc;
558     dst->reference               = src->reference;
559     dst->shared                  = src->shared;
560
561     return 0;
562 fail:
563     ff_mpeg_unref_picture(s, dst);
564     return ret;
565 }
566
567 static int init_duplicate_context(MpegEncContext *s)
568 {
569     int y_size = s->b8_stride * (2 * s->mb_height + 1);
570     int c_size = s->mb_stride * (s->mb_height + 1);
571     int yc_size = y_size + 2 * c_size;
572     int i;
573
574     s->edge_emu_buffer =
575     s->me.scratchpad   =
576     s->me.temp         =
577     s->rd_scratchpad   =
578     s->b_scratchpad    =
579     s->obmc_scratchpad = NULL;
580
581     if (s->encoding) {
582         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
583                           ME_MAP_SIZE * sizeof(uint32_t), fail)
584         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
585                           ME_MAP_SIZE * sizeof(uint32_t), fail)
586         if (s->avctx->noise_reduction) {
587             FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
588                               2 * 64 * sizeof(int), fail)
589         }
590     }
591     FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(int16_t), fail)
592     s->block = s->blocks[0];
593
594     for (i = 0; i < 12; i++) {
595         s->pblocks[i] = &s->block[i];
596     }
597
598     if (s->out_format == FMT_H263) {
599         /* ac values */
600         FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
601                           yc_size * sizeof(int16_t) * 16, fail);
602         s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
603         s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
604         s->ac_val[2] = s->ac_val[1] + c_size;
605     }
606
607     return 0;
608 fail:
609     return -1; // free() through ff_MPV_common_end()
610 }
611
612 static void free_duplicate_context(MpegEncContext *s)
613 {
614     if (s == NULL)
615         return;
616
617     av_freep(&s->edge_emu_buffer);
618     av_freep(&s->me.scratchpad);
619     s->me.temp =
620     s->rd_scratchpad =
621     s->b_scratchpad =
622     s->obmc_scratchpad = NULL;
623
624     av_freep(&s->dct_error_sum);
625     av_freep(&s->me.map);
626     av_freep(&s->me.score_map);
627     av_freep(&s->blocks);
628     av_freep(&s->ac_val_base);
629     s->block = NULL;
630 }
631
632 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
633 {
634 #define COPY(a) bak->a = src->a
635     COPY(edge_emu_buffer);
636     COPY(me.scratchpad);
637     COPY(me.temp);
638     COPY(rd_scratchpad);
639     COPY(b_scratchpad);
640     COPY(obmc_scratchpad);
641     COPY(me.map);
642     COPY(me.score_map);
643     COPY(blocks);
644     COPY(block);
645     COPY(start_mb_y);
646     COPY(end_mb_y);
647     COPY(me.map_generation);
648     COPY(pb);
649     COPY(dct_error_sum);
650     COPY(dct_count[0]);
651     COPY(dct_count[1]);
652     COPY(ac_val_base);
653     COPY(ac_val[0]);
654     COPY(ac_val[1]);
655     COPY(ac_val[2]);
656 #undef COPY
657 }
658
659 int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
660 {
661     MpegEncContext bak;
662     int i, ret;
663     // FIXME copy only needed parts
664     // START_TIMER
665     backup_duplicate_context(&bak, dst);
666     memcpy(dst, src, sizeof(MpegEncContext));
667     backup_duplicate_context(dst, &bak);
668     for (i = 0; i < 12; i++) {
669         dst->pblocks[i] = &dst->block[i];
670     }
671     if (!dst->edge_emu_buffer &&
672         (ret = ff_mpv_frame_size_alloc(dst, dst->linesize)) < 0) {
673         av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
674                "scratch buffers.\n");
675         return ret;
676     }
677     // STOP_TIMER("update_duplicate_context")
678     // about 10k cycles / 0.01 sec for  1000frames on 1ghz with 2 threads
679     return 0;
680 }
681
682 int ff_mpeg_update_thread_context(AVCodecContext *dst,
683                                   const AVCodecContext *src)
684 {
685     int i, ret;
686     MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
687
688     if (dst == src)
689         return 0;
690
691     av_assert0(s != s1);
692
693     // FIXME can parameters change on I-frames?
694     // in that case dst may need a reinit
695     if (!s->context_initialized) {
696         memcpy(s, s1, sizeof(MpegEncContext));
697
698         s->avctx                 = dst;
699         s->bitstream_buffer      = NULL;
700         s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
701
702         if (s1->context_initialized){
703 //             s->picture_range_start  += MAX_PICTURE_COUNT;
704 //             s->picture_range_end    += MAX_PICTURE_COUNT;
705             if((ret = ff_MPV_common_init(s)) < 0){
706                 memset(s, 0, sizeof(MpegEncContext));
707                 s->avctx = dst;
708                 return ret;
709             }
710         }
711     }
712
713     if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
714         s->context_reinit = 0;
715         s->height = s1->height;
716         s->width  = s1->width;
717         if ((ret = ff_MPV_common_frame_size_change(s)) < 0)
718             return ret;
719     }
720
721     s->avctx->coded_height  = s1->avctx->coded_height;
722     s->avctx->coded_width   = s1->avctx->coded_width;
723     s->avctx->width         = s1->avctx->width;
724     s->avctx->height        = s1->avctx->height;
725
726     s->coded_picture_number = s1->coded_picture_number;
727     s->picture_number       = s1->picture_number;
728     s->input_picture_number = s1->input_picture_number;
729
730     av_assert0(!s->picture || s->picture != s1->picture);
731     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
732         ff_mpeg_unref_picture(s, &s->picture[i]);
733         if (s1->picture[i].f.data[0] &&
734             (ret = ff_mpeg_ref_picture(s, &s->picture[i], &s1->picture[i])) < 0)
735             return ret;
736         s->picture[i].period_since_free ++;
737     }
738
739 #define UPDATE_PICTURE(pic)\
740 do {\
741     ff_mpeg_unref_picture(s, &s->pic);\
742     if (s1->pic.f.data[0])\
743         ret = ff_mpeg_ref_picture(s, &s->pic, &s1->pic);\
744     else\
745         ret = update_picture_tables(&s->pic, &s1->pic);\
746     if (ret < 0)\
747         return ret;\
748 } while (0)
749
750     UPDATE_PICTURE(current_picture);
751     UPDATE_PICTURE(last_picture);
752     UPDATE_PICTURE(next_picture);
753
754     s->last_picture_ptr    = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
755     s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
756     s->next_picture_ptr    = REBASE_PICTURE(s1->next_picture_ptr,    s, s1);
757
758     // Error/bug resilience
759     s->next_p_frame_damaged = s1->next_p_frame_damaged;
760     s->workaround_bugs      = s1->workaround_bugs;
761     s->padding_bug_score    = s1->padding_bug_score;
762
763     // MPEG4 timing info
764     memcpy(&s->time_increment_bits, &s1->time_increment_bits,
765            (char *) &s1->shape - (char *) &s1->time_increment_bits);
766
767     // B-frame info
768     s->max_b_frames = s1->max_b_frames;
769     s->low_delay    = s1->low_delay;
770     s->droppable    = s1->droppable;
771
772     // DivX handling (doesn't work)
773     s->divx_packed  = s1->divx_packed;
774
775     if (s1->bitstream_buffer) {
776         if (s1->bitstream_buffer_size +
777             FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
778             av_fast_malloc(&s->bitstream_buffer,
779                            &s->allocated_bitstream_buffer_size,
780                            s1->allocated_bitstream_buffer_size);
781             s->bitstream_buffer_size = s1->bitstream_buffer_size;
782         memcpy(s->bitstream_buffer, s1->bitstream_buffer,
783                s1->bitstream_buffer_size);
784         memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
785                FF_INPUT_BUFFER_PADDING_SIZE);
786     }
787
788     // linesize dependend scratch buffer allocation
789     if (!s->edge_emu_buffer)
790         if (s1->linesize) {
791             if (ff_mpv_frame_size_alloc(s, s1->linesize) < 0) {
792                 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
793                        "scratch buffers.\n");
794                 return AVERROR(ENOMEM);
795             }
796         } else {
797             av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
798                    "be allocated due to unknown size.\n");
799         }
800
801     // MPEG2/interlacing info
802     memcpy(&s->progressive_sequence, &s1->progressive_sequence,
803            (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
804
805     if (!s1->first_field) {
806         s->last_pict_type = s1->pict_type;
807         if (s1->current_picture_ptr)
808             s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
809
810         if (s1->pict_type != AV_PICTURE_TYPE_B) {
811             s->last_non_b_pict_type = s1->pict_type;
812         }
813     }
814
815     return 0;
816 }
817
818 /**
819  * Set the given MpegEncContext to common defaults
820  * (same for encoding and decoding).
821  * The changed fields will not depend upon the
822  * prior state of the MpegEncContext.
823  */
824 void ff_MPV_common_defaults(MpegEncContext *s)
825 {
826     s->y_dc_scale_table      =
827     s->c_dc_scale_table      = ff_mpeg1_dc_scale_table;
828     s->chroma_qscale_table   = ff_default_chroma_qscale_table;
829     s->progressive_frame     = 1;
830     s->progressive_sequence  = 1;
831     s->picture_structure     = PICT_FRAME;
832
833     s->coded_picture_number  = 0;
834     s->picture_number        = 0;
835     s->input_picture_number  = 0;
836
837     s->picture_in_gop_number = 0;
838
839     s->f_code                = 1;
840     s->b_code                = 1;
841
842     s->slice_context_count   = 1;
843 }
844
845 /**
846  * Set the given MpegEncContext to defaults for decoding.
847  * the changed fields will not depend upon
848  * the prior state of the MpegEncContext.
849  */
850 void ff_MPV_decode_defaults(MpegEncContext *s)
851 {
852     ff_MPV_common_defaults(s);
853 }
854
855 static int init_er(MpegEncContext *s)
856 {
857     ERContext *er = &s->er;
858     int mb_array_size = s->mb_height * s->mb_stride;
859     int i;
860
861     er->avctx       = s->avctx;
862     er->dsp         = &s->dsp;
863
864     er->mb_index2xy = s->mb_index2xy;
865     er->mb_num      = s->mb_num;
866     er->mb_width    = s->mb_width;
867     er->mb_height   = s->mb_height;
868     er->mb_stride   = s->mb_stride;
869     er->b8_stride   = s->b8_stride;
870
871     er->er_temp_buffer     = av_malloc(s->mb_height * s->mb_stride);
872     er->error_status_table = av_mallocz(mb_array_size);
873     if (!er->er_temp_buffer || !er->error_status_table)
874         goto fail;
875
876     er->mbskip_table  = s->mbskip_table;
877     er->mbintra_table = s->mbintra_table;
878
879     for (i = 0; i < FF_ARRAY_ELEMS(s->dc_val); i++)
880         er->dc_val[i] = s->dc_val[i];
881
882     er->decode_mb = mpeg_er_decode_mb;
883     er->opaque    = s;
884
885     return 0;
886 fail:
887     av_freep(&er->er_temp_buffer);
888     av_freep(&er->error_status_table);
889     return AVERROR(ENOMEM);
890 }
891
892 /**
893  * Initialize and allocates MpegEncContext fields dependent on the resolution.
894  */
895 static int init_context_frame(MpegEncContext *s)
896 {
897     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
898
899     s->mb_width   = (s->width + 15) / 16;
900     s->mb_stride  = s->mb_width + 1;
901     s->b8_stride  = s->mb_width * 2 + 1;
902     s->b4_stride  = s->mb_width * 4 + 1;
903     mb_array_size = s->mb_height * s->mb_stride;
904     mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
905
906     /* set default edge pos, will be overriden
907      * in decode_header if needed */
908     s->h_edge_pos = s->mb_width * 16;
909     s->v_edge_pos = s->mb_height * 16;
910
911     s->mb_num     = s->mb_width * s->mb_height;
912
913     s->block_wrap[0] =
914     s->block_wrap[1] =
915     s->block_wrap[2] =
916     s->block_wrap[3] = s->b8_stride;
917     s->block_wrap[4] =
918     s->block_wrap[5] = s->mb_stride;
919
920     y_size  = s->b8_stride * (2 * s->mb_height + 1);
921     c_size  = s->mb_stride * (s->mb_height + 1);
922     yc_size = y_size + 2   * c_size;
923
924     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
925     for (y = 0; y < s->mb_height; y++)
926         for (x = 0; x < s->mb_width; x++)
927             s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
928
929     s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
930
931     if (s->encoding) {
932         /* Allocate MV tables */
933         FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,                 mv_table_size * 2 * sizeof(int16_t), fail)
934         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
935         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
936         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
937         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
938         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,          mv_table_size * 2 * sizeof(int16_t), fail)
939         s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;
940         s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;
941         s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;
942         s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
943         s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
944         s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;
945
946         /* Allocate MB type table */
947         FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
948
949         FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
950
951         FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
952                          mb_array_size * sizeof(float), fail);
953         FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
954                          mb_array_size * sizeof(float), fail);
955
956     }
957
958     if (s->codec_id == AV_CODEC_ID_MPEG4 ||
959         (s->flags & CODEC_FLAG_INTERLACED_ME)) {
960         /* interlaced direct mode decoding tables */
961         for (i = 0; i < 2; i++) {
962             int j, k;
963             for (j = 0; j < 2; j++) {
964                 for (k = 0; k < 2; k++) {
965                     FF_ALLOCZ_OR_GOTO(s->avctx,
966                                       s->b_field_mv_table_base[i][j][k],
967                                       mv_table_size * 2 * sizeof(int16_t),
968                                       fail);
969                     s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
970                                                    s->mb_stride + 1;
971                 }
972                 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
973                 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
974                 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
975             }
976             FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], 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     , mb_array_size * sizeof(uint8_t), fail);
986         FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
987     }
988
989     if (s->h263_pred || s->h263_plus || !s->encoding) {
990         /* dc values */
991         // MN: we need these for  error resilience of intra-frames
992         FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
993         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
994         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
995         s->dc_val[2] = s->dc_val[1] + c_size;
996         for (i = 0; i < yc_size; i++)
997             s->dc_val_base[i] = 1024;
998     }
999
1000     /* which mb is a intra block */
1001     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
1002     memset(s->mbintra_table, 1, mb_array_size);
1003
1004     /* init macroblock skip table */
1005     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
1006     // Note the + 1 is for  a quicker mpeg4 slice_end detection
1007
1008     return init_er(s);
1009 fail:
1010     return AVERROR(ENOMEM);
1011 }
1012
1013 /**
1014  * init common structure for both encoder and decoder.
1015  * this assumes that some variables like width/height are already set
1016  */
1017 av_cold int ff_MPV_common_init(MpegEncContext *s)
1018 {
1019     int i;
1020     int nb_slices = (HAVE_THREADS &&
1021                      s->avctx->active_thread_type & FF_THREAD_SLICE) ?
1022                     s->avctx->thread_count : 1;
1023
1024     if (s->encoding && s->avctx->slices)
1025         nb_slices = s->avctx->slices;
1026
1027     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1028         s->mb_height = (s->height + 31) / 32 * 2;
1029     else if (s->codec_id != AV_CODEC_ID_H264)
1030         s->mb_height = (s->height + 15) / 16;
1031
1032     if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
1033         av_log(s->avctx, AV_LOG_ERROR,
1034                "decoding to AV_PIX_FMT_NONE is not supported.\n");
1035         return -1;
1036     }
1037
1038     if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
1039         int max_slices;
1040         if (s->mb_height)
1041             max_slices = FFMIN(MAX_THREADS, s->mb_height);
1042         else
1043             max_slices = MAX_THREADS;
1044         av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
1045                " reducing to %d\n", nb_slices, max_slices);
1046         nb_slices = max_slices;
1047     }
1048
1049     if ((s->width || s->height) &&
1050         av_image_check_size(s->width, s->height, 0, s->avctx))
1051         return -1;
1052
1053     ff_dct_common_init(s);
1054
1055     s->flags  = s->avctx->flags;
1056     s->flags2 = s->avctx->flags2;
1057
1058     /* set chroma shifts */
1059     avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
1060
1061     /* convert fourcc to upper case */
1062     s->codec_tag        = avpriv_toupper4(s->avctx->codec_tag);
1063     s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
1064
1065     s->avctx->coded_frame = &s->current_picture.f;
1066
1067     if (s->encoding) {
1068         if (s->msmpeg4_version) {
1069             FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
1070                                 2 * 2 * (MAX_LEVEL + 1) *
1071                                 (MAX_RUN + 1) * 2 * sizeof(int), fail);
1072         }
1073         FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
1074
1075         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix,          64 * 32   * sizeof(int), fail)
1076         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix,   64 * 32   * sizeof(int), fail)
1077         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix,          64 * 32   * sizeof(int), fail)
1078         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16,        64 * 32 * 2 * sizeof(uint16_t), fail)
1079         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
1080         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16,        64 * 32 * 2 * sizeof(uint16_t), fail)
1081         FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,           MAX_PICTURE_COUNT * sizeof(Picture *), fail)
1082         FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), fail)
1083
1084         if (s->avctx->noise_reduction) {
1085             FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail);
1086         }
1087     }
1088
1089     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
1090                       MAX_PICTURE_COUNT * sizeof(Picture), fail);
1091     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1092         avcodec_get_frame_defaults(&s->picture[i].f);
1093     }
1094     memset(&s->next_picture, 0, sizeof(s->next_picture));
1095     memset(&s->last_picture, 0, sizeof(s->last_picture));
1096     memset(&s->current_picture, 0, sizeof(s->current_picture));
1097     avcodec_get_frame_defaults(&s->next_picture.f);
1098     avcodec_get_frame_defaults(&s->last_picture.f);
1099     avcodec_get_frame_defaults(&s->current_picture.f);
1100
1101         if (init_context_frame(s))
1102             goto fail;
1103
1104         s->parse_context.state = -1;
1105
1106         s->context_initialized = 1;
1107         s->thread_context[0]   = s;
1108
1109 //     if (s->width && s->height) {
1110         if (nb_slices > 1) {
1111             for (i = 1; i < nb_slices; i++) {
1112                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1113                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1114             }
1115
1116             for (i = 0; i < nb_slices; i++) {
1117                 if (init_duplicate_context(s->thread_context[i]) < 0)
1118                     goto fail;
1119                     s->thread_context[i]->start_mb_y =
1120                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1121                     s->thread_context[i]->end_mb_y   =
1122                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1123             }
1124         } else {
1125             if (init_duplicate_context(s) < 0)
1126                 goto fail;
1127             s->start_mb_y = 0;
1128             s->end_mb_y   = s->mb_height;
1129         }
1130         s->slice_context_count = nb_slices;
1131 //     }
1132
1133     return 0;
1134  fail:
1135     ff_MPV_common_end(s);
1136     return -1;
1137 }
1138
1139 /**
1140  * Frees and resets MpegEncContext fields depending on the resolution.
1141  * Is used during resolution changes to avoid a full reinitialization of the
1142  * codec.
1143  */
1144 static int free_context_frame(MpegEncContext *s)
1145 {
1146     int i, j, k;
1147
1148     av_freep(&s->mb_type);
1149     av_freep(&s->p_mv_table_base);
1150     av_freep(&s->b_forw_mv_table_base);
1151     av_freep(&s->b_back_mv_table_base);
1152     av_freep(&s->b_bidir_forw_mv_table_base);
1153     av_freep(&s->b_bidir_back_mv_table_base);
1154     av_freep(&s->b_direct_mv_table_base);
1155     s->p_mv_table            = NULL;
1156     s->b_forw_mv_table       = NULL;
1157     s->b_back_mv_table       = NULL;
1158     s->b_bidir_forw_mv_table = NULL;
1159     s->b_bidir_back_mv_table = NULL;
1160     s->b_direct_mv_table     = NULL;
1161     for (i = 0; i < 2; i++) {
1162         for (j = 0; j < 2; j++) {
1163             for (k = 0; k < 2; k++) {
1164                 av_freep(&s->b_field_mv_table_base[i][j][k]);
1165                 s->b_field_mv_table[i][j][k] = NULL;
1166             }
1167             av_freep(&s->b_field_select_table[i][j]);
1168             av_freep(&s->p_field_mv_table_base[i][j]);
1169             s->p_field_mv_table[i][j] = NULL;
1170         }
1171         av_freep(&s->p_field_select_table[i]);
1172     }
1173
1174     av_freep(&s->dc_val_base);
1175     av_freep(&s->coded_block_base);
1176     av_freep(&s->mbintra_table);
1177     av_freep(&s->cbp_table);
1178     av_freep(&s->pred_dir_table);
1179
1180     av_freep(&s->mbskip_table);
1181
1182     av_freep(&s->er.error_status_table);
1183     av_freep(&s->er.er_temp_buffer);
1184     av_freep(&s->mb_index2xy);
1185     av_freep(&s->lambda_table);
1186
1187     av_freep(&s->cplx_tab);
1188     av_freep(&s->bits_tab);
1189
1190     s->linesize = s->uvlinesize = 0;
1191
1192     for (i = 0; i < 3; i++)
1193         av_freep(&s->visualization_buffer[i]);
1194
1195     return 0;
1196 }
1197
1198 int ff_MPV_common_frame_size_change(MpegEncContext *s)
1199 {
1200     int i, err = 0;
1201
1202     if (s->slice_context_count > 1) {
1203         for (i = 0; i < s->slice_context_count; i++) {
1204             free_duplicate_context(s->thread_context[i]);
1205         }
1206         for (i = 1; i < s->slice_context_count; i++) {
1207             av_freep(&s->thread_context[i]);
1208         }
1209     } else
1210         free_duplicate_context(s);
1211
1212     if ((err = free_context_frame(s)) < 0)
1213         return err;
1214
1215     if (s->picture)
1216         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1217                 s->picture[i].needs_realloc = 1;
1218         }
1219
1220     s->last_picture_ptr         =
1221     s->next_picture_ptr         =
1222     s->current_picture_ptr      = NULL;
1223
1224     // init
1225     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1226         s->mb_height = (s->height + 31) / 32 * 2;
1227     else if (s->codec_id != AV_CODEC_ID_H264)
1228         s->mb_height = (s->height + 15) / 16;
1229
1230     if ((s->width || s->height) &&
1231         av_image_check_size(s->width, s->height, 0, s->avctx))
1232         return AVERROR_INVALIDDATA;
1233
1234     if ((err = init_context_frame(s)))
1235         goto fail;
1236
1237     s->thread_context[0]   = s;
1238
1239     if (s->width && s->height) {
1240         int nb_slices = s->slice_context_count;
1241         if (nb_slices > 1) {
1242             for (i = 1; i < nb_slices; i++) {
1243                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1244                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1245             }
1246
1247             for (i = 0; i < nb_slices; i++) {
1248                 if (init_duplicate_context(s->thread_context[i]) < 0)
1249                     goto fail;
1250                     s->thread_context[i]->start_mb_y =
1251                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1252                     s->thread_context[i]->end_mb_y   =
1253                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1254             }
1255         } else {
1256             if (init_duplicate_context(s) < 0)
1257                 goto fail;
1258             s->start_mb_y = 0;
1259             s->end_mb_y   = s->mb_height;
1260         }
1261         s->slice_context_count = nb_slices;
1262     }
1263
1264     return 0;
1265  fail:
1266     ff_MPV_common_end(s);
1267     return err;
1268 }
1269
1270 /* init common structure for both encoder and decoder */
1271 void ff_MPV_common_end(MpegEncContext *s)
1272 {
1273     int i;
1274
1275     if (s->slice_context_count > 1) {
1276         for (i = 0; i < s->slice_context_count; i++) {
1277             free_duplicate_context(s->thread_context[i]);
1278         }
1279         for (i = 1; i < s->slice_context_count; i++) {
1280             av_freep(&s->thread_context[i]);
1281         }
1282         s->slice_context_count = 1;
1283     } else free_duplicate_context(s);
1284
1285     av_freep(&s->parse_context.buffer);
1286     s->parse_context.buffer_size = 0;
1287
1288     av_freep(&s->bitstream_buffer);
1289     s->allocated_bitstream_buffer_size = 0;
1290
1291     av_freep(&s->avctx->stats_out);
1292     av_freep(&s->ac_stats);
1293
1294     if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
1295     if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1296     s->q_chroma_intra_matrix=   NULL;
1297     s->q_chroma_intra_matrix16= NULL;
1298     av_freep(&s->q_intra_matrix);
1299     av_freep(&s->q_inter_matrix);
1300     av_freep(&s->q_intra_matrix16);
1301     av_freep(&s->q_inter_matrix16);
1302     av_freep(&s->input_picture);
1303     av_freep(&s->reordered_input_picture);
1304     av_freep(&s->dct_offset);
1305
1306     if (s->picture) {
1307         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1308             free_picture_tables(&s->picture[i]);
1309             ff_mpeg_unref_picture(s, &s->picture[i]);
1310         }
1311     }
1312     av_freep(&s->picture);
1313     free_picture_tables(&s->last_picture);
1314     ff_mpeg_unref_picture(s, &s->last_picture);
1315     free_picture_tables(&s->current_picture);
1316     ff_mpeg_unref_picture(s, &s->current_picture);
1317     free_picture_tables(&s->next_picture);
1318     ff_mpeg_unref_picture(s, &s->next_picture);
1319     free_picture_tables(&s->new_picture);
1320     ff_mpeg_unref_picture(s, &s->new_picture);
1321
1322     free_context_frame(s);
1323
1324     s->context_initialized      = 0;
1325     s->last_picture_ptr         =
1326     s->next_picture_ptr         =
1327     s->current_picture_ptr      = NULL;
1328     s->linesize = s->uvlinesize = 0;
1329 }
1330
1331 void ff_init_rl(RLTable *rl,
1332                 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1333 {
1334     int8_t  max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1335     uint8_t index_run[MAX_RUN + 1];
1336     int last, run, level, start, end, i;
1337
1338     /* If table is static, we can quit if rl->max_level[0] is not NULL */
1339     if (static_store && rl->max_level[0])
1340         return;
1341
1342     /* compute max_level[], max_run[] and index_run[] */
1343     for (last = 0; last < 2; last++) {
1344         if (last == 0) {
1345             start = 0;
1346             end = rl->last;
1347         } else {
1348             start = rl->last;
1349             end = rl->n;
1350         }
1351
1352         memset(max_level, 0, MAX_RUN + 1);
1353         memset(max_run, 0, MAX_LEVEL + 1);
1354         memset(index_run, rl->n, MAX_RUN + 1);
1355         for (i = start; i < end; i++) {
1356             run   = rl->table_run[i];
1357             level = rl->table_level[i];
1358             if (index_run[run] == rl->n)
1359                 index_run[run] = i;
1360             if (level > max_level[run])
1361                 max_level[run] = level;
1362             if (run > max_run[level])
1363                 max_run[level] = run;
1364         }
1365         if (static_store)
1366             rl->max_level[last] = static_store[last];
1367         else
1368             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1369         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1370         if (static_store)
1371             rl->max_run[last]   = static_store[last] + MAX_RUN + 1;
1372         else
1373             rl->max_run[last]   = av_malloc(MAX_LEVEL + 1);
1374         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1375         if (static_store)
1376             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1377         else
1378             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1379         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1380     }
1381 }
1382
1383 void ff_init_vlc_rl(RLTable *rl)
1384 {
1385     int i, q;
1386
1387     for (q = 0; q < 32; q++) {
1388         int qmul = q * 2;
1389         int qadd = (q - 1) | 1;
1390
1391         if (q == 0) {
1392             qmul = 1;
1393             qadd = 0;
1394         }
1395         for (i = 0; i < rl->vlc.table_size; i++) {
1396             int code = rl->vlc.table[i][0];
1397             int len  = rl->vlc.table[i][1];
1398             int level, run;
1399
1400             if (len == 0) { // illegal code
1401                 run   = 66;
1402                 level = MAX_LEVEL;
1403             } else if (len < 0) { // more bits needed
1404                 run   = 0;
1405                 level = code;
1406             } else {
1407                 if (code == rl->n) { // esc
1408                     run   = 66;
1409                     level =  0;
1410                 } else {
1411                     run   = rl->table_run[code] + 1;
1412                     level = rl->table_level[code] * qmul + qadd;
1413                     if (code >= rl->last) run += 192;
1414                 }
1415             }
1416             rl->rl_vlc[q][i].len   = len;
1417             rl->rl_vlc[q][i].level = level;
1418             rl->rl_vlc[q][i].run   = run;
1419         }
1420     }
1421 }
1422
1423 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1424 {
1425     int i;
1426
1427     /* release non reference frames */
1428     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1429         if (!s->picture[i].reference &&
1430             (remove_current || &s->picture[i] !=  s->current_picture_ptr)) {
1431             ff_mpeg_unref_picture(s, &s->picture[i]);
1432         }
1433     }
1434 }
1435
1436 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1437 {
1438     if (   (s->avctx->active_thread_type & FF_THREAD_FRAME)
1439         && pic->f.qscale_table //check if the frame has anything allocated
1440         && pic->period_since_free < s->avctx->thread_count)
1441         return 0;
1442     if (pic == s->last_picture_ptr)
1443         return 0;
1444     if (pic->f.data[0] == NULL)
1445         return 1;
1446     if (pic->needs_realloc && !(pic->reference & DELAYED_PIC_REF))
1447         return 1;
1448     return 0;
1449 }
1450
1451 static int find_unused_picture(MpegEncContext *s, int shared)
1452 {
1453     int i;
1454
1455     if (shared) {
1456         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1457             if (s->picture[i].f.data[0] == NULL && &s->picture[i] != s->last_picture_ptr)
1458                 return i;
1459         }
1460     } else {
1461         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1462             if (pic_is_unused(s, &s->picture[i]))
1463                 return i;
1464         }
1465     }
1466
1467     av_log(s->avctx, AV_LOG_FATAL,
1468            "Internal error, picture buffer overflow\n");
1469     /* We could return -1, but the codec would crash trying to draw into a
1470      * non-existing frame anyway. This is safer than waiting for a random crash.
1471      * Also the return of this is never useful, an encoder must only allocate
1472      * as much as allowed in the specification. This has no relationship to how
1473      * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1474      * enough for such valid streams).
1475      * Plus, a decoder has to check stream validity and remove frames if too
1476      * many reference frames are around. Waiting for "OOM" is not correct at
1477      * all. Similarly, missing reference frames have to be replaced by
1478      * interpolated/MC frames, anything else is a bug in the codec ...
1479      */
1480     abort();
1481     return -1;
1482 }
1483
1484 int ff_find_unused_picture(MpegEncContext *s, int shared)
1485 {
1486     int ret = find_unused_picture(s, shared);
1487
1488     if (ret >= 0 && ret < MAX_PICTURE_COUNT) {
1489         if (s->picture[ret].needs_realloc) {
1490             s->picture[ret].needs_realloc = 0;
1491             free_picture_tables(&s->picture[ret]);
1492             ff_mpeg_unref_picture(s, &s->picture[ret]);
1493             avcodec_get_frame_defaults(&s->picture[ret].f);
1494         }
1495     }
1496     return ret;
1497 }
1498
1499 static void update_noise_reduction(MpegEncContext *s)
1500 {
1501     int intra, i;
1502
1503     for (intra = 0; intra < 2; intra++) {
1504         if (s->dct_count[intra] > (1 << 16)) {
1505             for (i = 0; i < 64; i++) {
1506                 s->dct_error_sum[intra][i] >>= 1;
1507             }
1508             s->dct_count[intra] >>= 1;
1509         }
1510
1511         for (i = 0; i < 64; i++) {
1512             s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1513                                        s->dct_count[intra] +
1514                                        s->dct_error_sum[intra][i] / 2) /
1515                                       (s->dct_error_sum[intra][i] + 1);
1516         }
1517     }
1518 }
1519
1520 /**
1521  * generic function for encode/decode called after coding/decoding
1522  * the header and before a frame is coded/decoded.
1523  */
1524 int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1525 {
1526     int i, ret;
1527     Picture *pic;
1528     s->mb_skipped = 0;
1529
1530     if (!ff_thread_can_start_frame(avctx)) {
1531         av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1532         return -1;
1533     }
1534
1535     /* mark & release old frames */
1536     if (s->out_format != FMT_H264 || s->codec_id == AV_CODEC_ID_SVQ3) {
1537         if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1538             s->last_picture_ptr != s->next_picture_ptr &&
1539             s->last_picture_ptr->f.data[0]) {
1540             ff_mpeg_unref_picture(s, s->last_picture_ptr);
1541         }
1542
1543         /* release forgotten pictures */
1544         /* if (mpeg124/h263) */
1545         if (!s->encoding) {
1546             for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1547                 if (&s->picture[i] != s->last_picture_ptr &&
1548                     &s->picture[i] != s->next_picture_ptr &&
1549                     s->picture[i].reference && !s->picture[i].needs_realloc) {
1550                     if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1551                         av_log(avctx, AV_LOG_ERROR,
1552                                "releasing zombie picture\n");
1553                     ff_mpeg_unref_picture(s, &s->picture[i]);
1554                 }
1555             }
1556         }
1557     }
1558
1559     if (!s->encoding) {
1560         ff_release_unused_pictures(s, 1);
1561
1562         if (s->current_picture_ptr &&
1563             s->current_picture_ptr->f.data[0] == NULL) {
1564             // we already have a unused image
1565             // (maybe it was set before reading the header)
1566             pic = s->current_picture_ptr;
1567         } else {
1568             i   = ff_find_unused_picture(s, 0);
1569             if (i < 0) {
1570                 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1571                 return i;
1572             }
1573             pic = &s->picture[i];
1574         }
1575
1576         pic->reference = 0;
1577         if (!s->droppable) {
1578             if (s->codec_id == AV_CODEC_ID_H264)
1579                 pic->reference = s->picture_structure;
1580             else if (s->pict_type != AV_PICTURE_TYPE_B)
1581                 pic->reference = 3;
1582         }
1583
1584         pic->f.coded_picture_number = s->coded_picture_number++;
1585
1586         if (ff_alloc_picture(s, pic, 0) < 0)
1587             return -1;
1588
1589         s->current_picture_ptr = pic;
1590         // FIXME use only the vars from current_pic
1591         s->current_picture_ptr->f.top_field_first = s->top_field_first;
1592         if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1593             s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1594             if (s->picture_structure != PICT_FRAME)
1595                 s->current_picture_ptr->f.top_field_first =
1596                     (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1597         }
1598         s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1599                                                      !s->progressive_sequence;
1600         s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
1601     }
1602
1603     s->current_picture_ptr->f.pict_type = s->pict_type;
1604     // if (s->flags && CODEC_FLAG_QSCALE)
1605     //     s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1606     s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1607
1608     ff_mpeg_unref_picture(s, &s->current_picture);
1609     if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1610                                    s->current_picture_ptr)) < 0)
1611         return ret;
1612
1613     if (s->codec_id != AV_CODEC_ID_H264 && s->pict_type != AV_PICTURE_TYPE_B) {
1614         s->last_picture_ptr = s->next_picture_ptr;
1615         if (!s->droppable)
1616             s->next_picture_ptr = s->current_picture_ptr;
1617     }
1618     av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1619             s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1620             s->last_picture_ptr    ? s->last_picture_ptr->f.data[0]    : NULL,
1621             s->next_picture_ptr    ? s->next_picture_ptr->f.data[0]    : NULL,
1622             s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1623             s->pict_type, s->droppable);
1624
1625     if (s->codec_id != AV_CODEC_ID_H264) {
1626         if ((s->last_picture_ptr == NULL ||
1627              s->last_picture_ptr->f.data[0] == NULL) &&
1628             (s->pict_type != AV_PICTURE_TYPE_I ||
1629              s->picture_structure != PICT_FRAME)) {
1630             int h_chroma_shift, v_chroma_shift;
1631             av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1632                                              &h_chroma_shift, &v_chroma_shift);
1633             if (s->pict_type != AV_PICTURE_TYPE_I)
1634                 av_log(avctx, AV_LOG_ERROR,
1635                        "warning: first frame is no keyframe\n");
1636             else if (s->picture_structure != PICT_FRAME)
1637                 av_log(avctx, AV_LOG_INFO,
1638                        "allocate dummy last picture for field based first keyframe\n");
1639
1640             /* Allocate a dummy frame */
1641             i = ff_find_unused_picture(s, 0);
1642             if (i < 0) {
1643                 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1644                 return i;
1645             }
1646             s->last_picture_ptr = &s->picture[i];
1647             s->last_picture_ptr->f.key_frame = 0;
1648             if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1649                 s->last_picture_ptr = NULL;
1650                 return -1;
1651             }
1652
1653             memset(s->last_picture_ptr->f.data[0], 0x80,
1654                    avctx->height * s->last_picture_ptr->f.linesize[0]);
1655             memset(s->last_picture_ptr->f.data[1], 0x80,
1656                    (avctx->height >> v_chroma_shift) *
1657                    s->last_picture_ptr->f.linesize[1]);
1658             memset(s->last_picture_ptr->f.data[2], 0x80,
1659                    (avctx->height >> v_chroma_shift) *
1660                    s->last_picture_ptr->f.linesize[2]);
1661
1662             if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1663                 for(i=0; i<avctx->height; i++)
1664                     memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);
1665             }
1666             ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1667             ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1668         }
1669         if ((s->next_picture_ptr == NULL ||
1670              s->next_picture_ptr->f.data[0] == NULL) &&
1671             s->pict_type == AV_PICTURE_TYPE_B) {
1672             /* Allocate a dummy frame */
1673             i = ff_find_unused_picture(s, 0);
1674             if (i < 0) {
1675                 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1676                 return i;
1677             }
1678             s->next_picture_ptr = &s->picture[i];
1679             s->next_picture_ptr->f.key_frame = 0;
1680             if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1681                 s->next_picture_ptr = NULL;
1682                 return -1;
1683             }
1684             ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1685             ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1686         }
1687     }
1688
1689 #if 0 // BUFREF-FIXME
1690     memset(s->last_picture.f.data, 0, sizeof(s->last_picture.f.data));
1691     memset(s->next_picture.f.data, 0, sizeof(s->next_picture.f.data));
1692 #endif
1693     if (s->codec_id != AV_CODEC_ID_H264) {
1694         if (s->last_picture_ptr) {
1695             ff_mpeg_unref_picture(s, &s->last_picture);
1696             if (s->last_picture_ptr->f.data[0] &&
1697                 (ret = ff_mpeg_ref_picture(s, &s->last_picture,
1698                                            s->last_picture_ptr)) < 0)
1699                 return ret;
1700         }
1701         if (s->next_picture_ptr) {
1702             ff_mpeg_unref_picture(s, &s->next_picture);
1703             if (s->next_picture_ptr->f.data[0] &&
1704                 (ret = ff_mpeg_ref_picture(s, &s->next_picture,
1705                                            s->next_picture_ptr)) < 0)
1706                 return ret;
1707         }
1708
1709         assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1710                                                      s->last_picture_ptr->f.data[0]));
1711     }
1712
1713     if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1714         int i;
1715         for (i = 0; i < 4; i++) {
1716             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1717                 s->current_picture.f.data[i] +=
1718                     s->current_picture.f.linesize[i];
1719             }
1720             s->current_picture.f.linesize[i] *= 2;
1721             s->last_picture.f.linesize[i]    *= 2;
1722             s->next_picture.f.linesize[i]    *= 2;
1723         }
1724     }
1725
1726     s->err_recognition = avctx->err_recognition;
1727
1728     /* set dequantizer, we can't do it during init as
1729      * it might change for mpeg4 and we can't do it in the header
1730      * decode as init is not called for mpeg4 there yet */
1731     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1732         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1733         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1734     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1735         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1736         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1737     } else {
1738         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1739         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1740     }
1741
1742     if (s->dct_error_sum) {
1743         assert(s->avctx->noise_reduction && s->encoding);
1744         update_noise_reduction(s);
1745     }
1746
1747     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1748         return ff_xvmc_field_start(s, avctx);
1749
1750     return 0;
1751 }
1752
1753 /* generic function for encode/decode called after a
1754  * frame has been coded/decoded. */
1755 void ff_MPV_frame_end(MpegEncContext *s)
1756 {
1757     int i;
1758     /* redraw edges for the frame if decoding didn't complete */
1759     // just to make sure that all data is rendered.
1760     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1761         ff_xvmc_field_end(s);
1762    } else if ((s->er.error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1763               !s->avctx->hwaccel &&
1764               !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1765               s->unrestricted_mv &&
1766               s->current_picture.reference &&
1767               !s->intra_only &&
1768               !(s->flags & CODEC_FLAG_EMU_EDGE) &&
1769               !s->avctx->lowres
1770             ) {
1771         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1772         int hshift = desc->log2_chroma_w;
1773         int vshift = desc->log2_chroma_h;
1774         s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1775                           s->h_edge_pos, s->v_edge_pos,
1776                           EDGE_WIDTH, EDGE_WIDTH,
1777                           EDGE_TOP | EDGE_BOTTOM);
1778         s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1779                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1780                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1781                           EDGE_TOP | EDGE_BOTTOM);
1782         s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1783                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1784                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1785                           EDGE_TOP | EDGE_BOTTOM);
1786     }
1787
1788     emms_c();
1789
1790     s->last_pict_type                 = s->pict_type;
1791     s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1792     if (s->pict_type!= AV_PICTURE_TYPE_B) {
1793         s->last_non_b_pict_type = s->pict_type;
1794     }
1795 #if 0
1796     /* copy back current_picture variables */
1797     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1798         if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1799             s->picture[i] = s->current_picture;
1800             break;
1801         }
1802     }
1803     assert(i < MAX_PICTURE_COUNT);
1804 #endif
1805
1806     if (s->encoding) {
1807         /* release non-reference frames */
1808         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1809             if (!s->picture[i].reference)
1810                 ff_mpeg_unref_picture(s, &s->picture[i]);
1811         }
1812     }
1813     // clear copies, to avoid confusion
1814 #if 0
1815     memset(&s->last_picture,    0, sizeof(Picture));
1816     memset(&s->next_picture,    0, sizeof(Picture));
1817     memset(&s->current_picture, 0, sizeof(Picture));
1818 #endif
1819     s->avctx->coded_frame = &s->current_picture_ptr->f;
1820
1821     if (s->codec_id != AV_CODEC_ID_H264 && s->current_picture.reference)
1822         ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1823 }
1824
1825 /**
1826  * Draw a line from (ex, ey) -> (sx, sy).
1827  * @param w width of the image
1828  * @param h height of the image
1829  * @param stride stride/linesize of the image
1830  * @param color color of the arrow
1831  */
1832 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1833                       int w, int h, int stride, int color)
1834 {
1835     int x, y, fr, f;
1836
1837     sx = av_clip(sx, 0, w - 1);
1838     sy = av_clip(sy, 0, h - 1);
1839     ex = av_clip(ex, 0, w - 1);
1840     ey = av_clip(ey, 0, h - 1);
1841
1842     buf[sy * stride + sx] += color;
1843
1844     if (FFABS(ex - sx) > FFABS(ey - sy)) {
1845         if (sx > ex) {
1846             FFSWAP(int, sx, ex);
1847             FFSWAP(int, sy, ey);
1848         }
1849         buf += sx + sy * stride;
1850         ex  -= sx;
1851         f    = ((ey - sy) << 16) / ex;
1852         for (x = 0; x <= ex; x++) {
1853             y  = (x * f) >> 16;
1854             fr = (x * f) & 0xFFFF;
1855             buf[y * stride + x]       += (color * (0x10000 - fr)) >> 16;
1856             if(fr) buf[(y + 1) * stride + x] += (color *            fr ) >> 16;
1857         }
1858     } else {
1859         if (sy > ey) {
1860             FFSWAP(int, sx, ex);
1861             FFSWAP(int, sy, ey);
1862         }
1863         buf += sx + sy * stride;
1864         ey  -= sy;
1865         if (ey)
1866             f = ((ex - sx) << 16) / ey;
1867         else
1868             f = 0;
1869         for(y= 0; y <= ey; y++){
1870             x  = (y*f) >> 16;
1871             fr = (y*f) & 0xFFFF;
1872             buf[y * stride + x]     += (color * (0x10000 - fr)) >> 16;
1873             if(fr) buf[y * stride + x + 1] += (color *            fr ) >> 16;
1874         }
1875     }
1876 }
1877
1878 /**
1879  * Draw an arrow from (ex, ey) -> (sx, sy).
1880  * @param w width of the image
1881  * @param h height of the image
1882  * @param stride stride/linesize of the image
1883  * @param color color of the arrow
1884  */
1885 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1886                        int ey, int w, int h, int stride, int color)
1887 {
1888     int dx,dy;
1889
1890     sx = av_clip(sx, -100, w + 100);
1891     sy = av_clip(sy, -100, h + 100);
1892     ex = av_clip(ex, -100, w + 100);
1893     ey = av_clip(ey, -100, h + 100);
1894
1895     dx = ex - sx;
1896     dy = ey - sy;
1897
1898     if (dx * dx + dy * dy > 3 * 3) {
1899         int rx =  dx + dy;
1900         int ry = -dx + dy;
1901         int length = ff_sqrt((rx * rx + ry * ry) << 8);
1902
1903         // FIXME subpixel accuracy
1904         rx = ROUNDED_DIV(rx * 3 << 4, length);
1905         ry = ROUNDED_DIV(ry * 3 << 4, length);
1906
1907         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1908         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1909     }
1910     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1911 }
1912
1913 /**
1914  * Print debugging info for the given picture.
1915  */
1916 void ff_print_debug_info2(AVCodecContext *avctx, Picture *p, uint8_t *mbskip_table,
1917                          uint8_t *visualization_buffer[3], int *low_delay,
1918                          int mb_width, int mb_height, int mb_stride, int quarter_sample)
1919 {
1920     AVFrame *pict;
1921     if (avctx->hwaccel || !p || !p->mb_type
1922         || (avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
1923         return;
1924     pict = &p->f;
1925
1926
1927     if (avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1928         int x,y;
1929
1930         av_log(avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1931                av_get_picture_type_char(pict->pict_type));
1932         for (y = 0; y < mb_height; y++) {
1933             for (x = 0; x < mb_width; x++) {
1934                 if (avctx->debug & FF_DEBUG_SKIP) {
1935                     int count = mbskip_table[x + y * mb_stride];
1936                     if (count > 9)
1937                         count = 9;
1938                     av_log(avctx, AV_LOG_DEBUG, "%1d", count);
1939                 }
1940                 if (avctx->debug & FF_DEBUG_QP) {
1941                     av_log(avctx, AV_LOG_DEBUG, "%2d",
1942                            p->qscale_table[x + y * mb_stride]);
1943                 }
1944                 if (avctx->debug & FF_DEBUG_MB_TYPE) {
1945                     int mb_type = p->mb_type[x + y * mb_stride];
1946                     // Type & MV direction
1947                     if (IS_PCM(mb_type))
1948                         av_log(avctx, AV_LOG_DEBUG, "P");
1949                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1950                         av_log(avctx, AV_LOG_DEBUG, "A");
1951                     else if (IS_INTRA4x4(mb_type))
1952                         av_log(avctx, AV_LOG_DEBUG, "i");
1953                     else if (IS_INTRA16x16(mb_type))
1954                         av_log(avctx, AV_LOG_DEBUG, "I");
1955                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1956                         av_log(avctx, AV_LOG_DEBUG, "d");
1957                     else if (IS_DIRECT(mb_type))
1958                         av_log(avctx, AV_LOG_DEBUG, "D");
1959                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1960                         av_log(avctx, AV_LOG_DEBUG, "g");
1961                     else if (IS_GMC(mb_type))
1962                         av_log(avctx, AV_LOG_DEBUG, "G");
1963                     else if (IS_SKIP(mb_type))
1964                         av_log(avctx, AV_LOG_DEBUG, "S");
1965                     else if (!USES_LIST(mb_type, 1))
1966                         av_log(avctx, AV_LOG_DEBUG, ">");
1967                     else if (!USES_LIST(mb_type, 0))
1968                         av_log(avctx, AV_LOG_DEBUG, "<");
1969                     else {
1970                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1971                         av_log(avctx, AV_LOG_DEBUG, "X");
1972                     }
1973
1974                     // segmentation
1975                     if (IS_8X8(mb_type))
1976                         av_log(avctx, AV_LOG_DEBUG, "+");
1977                     else if (IS_16X8(mb_type))
1978                         av_log(avctx, AV_LOG_DEBUG, "-");
1979                     else if (IS_8X16(mb_type))
1980                         av_log(avctx, AV_LOG_DEBUG, "|");
1981                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1982                         av_log(avctx, AV_LOG_DEBUG, " ");
1983                     else
1984                         av_log(avctx, AV_LOG_DEBUG, "?");
1985
1986
1987                     if (IS_INTERLACED(mb_type))
1988                         av_log(avctx, AV_LOG_DEBUG, "=");
1989                     else
1990                         av_log(avctx, AV_LOG_DEBUG, " ");
1991                 }
1992             }
1993             av_log(avctx, AV_LOG_DEBUG, "\n");
1994         }
1995     }
1996
1997     if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1998         (avctx->debug_mv)) {
1999         const int shift = 1 + quarter_sample;
2000         int mb_y;
2001         uint8_t *ptr;
2002         int i;
2003         int h_chroma_shift, v_chroma_shift, block_height;
2004         const int width          = avctx->width;
2005         const int height         = avctx->height;
2006         const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
2007         const int mv_stride      = (mb_width << mv_sample_log2) +
2008                                    (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
2009         *low_delay = 0; // needed to see the vectors without trashing the buffers
2010
2011         avcodec_get_chroma_sub_sample(avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2012
2013         for (i = 0; i < 3; i++) {
2014             size_t size= (i == 0) ? pict->linesize[i] * FFALIGN(height, 16):
2015                          pict->linesize[i] * FFALIGN(height, 16) >> v_chroma_shift;
2016             visualization_buffer[i]= av_realloc(visualization_buffer[i], size);
2017             memcpy(visualization_buffer[i], pict->data[i], size);
2018             pict->data[i] = visualization_buffer[i];
2019         }
2020         pict->opaque = NULL;
2021         ptr          = pict->data[0];
2022         block_height = 16 >> v_chroma_shift;
2023
2024         for (mb_y = 0; mb_y < mb_height; mb_y++) {
2025             int mb_x;
2026             for (mb_x = 0; mb_x < mb_width; mb_x++) {
2027                 const int mb_index = mb_x + mb_y * mb_stride;
2028                 if ((avctx->debug_mv) && p->motion_val[0]) {
2029                     int type;
2030                     for (type = 0; type < 3; type++) {
2031                         int direction = 0;
2032                         switch (type) {
2033                         case 0:
2034                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
2035                                 (pict->pict_type!= AV_PICTURE_TYPE_P))
2036                                 continue;
2037                             direction = 0;
2038                             break;
2039                         case 1:
2040                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
2041                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
2042                                 continue;
2043                             direction = 0;
2044                             break;
2045                         case 2:
2046                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
2047                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
2048                                 continue;
2049                             direction = 1;
2050                             break;
2051                         }
2052                         if (!USES_LIST(p->mb_type[mb_index], direction))
2053                             continue;
2054
2055                         if (IS_8X8(p->mb_type[mb_index])) {
2056                             int i;
2057                             for (i = 0; i < 4; i++) {
2058                                 int sx = mb_x * 16 + 4 + 8 * (i & 1);
2059                                 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
2060                                 int xy = (mb_x * 2 + (i & 1) +
2061                                           (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2062                                 int mx = (p->motion_val[direction][xy][0] >> shift) + sx;
2063                                 int my = (p->motion_val[direction][xy][1] >> shift) + sy;
2064                                 draw_arrow(ptr, sx, sy, mx, my, width,
2065                                            height, pict->linesize[0], 100);
2066                             }
2067                         } else if (IS_16X8(p->mb_type[mb_index])) {
2068                             int i;
2069                             for (i = 0; i < 2; i++) {
2070                                 int sx = mb_x * 16 + 8;
2071                                 int sy = mb_y * 16 + 4 + 8 * i;
2072                                 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
2073                                 int mx = (p->motion_val[direction][xy][0] >> shift);
2074                                 int my = (p->motion_val[direction][xy][1] >> shift);
2075
2076                                 if (IS_INTERLACED(p->mb_type[mb_index]))
2077                                     my *= 2;
2078
2079                             draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2080                                        height, pict->linesize[0], 100);
2081                             }
2082                         } else if (IS_8X16(p->mb_type[mb_index])) {
2083                             int i;
2084                             for (i = 0; i < 2; i++) {
2085                                 int sx = mb_x * 16 + 4 + 8 * i;
2086                                 int sy = mb_y * 16 + 8;
2087                                 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
2088                                 int mx = p->motion_val[direction][xy][0] >> shift;
2089                                 int my = p->motion_val[direction][xy][1] >> shift;
2090
2091                                 if (IS_INTERLACED(p->mb_type[mb_index]))
2092                                     my *= 2;
2093
2094                                 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2095                                            height, pict->linesize[0], 100);
2096                             }
2097                         } else {
2098                               int sx= mb_x * 16 + 8;
2099                               int sy= mb_y * 16 + 8;
2100                               int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
2101                               int mx= (p->motion_val[direction][xy][0]>>shift) + sx;
2102                               int my= (p->motion_val[direction][xy][1]>>shift) + sy;
2103                               draw_arrow(ptr, sx, sy, mx, my, width, height, pict->linesize[0], 100);
2104                         }
2105                     }
2106                 }
2107                 if ((avctx->debug & FF_DEBUG_VIS_QP)) {
2108                     uint64_t c = (p->qscale_table[mb_index] * 128 / 31) *
2109                                  0x0101010101010101ULL;
2110                     int y;
2111                     for (y = 0; y < block_height; y++) {
2112                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
2113                                       (block_height * mb_y + y) *
2114                                       pict->linesize[1]) = c;
2115                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
2116                                       (block_height * mb_y + y) *
2117                                       pict->linesize[2]) = c;
2118                     }
2119                 }
2120                 if ((avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
2121                     p->motion_val[0]) {
2122                     int mb_type = p->mb_type[mb_index];
2123                     uint64_t u,v;
2124                     int y;
2125 #define COLOR(theta, r) \
2126     u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
2127     v = (int)(128 + r * sin(theta * 3.141592 / 180));
2128
2129
2130                     u = v = 128;
2131                     if (IS_PCM(mb_type)) {
2132                         COLOR(120, 48)
2133                     } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
2134                                IS_INTRA16x16(mb_type)) {
2135                         COLOR(30, 48)
2136                     } else if (IS_INTRA4x4(mb_type)) {
2137                         COLOR(90, 48)
2138                     } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
2139                         // COLOR(120, 48)
2140                     } else if (IS_DIRECT(mb_type)) {
2141                         COLOR(150, 48)
2142                     } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
2143                         COLOR(170, 48)
2144                     } else if (IS_GMC(mb_type)) {
2145                         COLOR(190, 48)
2146                     } else if (IS_SKIP(mb_type)) {
2147                         // COLOR(180, 48)
2148                     } else if (!USES_LIST(mb_type, 1)) {
2149                         COLOR(240, 48)
2150                     } else if (!USES_LIST(mb_type, 0)) {
2151                         COLOR(0, 48)
2152                     } else {
2153                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2154                         COLOR(300,48)
2155                     }
2156
2157                     u *= 0x0101010101010101ULL;
2158                     v *= 0x0101010101010101ULL;
2159                     for (y = 0; y < block_height; y++) {
2160                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
2161                                       (block_height * mb_y + y) * pict->linesize[1]) = u;
2162                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
2163                                       (block_height * mb_y + y) * pict->linesize[2]) = v;
2164                     }
2165
2166                     // segmentation
2167                     if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
2168                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
2169                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2170                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
2171                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2172                     }
2173                     if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
2174                         for (y = 0; y < 16; y++)
2175                             pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
2176                                           pict->linesize[0]] ^= 0x80;
2177                     }
2178                     if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
2179                         int dm = 1 << (mv_sample_log2 - 2);
2180                         for (i = 0; i < 4; i++) {
2181                             int sx = mb_x * 16 + 8 * (i & 1);
2182                             int sy = mb_y * 16 + 8 * (i >> 1);
2183                             int xy = (mb_x * 2 + (i & 1) +
2184                                      (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2185                             // FIXME bidir
2186                             int32_t *mv = (int32_t *) &p->motion_val[0][xy];
2187                             if (mv[0] != mv[dm] ||
2188                                 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
2189                                 for (y = 0; y < 8; y++)
2190                                     pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
2191                             if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
2192                                 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
2193                                               pict->linesize[0]) ^= 0x8080808080808080ULL;
2194                         }
2195                     }
2196
2197                     if (IS_INTERLACED(mb_type) &&
2198                         avctx->codec->id == AV_CODEC_ID_H264) {
2199                         // hmm
2200                     }
2201                 }
2202                 mbskip_table[mb_index] = 0;
2203             }
2204         }
2205     }
2206 }
2207
2208 void ff_print_debug_info(MpegEncContext *s, Picture *p)
2209 {
2210     ff_print_debug_info2(s->avctx, p, s->mbskip_table, s->visualization_buffer, &s->low_delay,
2211                          s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
2212 }
2213
2214 static inline int hpel_motion_lowres(MpegEncContext *s,
2215                                      uint8_t *dest, uint8_t *src,
2216                                      int field_based, int field_select,
2217                                      int src_x, int src_y,
2218                                      int width, int height, int stride,
2219                                      int h_edge_pos, int v_edge_pos,
2220                                      int w, int h, h264_chroma_mc_func *pix_op,
2221                                      int motion_x, int motion_y)
2222 {
2223     const int lowres   = s->avctx->lowres;
2224     const int op_index = FFMIN(lowres, 2);
2225     const int s_mask   = (2 << lowres) - 1;
2226     int emu = 0;
2227     int sx, sy;
2228
2229     if (s->quarter_sample) {
2230         motion_x /= 2;
2231         motion_y /= 2;
2232     }
2233
2234     sx = motion_x & s_mask;
2235     sy = motion_y & s_mask;
2236     src_x += motion_x >> lowres + 1;
2237     src_y += motion_y >> lowres + 1;
2238
2239     src   += src_y * stride + src_x;
2240
2241     if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w,                 0) ||
2242         (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2243         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
2244                                 (h + 1) << field_based, src_x,
2245                                 src_y   << field_based,
2246                                 h_edge_pos,
2247                                 v_edge_pos);
2248         src = s->edge_emu_buffer;
2249         emu = 1;
2250     }
2251
2252     sx = (sx << 2) >> lowres;
2253     sy = (sy << 2) >> lowres;
2254     if (field_select)
2255         src += s->linesize;
2256     pix_op[op_index](dest, src, stride, h, sx, sy);
2257     return emu;
2258 }
2259
2260 /* apply one mpeg motion vector to the three components */
2261 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2262                                                 uint8_t *dest_y,
2263                                                 uint8_t *dest_cb,
2264                                                 uint8_t *dest_cr,
2265                                                 int field_based,
2266                                                 int bottom_field,
2267                                                 int field_select,
2268                                                 uint8_t **ref_picture,
2269                                                 h264_chroma_mc_func *pix_op,
2270                                                 int motion_x, int motion_y,
2271                                                 int h, int mb_y)
2272 {
2273     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2274     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
2275         uvsx, uvsy;
2276     const int lowres     = s->avctx->lowres;
2277     const int op_index   = FFMIN(lowres-1+s->chroma_x_shift, 2);
2278     const int block_s    = 8>>lowres;
2279     const int s_mask     = (2 << lowres) - 1;
2280     const int h_edge_pos = s->h_edge_pos >> lowres;
2281     const int v_edge_pos = s->v_edge_pos >> lowres;
2282     linesize   = s->current_picture.f.linesize[0] << field_based;
2283     uvlinesize = s->current_picture.f.linesize[1] << field_based;
2284
2285     // FIXME obviously not perfect but qpel will not work in lowres anyway
2286     if (s->quarter_sample) {
2287         motion_x /= 2;
2288         motion_y /= 2;
2289     }
2290
2291     if(field_based){
2292         motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2293     }
2294
2295     sx = motion_x & s_mask;
2296     sy = motion_y & s_mask;
2297     src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2298     src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2299
2300     if (s->out_format == FMT_H263) {
2301         uvsx    = ((motion_x >> 1) & s_mask) | (sx & 1);
2302         uvsy    = ((motion_y >> 1) & s_mask) | (sy & 1);
2303         uvsrc_x = src_x >> 1;
2304         uvsrc_y = src_y >> 1;
2305     } else if (s->out_format == FMT_H261) {
2306         // even chroma mv's are full pel in H261
2307         mx      = motion_x / 4;
2308         my      = motion_y / 4;
2309         uvsx    = (2 * mx) & s_mask;
2310         uvsy    = (2 * my) & s_mask;
2311         uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2312         uvsrc_y =    mb_y * block_s + (my >> lowres);
2313     } else {
2314         if(s->chroma_y_shift){
2315             mx      = motion_x / 2;
2316             my      = motion_y / 2;
2317             uvsx    = mx & s_mask;
2318             uvsy    = my & s_mask;
2319             uvsrc_x = s->mb_x * block_s                 + (mx >> lowres + 1);
2320             uvsrc_y =   (mb_y * block_s >> field_based) + (my >> lowres + 1);
2321         } else {
2322             if(s->chroma_x_shift){
2323             //Chroma422
2324                 mx = motion_x / 2;
2325                 uvsx = mx & s_mask;
2326                 uvsy = motion_y & s_mask;
2327                 uvsrc_y = src_y;
2328                 uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2329             } else {
2330             //Chroma444
2331                 uvsx = motion_x & s_mask;
2332                 uvsy = motion_y & s_mask;
2333                 uvsrc_x = src_x;
2334                 uvsrc_y = src_y;
2335             }
2336         }
2337     }
2338
2339     ptr_y  = ref_picture[0] + src_y   * linesize   + src_x;
2340     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2341     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2342
2343     if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s,       0) ||
2344         (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2345         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2346                                 linesize >> field_based, 17, 17 + field_based,
2347                                 src_x, src_y << field_based, h_edge_pos,
2348                                 v_edge_pos);
2349         ptr_y = s->edge_emu_buffer;
2350         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2351             uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
2352             s->vdsp.emulated_edge_mc(uvbuf , ptr_cb, uvlinesize >> field_based, 9,
2353                                     9 + field_based,
2354                                     uvsrc_x, uvsrc_y << field_based,
2355                                     h_edge_pos >> 1, v_edge_pos >> 1);
2356             s->vdsp.emulated_edge_mc(uvbuf + 16, ptr_cr, uvlinesize >> field_based, 9,
2357                                     9 + field_based,
2358                                     uvsrc_x, uvsrc_y << field_based,
2359                                     h_edge_pos >> 1, v_edge_pos >> 1);
2360             ptr_cb = uvbuf;
2361             ptr_cr = uvbuf + 16;
2362         }
2363     }
2364
2365     // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
2366     if (bottom_field) {
2367         dest_y  += s->linesize;
2368         dest_cb += s->uvlinesize;
2369         dest_cr += s->uvlinesize;
2370     }
2371
2372     if (field_select) {
2373         ptr_y   += s->linesize;
2374         ptr_cb  += s->uvlinesize;
2375         ptr_cr  += s->uvlinesize;
2376     }
2377
2378     sx = (sx << 2) >> lowres;
2379     sy = (sy << 2) >> lowres;
2380     pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2381
2382     if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2383         uvsx = (uvsx << 2) >> lowres;
2384         uvsy = (uvsy << 2) >> lowres;
2385         if (h >> s->chroma_y_shift) {
2386             pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2387             pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2388         }
2389     }
2390     // FIXME h261 lowres loop filter
2391 }
2392
2393 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2394                                             uint8_t *dest_cb, uint8_t *dest_cr,
2395                                             uint8_t **ref_picture,
2396                                             h264_chroma_mc_func * pix_op,
2397                                             int mx, int my)
2398 {
2399     const int lowres     = s->avctx->lowres;
2400     const int op_index   = FFMIN(lowres, 2);
2401     const int block_s    = 8 >> lowres;
2402     const int s_mask     = (2 << lowres) - 1;
2403     const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2404     const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2405     int emu = 0, src_x, src_y, offset, sx, sy;
2406     uint8_t *ptr;
2407
2408     if (s->quarter_sample) {
2409         mx /= 2;
2410         my /= 2;
2411     }
2412
2413     /* In case of 8X8, we construct a single chroma motion vector
2414        with a special rounding */
2415     mx = ff_h263_round_chroma(mx);
2416     my = ff_h263_round_chroma(my);
2417
2418     sx = mx & s_mask;
2419     sy = my & s_mask;
2420     src_x = s->mb_x * block_s + (mx >> lowres + 1);
2421     src_y = s->mb_y * block_s + (my >> lowres + 1);
2422
2423     offset = src_y * s->uvlinesize + src_x;
2424     ptr = ref_picture[1] + offset;
2425     if (s->flags & CODEC_FLAG_EMU_EDGE) {
2426         if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2427             (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2428             s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
2429                                     9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2430             ptr = s->edge_emu_buffer;
2431             emu = 1;
2432         }
2433     }
2434     sx = (sx << 2) >> lowres;
2435     sy = (sy << 2) >> lowres;
2436     pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2437
2438     ptr = ref_picture[2] + offset;
2439     if (emu) {
2440         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2441                                 src_x, src_y, h_edge_pos, v_edge_pos);
2442         ptr = s->edge_emu_buffer;
2443     }
2444     pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2445 }
2446
2447 /**
2448  * motion compensation of a single macroblock
2449  * @param s context
2450  * @param dest_y luma destination pointer
2451  * @param dest_cb chroma cb/u destination pointer
2452  * @param dest_cr chroma cr/v destination pointer
2453  * @param dir direction (0->forward, 1->backward)
2454  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2455  * @param pix_op halfpel motion compensation function (average or put normally)
2456  * the motion vectors are taken from s->mv and the MV type from s->mv_type
2457  */
2458 static inline void MPV_motion_lowres(MpegEncContext *s,
2459                                      uint8_t *dest_y, uint8_t *dest_cb,
2460                                      uint8_t *dest_cr,
2461                                      int dir, uint8_t **ref_picture,
2462                                      h264_chroma_mc_func *pix_op)
2463 {
2464     int mx, my;
2465     int mb_x, mb_y, i;
2466     const int lowres  = s->avctx->lowres;
2467     const int block_s = 8 >>lowres;
2468
2469     mb_x = s->mb_x;
2470     mb_y = s->mb_y;
2471
2472     switch (s->mv_type) {
2473     case MV_TYPE_16X16:
2474         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2475                            0, 0, 0,
2476                            ref_picture, pix_op,
2477                            s->mv[dir][0][0], s->mv[dir][0][1],
2478                            2 * block_s, mb_y);
2479         break;
2480     case MV_TYPE_8X8:
2481         mx = 0;
2482         my = 0;
2483         for (i = 0; i < 4; i++) {
2484             hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2485                                s->linesize) * block_s,
2486                                ref_picture[0], 0, 0,
2487                                (2 * mb_x + (i & 1)) * block_s,
2488                                (2 * mb_y + (i >> 1)) * block_s,
2489                                s->width, s->height, s->linesize,
2490                                s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2491                                block_s, block_s, pix_op,
2492                                s->mv[dir][i][0], s->mv[dir][i][1]);
2493
2494             mx += s->mv[dir][i][0];
2495             my += s->mv[dir][i][1];
2496         }
2497
2498         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2499             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2500                                      pix_op, mx, my);
2501         break;
2502     case MV_TYPE_FIELD:
2503         if (s->picture_structure == PICT_FRAME) {
2504             /* top field */
2505             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2506                                1, 0, s->field_select[dir][0],
2507                                ref_picture, pix_op,
2508                                s->mv[dir][0][0], s->mv[dir][0][1],
2509                                block_s, mb_y);
2510             /* bottom field */
2511             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2512                                1, 1, s->field_select[dir][1],
2513                                ref_picture, pix_op,
2514                                s->mv[dir][1][0], s->mv[dir][1][1],
2515                                block_s, mb_y);
2516         } else {
2517             if (s->picture_structure != s->field_select[dir][0] + 1 &&
2518                 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2519                 ref_picture = s->current_picture_ptr->f.data;
2520
2521             }
2522             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2523                                0, 0, s->field_select[dir][0],
2524                                ref_picture, pix_op,
2525                                s->mv[dir][0][0],
2526                                s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2527             }
2528         break;
2529     case MV_TYPE_16X8:
2530         for (i = 0; i < 2; i++) {
2531             uint8_t **ref2picture;
2532
2533             if (s->picture_structure == s->field_select[dir][i] + 1 ||
2534                 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2535                 ref2picture = ref_picture;
2536             } else {
2537                 ref2picture = s->current_picture_ptr->f.data;
2538             }
2539
2540             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2541                                0, 0, s->field_select[dir][i],
2542                                ref2picture, pix_op,
2543                                s->mv[dir][i][0], s->mv[dir][i][1] +
2544                                2 * block_s * i, block_s, mb_y >> 1);
2545
2546             dest_y  +=  2 * block_s *  s->linesize;
2547             dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2548             dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2549         }
2550         break;
2551     case MV_TYPE_DMV:
2552         if (s->picture_structure == PICT_FRAME) {
2553             for (i = 0; i < 2; i++) {
2554                 int j;
2555                 for (j = 0; j < 2; j++) {
2556                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2557                                        1, j, j ^ i,
2558                                        ref_picture, pix_op,
2559                                        s->mv[dir][2 * i + j][0],
2560                                        s->mv[dir][2 * i + j][1],
2561                                        block_s, mb_y);
2562                 }
2563                 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2564             }
2565         } else {
2566             for (i = 0; i < 2; i++) {
2567                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2568                                    0, 0, s->picture_structure != i + 1,
2569                                    ref_picture, pix_op,
2570                                    s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2571                                    2 * block_s, mb_y >> 1);
2572
2573                 // after put we make avg of the same block
2574                 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2575
2576                 // opposite parity is always in the same
2577                 // frame if this is second field
2578                 if (!s->first_field) {
2579                     ref_picture = s->current_picture_ptr->f.data;
2580                 }
2581             }
2582         }
2583         break;
2584     default:
2585         av_assert2(0);
2586     }
2587 }
2588
2589 /**
2590  * find the lowest MB row referenced in the MVs
2591  */
2592 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2593 {
2594     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2595     int my, off, i, mvs;
2596
2597     if (s->picture_structure != PICT_FRAME || s->mcsel)
2598         goto unhandled;
2599
2600     switch (s->mv_type) {
2601         case MV_TYPE_16X16:
2602             mvs = 1;
2603             break;
2604         case MV_TYPE_16X8:
2605             mvs = 2;
2606             break;
2607         case MV_TYPE_8X8:
2608             mvs = 4;
2609             break;
2610         default:
2611             goto unhandled;
2612     }
2613
2614     for (i = 0; i < mvs; i++) {
2615         my = s->mv[dir][i][1]<<qpel_shift;
2616         my_max = FFMAX(my_max, my);
2617         my_min = FFMIN(my_min, my);
2618     }
2619
2620     off = (FFMAX(-my_min, my_max) + 63) >> 6;
2621
2622     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2623 unhandled:
2624     return s->mb_height-1;
2625 }
2626
2627 /* put block[] to dest[] */
2628 static inline void put_dct(MpegEncContext *s,
2629                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2630 {
2631     s->dct_unquantize_intra(s, block, i, qscale);
2632     s->dsp.idct_put (dest, line_size, block);
2633 }
2634
2635 /* add block[] to dest[] */
2636 static inline void add_dct(MpegEncContext *s,
2637                            int16_t *block, int i, uint8_t *dest, int line_size)
2638 {
2639     if (s->block_last_index[i] >= 0) {
2640         s->dsp.idct_add (dest, line_size, block);
2641     }
2642 }
2643
2644 static inline void add_dequant_dct(MpegEncContext *s,
2645                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2646 {
2647     if (s->block_last_index[i] >= 0) {
2648         s->dct_unquantize_inter(s, block, i, qscale);
2649
2650         s->dsp.idct_add (dest, line_size, block);
2651     }
2652 }
2653
2654 /**
2655  * Clean dc, ac, coded_block for the current non-intra MB.
2656  */
2657 void ff_clean_intra_table_entries(MpegEncContext *s)
2658 {
2659     int wrap = s->b8_stride;
2660     int xy = s->block_index[0];
2661
2662     s->dc_val[0][xy           ] =
2663     s->dc_val[0][xy + 1       ] =
2664     s->dc_val[0][xy     + wrap] =
2665     s->dc_val[0][xy + 1 + wrap] = 1024;
2666     /* ac pred */
2667     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2668     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2669     if (s->msmpeg4_version>=3) {
2670         s->coded_block[xy           ] =
2671         s->coded_block[xy + 1       ] =
2672         s->coded_block[xy     + wrap] =
2673         s->coded_block[xy + 1 + wrap] = 0;
2674     }
2675     /* chroma */
2676     wrap = s->mb_stride;
2677     xy = s->mb_x + s->mb_y * wrap;
2678     s->dc_val[1][xy] =
2679     s->dc_val[2][xy] = 1024;
2680     /* ac pred */
2681     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2682     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2683
2684     s->mbintra_table[xy]= 0;
2685 }
2686
2687 /* generic function called after a macroblock has been parsed by the
2688    decoder or after it has been encoded by the encoder.
2689
2690    Important variables used:
2691    s->mb_intra : true if intra macroblock
2692    s->mv_dir   : motion vector direction
2693    s->mv_type  : motion vector type
2694    s->mv       : motion vector
2695    s->interlaced_dct : true if interlaced dct used (mpeg2)
2696  */
2697 static av_always_inline
2698 void MPV_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
2699                             int lowres_flag, int is_mpeg12)
2700 {
2701     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2702     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2703         ff_xvmc_decode_mb(s);//xvmc uses pblocks
2704         return;
2705     }
2706
2707     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2708        /* print DCT coefficients */
2709        int i,j;
2710        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2711        for(i=0; i<6; i++){
2712            for(j=0; j<64; j++){
2713                av_log(s->avctx, AV_LOG_DEBUG, "%5d", block[i][s->dsp.idct_permutation[j]]);
2714            }
2715            av_log(s->avctx, AV_LOG_DEBUG, "\n");
2716        }
2717     }
2718
2719     s->current_picture.qscale_table[mb_xy] = s->qscale;
2720
2721     /* update DC predictors for P macroblocks */
2722     if (!s->mb_intra) {
2723         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2724             if(s->mbintra_table[mb_xy])
2725                 ff_clean_intra_table_entries(s);
2726         } else {
2727             s->last_dc[0] =
2728             s->last_dc[1] =
2729             s->last_dc[2] = 128 << s->intra_dc_precision;
2730         }
2731     }
2732     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2733         s->mbintra_table[mb_xy]=1;
2734
2735     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
2736         uint8_t *dest_y, *dest_cb, *dest_cr;
2737         int dct_linesize, dct_offset;
2738         op_pixels_func (*op_pix)[4];
2739         qpel_mc_func (*op_qpix)[16];
2740         const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2741         const int uvlinesize = s->current_picture.f.linesize[1];
2742         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2743         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2744
2745         /* avoid copy if macroblock skipped in last frame too */
2746         /* skip only during decoding as we might trash the buffers during encoding a bit */
2747         if(!s->encoding){
2748             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2749
2750             if (s->mb_skipped) {
2751                 s->mb_skipped= 0;
2752                 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2753                 *mbskip_ptr = 1;
2754             } else if(!s->current_picture.reference) {
2755                 *mbskip_ptr = 1;
2756             } else{
2757                 *mbskip_ptr = 0; /* not skipped */
2758             }
2759         }
2760
2761         dct_linesize = linesize << s->interlaced_dct;
2762         dct_offset   = s->interlaced_dct ? linesize : linesize * block_size;
2763
2764         if(readable){
2765             dest_y=  s->dest[0];
2766             dest_cb= s->dest[1];
2767             dest_cr= s->dest[2];
2768         }else{
2769             dest_y = s->b_scratchpad;
2770             dest_cb= s->b_scratchpad+16*linesize;
2771             dest_cr= s->b_scratchpad+32*linesize;
2772         }
2773
2774         if (!s->mb_intra) {
2775             /* motion handling */
2776             /* decoding or more than one mb_type (MC was already done otherwise) */
2777             if(!s->encoding){
2778
2779                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2780                     if (s->mv_dir & MV_DIR_FORWARD) {
2781                         ff_thread_await_progress(&s->last_picture_ptr->tf,
2782                                                  ff_MPV_lowest_referenced_row(s, 0),
2783                                                  0);
2784                     }
2785                     if (s->mv_dir & MV_DIR_BACKWARD) {
2786                         ff_thread_await_progress(&s->next_picture_ptr->tf,
2787                                                  ff_MPV_lowest_referenced_row(s, 1),
2788                                                  0);
2789                     }
2790                 }
2791
2792                 if(lowres_flag){
2793                     h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
2794
2795                     if (s->mv_dir & MV_DIR_FORWARD) {
2796                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2797                         op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
2798                     }
2799                     if (s->mv_dir & MV_DIR_BACKWARD) {
2800                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2801                     }
2802                 }else{
2803                     op_qpix= s->me.qpel_put;
2804                     if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2805                         op_pix = s->dsp.put_pixels_tab;
2806                     }else{
2807                         op_pix = s->dsp.put_no_rnd_pixels_tab;
2808                     }
2809                     if (s->mv_dir & MV_DIR_FORWARD) {
2810                         ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2811                         op_pix = s->dsp.avg_pixels_tab;
2812                         op_qpix= s->me.qpel_avg;
2813                     }
2814                     if (s->mv_dir & MV_DIR_BACKWARD) {
2815                         ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2816                     }
2817                 }
2818             }
2819
2820             /* skip dequant / idct if we are really late ;) */
2821             if(s->avctx->skip_idct){
2822                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2823                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2824                    || s->avctx->skip_idct >= AVDISCARD_ALL)
2825                     goto skip_idct;
2826             }
2827
2828             /* add dct residue */
2829             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2830                                 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2831                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2832                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2833                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2834                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2835
2836                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2837                     if (s->chroma_y_shift){
2838                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2839                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2840                     }else{
2841                         dct_linesize >>= 1;
2842                         dct_offset >>=1;
2843                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2844                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2845                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2846                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2847                     }
2848                 }
2849             } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2850                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2851                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2852                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2853                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2854
2855                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2856                     if(s->chroma_y_shift){//Chroma420
2857                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
2858                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
2859                     }else{
2860                         //chroma422
2861                         dct_linesize = uvlinesize << s->interlaced_dct;
2862                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2863
2864                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
2865                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
2866                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2867                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2868                         if(!s->chroma_x_shift){//Chroma444
2869                             add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2870                             add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2871                             add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2872                             add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2873                         }
2874                     }
2875                 }//fi gray
2876             }
2877             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2878                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2879             }
2880         } else {
2881             /* dct only in intra block */
2882             if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2883                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2884                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2885                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2886                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2887
2888                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2889                     if(s->chroma_y_shift){
2890                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2891                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2892                     }else{
2893                         dct_offset >>=1;
2894                         dct_linesize >>=1;
2895                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2896                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2897                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2898                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2899                     }
2900                 }
2901             }else{
2902                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2903                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2904                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2905                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2906
2907                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2908                     if(s->chroma_y_shift){
2909                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2910                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2911                     }else{
2912
2913                         dct_linesize = uvlinesize << s->interlaced_dct;
2914                         dct_offset   = s->interlaced_dct? uvlinesize : uvlinesize*block_size;
2915
2916                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2917                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2918                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2919                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2920                         if(!s->chroma_x_shift){//Chroma444
2921                             s->dsp.idct_put(dest_cb + block_size,              dct_linesize, block[8]);
2922                             s->dsp.idct_put(dest_cr + block_size,              dct_linesize, block[9]);
2923                             s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2924                             s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2925                         }
2926                     }
2927                 }//gray
2928             }
2929         }
2930 skip_idct:
2931         if(!readable){
2932             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2933             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2934             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2935         }
2936     }
2937 }
2938
2939 void ff_MPV_decode_mb(MpegEncContext *s, int16_t block[12][64]){
2940 #if !CONFIG_SMALL
2941     if(s->out_format == FMT_MPEG1) {
2942         if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2943         else                 MPV_decode_mb_internal(s, block, 0, 1);
2944     } else
2945 #endif
2946     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2947     else                  MPV_decode_mb_internal(s, block, 0, 0);
2948 }
2949
2950 /**
2951  * @param h is the normal height, this will be reduced automatically if needed for the last row
2952  */
2953 void ff_draw_horiz_band(AVCodecContext *avctx, DSPContext *dsp, Picture *cur,
2954                         Picture *last, int y, int h, int picture_structure,
2955                         int first_field, int draw_edges, int low_delay,
2956                         int v_edge_pos, int h_edge_pos)
2957 {
2958     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
2959     int hshift = desc->log2_chroma_w;
2960     int vshift = desc->log2_chroma_h;
2961     const int field_pic = picture_structure != PICT_FRAME;
2962     if(field_pic){
2963         h <<= 1;
2964         y <<= 1;
2965     }
2966
2967     if (!avctx->hwaccel &&
2968         !(avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
2969         draw_edges &&
2970         cur->reference &&
2971         !(avctx->flags & CODEC_FLAG_EMU_EDGE)) {
2972         int *linesize = cur->f.linesize;
2973         int sides = 0, edge_h;
2974         if (y==0) sides |= EDGE_TOP;
2975         if (y + h >= v_edge_pos)
2976             sides |= EDGE_BOTTOM;
2977
2978         edge_h= FFMIN(h, v_edge_pos - y);
2979
2980         dsp->draw_edges(cur->f.data[0] + y * linesize[0],
2981                         linesize[0], h_edge_pos, edge_h,
2982                         EDGE_WIDTH, EDGE_WIDTH, sides);
2983         dsp->draw_edges(cur->f.data[1] + (y >> vshift) * linesize[1],
2984                         linesize[1], h_edge_pos >> hshift, edge_h >> vshift,
2985                         EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, sides);
2986         dsp->draw_edges(cur->f.data[2] + (y >> vshift) * linesize[2],
2987                         linesize[2], h_edge_pos >> hshift, edge_h >> vshift,
2988                         EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, sides);
2989     }
2990
2991     h = FFMIN(h, avctx->height - y);
2992
2993     if(field_pic && first_field && !(avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2994
2995     if (avctx->draw_horiz_band) {
2996         AVFrame *src;
2997         int offset[AV_NUM_DATA_POINTERS];
2998         int i;
2999
3000         if(cur->f.pict_type == AV_PICTURE_TYPE_B || low_delay ||
3001            (avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
3002             src = &cur->f;
3003         else if (last)
3004             src = &last->f;
3005         else
3006             return;
3007
3008         if (cur->f.pict_type == AV_PICTURE_TYPE_B &&
3009             picture_structure == PICT_FRAME    &&
3010             avctx->codec_id != AV_CODEC_ID_H264  &&
3011             avctx->codec_id != AV_CODEC_ID_SVQ3) {
3012             for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
3013                 offset[i] = 0;
3014         }else{
3015             offset[0]= y * src->linesize[0];
3016             offset[1]=
3017             offset[2]= (y >> vshift) * src->linesize[1];
3018             for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
3019                 offset[i] = 0;
3020         }
3021
3022         emms_c();
3023
3024         avctx->draw_horiz_band(avctx, src, offset,
3025                                y, picture_structure, h);
3026     }
3027 }
3028
3029 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
3030 {
3031     int draw_edges = s->unrestricted_mv && !s->intra_only;
3032     ff_draw_horiz_band(s->avctx, &s->dsp, &s->current_picture,
3033                        &s->last_picture, y, h, s->picture_structure,
3034                        s->first_field, draw_edges, s->low_delay,
3035                        s->v_edge_pos, s->h_edge_pos);
3036 }
3037
3038 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3039     const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
3040     const int uvlinesize = s->current_picture.f.linesize[1];
3041     const int mb_size= 4 - s->avctx->lowres;
3042
3043     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3044     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3045     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3046     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3047     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3048     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;
3049     //block_index is not used by mpeg2, so it is not affected by chroma_format
3050
3051     s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) <<  mb_size);
3052     s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3053     s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3054
3055     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3056     {
3057         if(s->picture_structure==PICT_FRAME){
3058         s->dest[0] += s->mb_y *   linesize << mb_size;
3059         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3060         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3061         }else{
3062             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
3063             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
3064             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
3065             av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
3066         }
3067     }
3068 }
3069
3070 /**
3071  * Permute an 8x8 block.
3072  * @param block the block which will be permuted according to the given permutation vector
3073  * @param permutation the permutation vector
3074  * @param last the last non zero coefficient in scantable order, used to speed the permutation up
3075  * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
3076  *                  (inverse) permutated to scantable order!
3077  */
3078 void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
3079 {
3080     int i;
3081     int16_t temp[64];
3082
3083     if(last<=0) return;
3084     //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
3085
3086     for(i=0; i<=last; i++){
3087         const int j= scantable[i];
3088         temp[j]= block[j];
3089         block[j]=0;
3090     }
3091
3092     for(i=0; i<=last; i++){
3093         const int j= scantable[i];
3094         const int perm_j= permutation[j];
3095         block[perm_j]= temp[j];
3096     }
3097 }
3098
3099 void ff_mpeg_flush(AVCodecContext *avctx){
3100     int i;
3101     MpegEncContext *s = avctx->priv_data;
3102
3103     if(s==NULL || s->picture==NULL)
3104         return;
3105
3106     for (i = 0; i < MAX_PICTURE_COUNT; i++)
3107         ff_mpeg_unref_picture(s, &s->picture[i]);
3108     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3109
3110     s->mb_x= s->mb_y= 0;
3111     s->closed_gop= 0;
3112
3113     s->parse_context.state= -1;
3114     s->parse_context.frame_start_found= 0;
3115     s->parse_context.overread= 0;
3116     s->parse_context.overread_index= 0;
3117     s->parse_context.index= 0;
3118     s->parse_context.last_index= 0;
3119     s->bitstream_buffer_size=0;
3120     s->pp_time=0;
3121 }
3122
3123 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
3124                                    int16_t *block, int n, int qscale)
3125 {
3126     int i, level, nCoeffs;
3127     const uint16_t *quant_matrix;
3128
3129     nCoeffs= s->block_last_index[n];
3130
3131     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3132     /* XXX: only mpeg1 */
3133     quant_matrix = s->intra_matrix;
3134     for(i=1;i<=nCoeffs;i++) {
3135         int j= s->intra_scantable.permutated[i];
3136         level = block[j];
3137         if (level) {
3138             if (level < 0) {
3139                 level = -level;
3140                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3141                 level = (level - 1) | 1;
3142                 level = -level;
3143             } else {
3144                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3145                 level = (level - 1) | 1;
3146             }
3147             block[j] = level;
3148         }
3149     }
3150 }
3151
3152 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
3153                                    int16_t *block, int n, int qscale)
3154 {
3155     int i, level, nCoeffs;
3156     const uint16_t *quant_matrix;
3157
3158     nCoeffs= s->block_last_index[n];
3159
3160     quant_matrix = s->inter_matrix;
3161     for(i=0; i<=nCoeffs; i++) {
3162         int j= s->intra_scantable.permutated[i];
3163         level = block[j];
3164         if (level) {
3165             if (level < 0) {
3166                 level = -level;
3167                 level = (((level << 1) + 1) * qscale *
3168                          ((int) (quant_matrix[j]))) >> 4;
3169                 level = (level - 1) | 1;
3170                 level = -level;
3171             } else {
3172                 level = (((level << 1) + 1) * qscale *
3173                          ((int) (quant_matrix[j]))) >> 4;
3174                 level = (level - 1) | 1;
3175             }
3176             block[j] = level;
3177         }
3178     }
3179 }
3180
3181 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
3182                                    int16_t *block, int n, int qscale)
3183 {
3184     int i, level, nCoeffs;
3185     const uint16_t *quant_matrix;
3186
3187     if(s->alternate_scan) nCoeffs= 63;
3188     else nCoeffs= s->block_last_index[n];
3189
3190     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3191     quant_matrix = s->intra_matrix;
3192     for(i=1;i<=nCoeffs;i++) {
3193         int j= s->intra_scantable.permutated[i];
3194         level = block[j];
3195         if (level) {
3196             if (level < 0) {
3197                 level = -level;
3198                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3199                 level = -level;
3200             } else {
3201                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3202             }
3203             block[j] = level;
3204         }
3205     }
3206 }
3207
3208 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
3209                                    int16_t *block, int n, int qscale)
3210 {
3211     int i, level, nCoeffs;
3212     const uint16_t *quant_matrix;
3213     int sum=-1;
3214
3215     if(s->alternate_scan) nCoeffs= 63;
3216     else nCoeffs= s->block_last_index[n];
3217
3218     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3219     sum += block[0];
3220     quant_matrix = s->intra_matrix;
3221     for(i=1;i<=nCoeffs;i++) {
3222         int j= s->intra_scantable.permutated[i];
3223         level = block[j];
3224         if (level) {
3225             if (level < 0) {
3226                 level = -level;
3227                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3228                 level = -level;
3229             } else {
3230                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3231             }
3232             block[j] = level;
3233             sum+=level;
3234         }
3235     }
3236     block[63]^=sum&1;
3237 }
3238
3239 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
3240                                    int16_t *block, int n, int qscale)
3241 {
3242     int i, level, nCoeffs;
3243     const uint16_t *quant_matrix;
3244     int sum=-1;
3245
3246     if(s->alternate_scan) nCoeffs= 63;
3247     else nCoeffs= s->block_last_index[n];
3248
3249     quant_matrix = s->inter_matrix;
3250     for(i=0; i<=nCoeffs; i++) {
3251         int j= s->intra_scantable.permutated[i];
3252         level = block[j];
3253         if (level) {
3254             if (level < 0) {
3255                 level = -level;
3256                 level = (((level << 1) + 1) * qscale *
3257                          ((int) (quant_matrix[j]))) >> 4;
3258                 level = -level;
3259             } else {
3260                 level = (((level << 1) + 1) * qscale *
3261                          ((int) (quant_matrix[j]))) >> 4;
3262             }
3263             block[j] = level;
3264             sum+=level;
3265         }
3266     }
3267     block[63]^=sum&1;
3268 }
3269
3270 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
3271                                   int16_t *block, int n, int qscale)
3272 {
3273     int i, level, qmul, qadd;
3274     int nCoeffs;
3275
3276     assert(s->block_last_index[n]>=0);
3277
3278     qmul = qscale << 1;
3279
3280     if (!s->h263_aic) {
3281         block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3282         qadd = (qscale - 1) | 1;
3283     }else{
3284         qadd = 0;
3285     }
3286     if(s->ac_pred)
3287         nCoeffs=63;
3288     else
3289         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3290
3291     for(i=1; i<=nCoeffs; i++) {
3292         level = block[i];
3293         if (level) {
3294             if (level < 0) {
3295                 level = level * qmul - qadd;
3296             } else {
3297                 level = level * qmul + qadd;
3298             }
3299             block[i] = level;
3300         }
3301     }
3302 }
3303
3304 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
3305                                   int16_t *block, int n, int qscale)
3306 {
3307     int i, level, qmul, qadd;
3308     int nCoeffs;
3309
3310     assert(s->block_last_index[n]>=0);
3311
3312     qadd = (qscale - 1) | 1;
3313     qmul = qscale << 1;
3314
3315     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3316
3317     for(i=0; i<=nCoeffs; i++) {
3318         level = block[i];
3319         if (level) {
3320             if (level < 0) {
3321                 level = level * qmul - qadd;
3322             } else {
3323                 level = level * qmul + qadd;
3324             }
3325             block[i] = level;
3326         }
3327     }
3328 }
3329
3330 /**
3331  * set qscale and update qscale dependent variables.
3332  */
3333 void ff_set_qscale(MpegEncContext * s, int qscale)
3334 {
3335     if (qscale < 1)
3336         qscale = 1;
3337     else if (qscale > 31)
3338         qscale = 31;
3339
3340     s->qscale = qscale;
3341     s->chroma_qscale= s->chroma_qscale_table[qscale];
3342
3343     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
3344     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
3345 }
3346
3347 void ff_MPV_report_decode_progress(MpegEncContext *s)
3348 {
3349     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
3350         ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
3351 }
3352
3353 #if CONFIG_ERROR_RESILIENCE
3354 void ff_mpeg_er_frame_start(MpegEncContext *s)
3355 {
3356     ERContext *er = &s->er;
3357
3358     er->cur_pic  = s->current_picture_ptr;
3359     er->last_pic = s->last_picture_ptr;
3360     er->next_pic = s->next_picture_ptr;
3361
3362     er->pp_time           = s->pp_time;
3363     er->pb_time           = s->pb_time;
3364     er->quarter_sample    = s->quarter_sample;
3365     er->partitioned_frame = s->partitioned_frame;
3366
3367     ff_er_frame_start(er);
3368 }
3369 #endif /* CONFIG_ERROR_RESILIENCE */