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