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