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