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