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