Merge commit '419e3404d07acaac019e8f363c281e17c3a3d622'
[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             s->bitstream_buffer_size = s1->bitstream_buffer_size;
1053         memcpy(s->bitstream_buffer, s1->bitstream_buffer,
1054                s1->bitstream_buffer_size);
1055         memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
1056                FF_INPUT_BUFFER_PADDING_SIZE);
1057     }
1058
1059     // linesize dependend scratch buffer allocation
1060     if (!s->edge_emu_buffer)
1061         if (s1->linesize) {
1062             if (frame_size_alloc(s, s1->linesize) < 0) {
1063                 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
1064                        "scratch buffers.\n");
1065                 return AVERROR(ENOMEM);
1066             }
1067         } else {
1068             av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
1069                    "be allocated due to unknown size.\n");
1070         }
1071
1072     // MPEG2/interlacing info
1073     memcpy(&s->progressive_sequence, &s1->progressive_sequence,
1074            (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
1075
1076     if (!s1->first_field) {
1077         s->last_pict_type = s1->pict_type;
1078         if (s1->current_picture_ptr)
1079             s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f->quality;
1080     }
1081
1082     return 0;
1083 }
1084
1085 /**
1086  * Set the given MpegEncContext to common defaults
1087  * (same for encoding and decoding).
1088  * The changed fields will not depend upon the
1089  * prior state of the MpegEncContext.
1090  */
1091 void ff_mpv_common_defaults(MpegEncContext *s)
1092 {
1093     s->y_dc_scale_table      =
1094     s->c_dc_scale_table      = ff_mpeg1_dc_scale_table;
1095     s->chroma_qscale_table   = ff_default_chroma_qscale_table;
1096     s->progressive_frame     = 1;
1097     s->progressive_sequence  = 1;
1098     s->picture_structure     = PICT_FRAME;
1099
1100     s->coded_picture_number  = 0;
1101     s->picture_number        = 0;
1102
1103     s->f_code                = 1;
1104     s->b_code                = 1;
1105
1106     s->slice_context_count   = 1;
1107 }
1108
1109 /**
1110  * Set the given MpegEncContext to defaults for decoding.
1111  * the changed fields will not depend upon
1112  * the prior state of the MpegEncContext.
1113  */
1114 void ff_mpv_decode_defaults(MpegEncContext *s)
1115 {
1116     ff_mpv_common_defaults(s);
1117 }
1118
1119 void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
1120 {
1121     s->avctx           = avctx;
1122     s->width           = avctx->coded_width;
1123     s->height          = avctx->coded_height;
1124     s->codec_id        = avctx->codec->id;
1125     s->workaround_bugs = avctx->workaround_bugs;
1126
1127     /* convert fourcc to upper case */
1128     s->codec_tag          = avpriv_toupper4(avctx->codec_tag);
1129 }
1130
1131 static int init_er(MpegEncContext *s)
1132 {
1133     ERContext *er = &s->er;
1134     int mb_array_size = s->mb_height * s->mb_stride;
1135     int i;
1136
1137     er->avctx       = s->avctx;
1138
1139     er->mb_index2xy = s->mb_index2xy;
1140     er->mb_num      = s->mb_num;
1141     er->mb_width    = s->mb_width;
1142     er->mb_height   = s->mb_height;
1143     er->mb_stride   = s->mb_stride;
1144     er->b8_stride   = s->b8_stride;
1145
1146     er->er_temp_buffer     = av_malloc(s->mb_height * s->mb_stride);
1147     er->error_status_table = av_mallocz(mb_array_size);
1148     if (!er->er_temp_buffer || !er->error_status_table)
1149         goto fail;
1150
1151     er->mbskip_table  = s->mbskip_table;
1152     er->mbintra_table = s->mbintra_table;
1153
1154     for (i = 0; i < FF_ARRAY_ELEMS(s->dc_val); i++)
1155         er->dc_val[i] = s->dc_val[i];
1156
1157     er->decode_mb = mpeg_er_decode_mb;
1158     er->opaque    = s;
1159
1160     return 0;
1161 fail:
1162     av_freep(&er->er_temp_buffer);
1163     av_freep(&er->error_status_table);
1164     return AVERROR(ENOMEM);
1165 }
1166
1167 /**
1168  * Initialize and allocates MpegEncContext fields dependent on the resolution.
1169  */
1170 static int init_context_frame(MpegEncContext *s)
1171 {
1172     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
1173
1174     s->mb_width   = (s->width + 15) / 16;
1175     s->mb_stride  = s->mb_width + 1;
1176     s->b8_stride  = s->mb_width * 2 + 1;
1177     mb_array_size = s->mb_height * s->mb_stride;
1178     mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
1179
1180     /* set default edge pos, will be overridden
1181      * in decode_header if needed */
1182     s->h_edge_pos = s->mb_width * 16;
1183     s->v_edge_pos = s->mb_height * 16;
1184
1185     s->mb_num     = s->mb_width * s->mb_height;
1186
1187     s->block_wrap[0] =
1188     s->block_wrap[1] =
1189     s->block_wrap[2] =
1190     s->block_wrap[3] = s->b8_stride;
1191     s->block_wrap[4] =
1192     s->block_wrap[5] = s->mb_stride;
1193
1194     y_size  = s->b8_stride * (2 * s->mb_height + 1);
1195     c_size  = s->mb_stride * (s->mb_height + 1);
1196     yc_size = y_size + 2   * c_size;
1197
1198     if (s->mb_height & 1)
1199         yc_size += 2*s->b8_stride + 2*s->mb_stride;
1200
1201     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
1202     for (y = 0; y < s->mb_height; y++)
1203         for (x = 0; x < s->mb_width; x++)
1204             s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
1205
1206     s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
1207
1208     if (s->encoding) {
1209         /* Allocate MV tables */
1210         FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,                 mv_table_size * 2 * sizeof(int16_t), fail)
1211         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
1212         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
1213         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
1214         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
1215         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,          mv_table_size * 2 * sizeof(int16_t), fail)
1216         s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;
1217         s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;
1218         s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;
1219         s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
1220         s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
1221         s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;
1222
1223         /* Allocate MB type table */
1224         FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
1225
1226         FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
1227
1228         FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
1229                          mb_array_size * sizeof(float), fail);
1230         FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
1231                          mb_array_size * sizeof(float), fail);
1232
1233     }
1234
1235     if (s->codec_id == AV_CODEC_ID_MPEG4 ||
1236         (s->avctx->flags & CODEC_FLAG_INTERLACED_ME)) {
1237         /* interlaced direct mode decoding tables */
1238         for (i = 0; i < 2; i++) {
1239             int j, k;
1240             for (j = 0; j < 2; j++) {
1241                 for (k = 0; k < 2; k++) {
1242                     FF_ALLOCZ_OR_GOTO(s->avctx,
1243                                       s->b_field_mv_table_base[i][j][k],
1244                                       mv_table_size * 2 * sizeof(int16_t),
1245                                       fail);
1246                     s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
1247                                                    s->mb_stride + 1;
1248                 }
1249                 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
1250                 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
1251                 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
1252             }
1253             FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
1254         }
1255     }
1256     if (s->out_format == FMT_H263) {
1257         /* cbp values */
1258         FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride, fail);
1259         s->coded_block = s->coded_block_base + s->b8_stride + 1;
1260
1261         /* cbp, ac_pred, pred_dir */
1262         FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table     , mb_array_size * sizeof(uint8_t), fail);
1263         FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
1264     }
1265
1266     if (s->h263_pred || s->h263_plus || !s->encoding) {
1267         /* dc values */
1268         // MN: we need these for  error resilience of intra-frames
1269         FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
1270         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
1271         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
1272         s->dc_val[2] = s->dc_val[1] + c_size;
1273         for (i = 0; i < yc_size; i++)
1274             s->dc_val_base[i] = 1024;
1275     }
1276
1277     /* which mb is a intra block */
1278     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
1279     memset(s->mbintra_table, 1, mb_array_size);
1280
1281     /* init macroblock skip table */
1282     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
1283     // Note the + 1 is for  a quicker mpeg4 slice_end detection
1284
1285     return init_er(s);
1286 fail:
1287     return AVERROR(ENOMEM);
1288 }
1289
1290 /**
1291  * init common structure for both encoder and decoder.
1292  * this assumes that some variables like width/height are already set
1293  */
1294 av_cold int ff_mpv_common_init(MpegEncContext *s)
1295 {
1296     int i;
1297     int nb_slices = (HAVE_THREADS &&
1298                      s->avctx->active_thread_type & FF_THREAD_SLICE) ?
1299                     s->avctx->thread_count : 1;
1300
1301     if (s->encoding && s->avctx->slices)
1302         nb_slices = s->avctx->slices;
1303
1304     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1305         s->mb_height = (s->height + 31) / 32 * 2;
1306     else
1307         s->mb_height = (s->height + 15) / 16;
1308
1309     if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
1310         av_log(s->avctx, AV_LOG_ERROR,
1311                "decoding to AV_PIX_FMT_NONE is not supported.\n");
1312         return -1;
1313     }
1314
1315     if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
1316         int max_slices;
1317         if (s->mb_height)
1318             max_slices = FFMIN(MAX_THREADS, s->mb_height);
1319         else
1320             max_slices = MAX_THREADS;
1321         av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
1322                " reducing to %d\n", nb_slices, max_slices);
1323         nb_slices = max_slices;
1324     }
1325
1326     if ((s->width || s->height) &&
1327         av_image_check_size(s->width, s->height, 0, s->avctx))
1328         return -1;
1329
1330     dct_init(s);
1331
1332     /* set chroma shifts */
1333     avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,
1334                                   &s->chroma_x_shift,
1335                                   &s->chroma_y_shift);
1336
1337
1338     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
1339                       MAX_PICTURE_COUNT * sizeof(Picture), fail);
1340     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1341         s->picture[i].f = av_frame_alloc();
1342         if (!s->picture[i].f)
1343             goto fail;
1344     }
1345     memset(&s->next_picture, 0, sizeof(s->next_picture));
1346     memset(&s->last_picture, 0, sizeof(s->last_picture));
1347     memset(&s->current_picture, 0, sizeof(s->current_picture));
1348     memset(&s->new_picture, 0, sizeof(s->new_picture));
1349     s->next_picture.f = av_frame_alloc();
1350     if (!s->next_picture.f)
1351         goto fail;
1352     s->last_picture.f = av_frame_alloc();
1353     if (!s->last_picture.f)
1354         goto fail;
1355     s->current_picture.f = av_frame_alloc();
1356     if (!s->current_picture.f)
1357         goto fail;
1358     s->new_picture.f = av_frame_alloc();
1359     if (!s->new_picture.f)
1360         goto fail;
1361
1362         if (init_context_frame(s))
1363             goto fail;
1364
1365         s->parse_context.state = -1;
1366
1367         s->context_initialized = 1;
1368         s->thread_context[0]   = s;
1369
1370 //     if (s->width && s->height) {
1371         if (nb_slices > 1) {
1372             for (i = 1; i < nb_slices; i++) {
1373                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1374                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1375             }
1376
1377             for (i = 0; i < nb_slices; i++) {
1378                 if (init_duplicate_context(s->thread_context[i]) < 0)
1379                     goto fail;
1380                     s->thread_context[i]->start_mb_y =
1381                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1382                     s->thread_context[i]->end_mb_y   =
1383                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1384             }
1385         } else {
1386             if (init_duplicate_context(s) < 0)
1387                 goto fail;
1388             s->start_mb_y = 0;
1389             s->end_mb_y   = s->mb_height;
1390         }
1391         s->slice_context_count = nb_slices;
1392 //     }
1393
1394     return 0;
1395  fail:
1396     ff_mpv_common_end(s);
1397     return -1;
1398 }
1399
1400 /**
1401  * Frees and resets MpegEncContext fields depending on the resolution.
1402  * Is used during resolution changes to avoid a full reinitialization of the
1403  * codec.
1404  */
1405 static void free_context_frame(MpegEncContext *s)
1406 {
1407     int i, j, k;
1408
1409     av_freep(&s->mb_type);
1410     av_freep(&s->p_mv_table_base);
1411     av_freep(&s->b_forw_mv_table_base);
1412     av_freep(&s->b_back_mv_table_base);
1413     av_freep(&s->b_bidir_forw_mv_table_base);
1414     av_freep(&s->b_bidir_back_mv_table_base);
1415     av_freep(&s->b_direct_mv_table_base);
1416     s->p_mv_table            = NULL;
1417     s->b_forw_mv_table       = NULL;
1418     s->b_back_mv_table       = NULL;
1419     s->b_bidir_forw_mv_table = NULL;
1420     s->b_bidir_back_mv_table = NULL;
1421     s->b_direct_mv_table     = NULL;
1422     for (i = 0; i < 2; i++) {
1423         for (j = 0; j < 2; j++) {
1424             for (k = 0; k < 2; k++) {
1425                 av_freep(&s->b_field_mv_table_base[i][j][k]);
1426                 s->b_field_mv_table[i][j][k] = NULL;
1427             }
1428             av_freep(&s->b_field_select_table[i][j]);
1429             av_freep(&s->p_field_mv_table_base[i][j]);
1430             s->p_field_mv_table[i][j] = NULL;
1431         }
1432         av_freep(&s->p_field_select_table[i]);
1433     }
1434
1435     av_freep(&s->dc_val_base);
1436     av_freep(&s->coded_block_base);
1437     av_freep(&s->mbintra_table);
1438     av_freep(&s->cbp_table);
1439     av_freep(&s->pred_dir_table);
1440
1441     av_freep(&s->mbskip_table);
1442
1443     av_freep(&s->er.error_status_table);
1444     av_freep(&s->er.er_temp_buffer);
1445     av_freep(&s->mb_index2xy);
1446     av_freep(&s->lambda_table);
1447
1448     av_freep(&s->cplx_tab);
1449     av_freep(&s->bits_tab);
1450
1451     s->linesize = s->uvlinesize = 0;
1452 }
1453
1454 int ff_mpv_common_frame_size_change(MpegEncContext *s)
1455 {
1456     int i, err = 0;
1457
1458     if (!s->context_initialized)
1459         return AVERROR(EINVAL);
1460
1461     if (s->slice_context_count > 1) {
1462         for (i = 0; i < s->slice_context_count; i++) {
1463             free_duplicate_context(s->thread_context[i]);
1464         }
1465         for (i = 1; i < s->slice_context_count; i++) {
1466             av_freep(&s->thread_context[i]);
1467         }
1468     } else
1469         free_duplicate_context(s);
1470
1471     free_context_frame(s);
1472
1473     if (s->picture)
1474         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1475                 s->picture[i].needs_realloc = 1;
1476         }
1477
1478     s->last_picture_ptr         =
1479     s->next_picture_ptr         =
1480     s->current_picture_ptr      = NULL;
1481
1482     // init
1483     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1484         s->mb_height = (s->height + 31) / 32 * 2;
1485     else
1486         s->mb_height = (s->height + 15) / 16;
1487
1488     if ((s->width || s->height) &&
1489         (err = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
1490         goto fail;
1491
1492     if ((err = init_context_frame(s)))
1493         goto fail;
1494
1495     s->thread_context[0]   = s;
1496
1497     if (s->width && s->height) {
1498         int nb_slices = s->slice_context_count;
1499         if (nb_slices > 1) {
1500             for (i = 1; i < nb_slices; i++) {
1501                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1502                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1503             }
1504
1505             for (i = 0; i < nb_slices; i++) {
1506                 if ((err = init_duplicate_context(s->thread_context[i])) < 0)
1507                     goto fail;
1508                     s->thread_context[i]->start_mb_y =
1509                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1510                     s->thread_context[i]->end_mb_y   =
1511                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1512             }
1513         } else {
1514             err = init_duplicate_context(s);
1515             if (err < 0)
1516                 goto fail;
1517             s->start_mb_y = 0;
1518             s->end_mb_y   = s->mb_height;
1519         }
1520         s->slice_context_count = nb_slices;
1521     }
1522
1523     return 0;
1524  fail:
1525     ff_mpv_common_end(s);
1526     return err;
1527 }
1528
1529 /* init common structure for both encoder and decoder */
1530 void ff_mpv_common_end(MpegEncContext *s)
1531 {
1532     int i;
1533
1534     if (s->slice_context_count > 1) {
1535         for (i = 0; i < s->slice_context_count; i++) {
1536             free_duplicate_context(s->thread_context[i]);
1537         }
1538         for (i = 1; i < s->slice_context_count; i++) {
1539             av_freep(&s->thread_context[i]);
1540         }
1541         s->slice_context_count = 1;
1542     } else free_duplicate_context(s);
1543
1544     av_freep(&s->parse_context.buffer);
1545     s->parse_context.buffer_size = 0;
1546
1547     av_freep(&s->bitstream_buffer);
1548     s->allocated_bitstream_buffer_size = 0;
1549
1550     if (s->picture) {
1551         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1552             ff_free_picture_tables(&s->picture[i]);
1553             ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1554             av_frame_free(&s->picture[i].f);
1555         }
1556     }
1557     av_freep(&s->picture);
1558     ff_free_picture_tables(&s->last_picture);
1559     ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1560     av_frame_free(&s->last_picture.f);
1561     ff_free_picture_tables(&s->current_picture);
1562     ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1563     av_frame_free(&s->current_picture.f);
1564     ff_free_picture_tables(&s->next_picture);
1565     ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1566     av_frame_free(&s->next_picture.f);
1567     ff_free_picture_tables(&s->new_picture);
1568     ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1569     av_frame_free(&s->new_picture.f);
1570
1571     free_context_frame(s);
1572
1573     s->context_initialized      = 0;
1574     s->last_picture_ptr         =
1575     s->next_picture_ptr         =
1576     s->current_picture_ptr      = NULL;
1577     s->linesize = s->uvlinesize = 0;
1578 }
1579
1580 av_cold void ff_init_rl(RLTable *rl,
1581                         uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1582 {
1583     int8_t  max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1584     uint8_t index_run[MAX_RUN + 1];
1585     int last, run, level, start, end, i;
1586
1587     /* If table is static, we can quit if rl->max_level[0] is not NULL */
1588     if (static_store && rl->max_level[0])
1589         return;
1590
1591     /* compute max_level[], max_run[] and index_run[] */
1592     for (last = 0; last < 2; last++) {
1593         if (last == 0) {
1594             start = 0;
1595             end = rl->last;
1596         } else {
1597             start = rl->last;
1598             end = rl->n;
1599         }
1600
1601         memset(max_level, 0, MAX_RUN + 1);
1602         memset(max_run, 0, MAX_LEVEL + 1);
1603         memset(index_run, rl->n, MAX_RUN + 1);
1604         for (i = start; i < end; i++) {
1605             run   = rl->table_run[i];
1606             level = rl->table_level[i];
1607             if (index_run[run] == rl->n)
1608                 index_run[run] = i;
1609             if (level > max_level[run])
1610                 max_level[run] = level;
1611             if (run > max_run[level])
1612                 max_run[level] = run;
1613         }
1614         if (static_store)
1615             rl->max_level[last] = static_store[last];
1616         else
1617             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1618         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1619         if (static_store)
1620             rl->max_run[last]   = static_store[last] + MAX_RUN + 1;
1621         else
1622             rl->max_run[last]   = av_malloc(MAX_LEVEL + 1);
1623         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1624         if (static_store)
1625             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1626         else
1627             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1628         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1629     }
1630 }
1631
1632 av_cold void ff_init_vlc_rl(RLTable *rl, unsigned static_size)
1633 {
1634     int i, q;
1635     VLC_TYPE table[1500][2] = {{0}};
1636     VLC vlc = { .table = table, .table_allocated = static_size };
1637     av_assert0(static_size <= FF_ARRAY_ELEMS(table));
1638     init_vlc(&vlc, 9, rl->n + 1, &rl->table_vlc[0][1], 4, 2, &rl->table_vlc[0][0], 4, 2, INIT_VLC_USE_NEW_STATIC);
1639
1640     for (q = 0; q < 32; q++) {
1641         int qmul = q * 2;
1642         int qadd = (q - 1) | 1;
1643
1644         if (q == 0) {
1645             qmul = 1;
1646             qadd = 0;
1647         }
1648         for (i = 0; i < vlc.table_size; i++) {
1649             int code = vlc.table[i][0];
1650             int len  = vlc.table[i][1];
1651             int level, run;
1652
1653             if (len == 0) { // illegal code
1654                 run   = 66;
1655                 level = MAX_LEVEL;
1656             } else if (len < 0) { // more bits needed
1657                 run   = 0;
1658                 level = code;
1659             } else {
1660                 if (code == rl->n) { // esc
1661                     run   = 66;
1662                     level =  0;
1663                 } else {
1664                     run   = rl->table_run[code] + 1;
1665                     level = rl->table_level[code] * qmul + qadd;
1666                     if (code >= rl->last) run += 192;
1667                 }
1668             }
1669             rl->rl_vlc[q][i].len   = len;
1670             rl->rl_vlc[q][i].level = level;
1671             rl->rl_vlc[q][i].run   = run;
1672         }
1673     }
1674 }
1675
1676 static void release_unused_pictures(AVCodecContext *avctx, Picture *picture)
1677 {
1678     int i;
1679
1680     /* release non reference frames */
1681     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1682         if (!picture[i].reference)
1683             ff_mpeg_unref_picture(avctx, &picture[i]);
1684     }
1685 }
1686
1687 static inline int pic_is_unused(Picture *pic)
1688 {
1689     if (!pic->f->buf[0])
1690         return 1;
1691     if (pic->needs_realloc && !(pic->reference & DELAYED_PIC_REF))
1692         return 1;
1693     return 0;
1694 }
1695
1696 static int find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
1697 {
1698     int i;
1699
1700     if (shared) {
1701         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1702             if (!picture[i].f->buf[0])
1703                 return i;
1704         }
1705     } else {
1706         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1707             if (pic_is_unused(&picture[i]))
1708                 return i;
1709         }
1710     }
1711
1712     av_log(avctx, AV_LOG_FATAL,
1713            "Internal error, picture buffer overflow\n");
1714     /* We could return -1, but the codec would crash trying to draw into a
1715      * non-existing frame anyway. This is safer than waiting for a random crash.
1716      * Also the return of this is never useful, an encoder must only allocate
1717      * as much as allowed in the specification. This has no relationship to how
1718      * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1719      * enough for such valid streams).
1720      * Plus, a decoder has to check stream validity and remove frames if too
1721      * many reference frames are around. Waiting for "OOM" is not correct at
1722      * all. Similarly, missing reference frames have to be replaced by
1723      * interpolated/MC frames, anything else is a bug in the codec ...
1724      */
1725     abort();
1726     return -1;
1727 }
1728
1729 int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
1730 {
1731     int ret = find_unused_picture(avctx, picture, shared);
1732
1733     if (ret >= 0 && ret < MAX_PICTURE_COUNT) {
1734         if (picture[ret].needs_realloc) {
1735             picture[ret].needs_realloc = 0;
1736             ff_free_picture_tables(&picture[ret]);
1737             ff_mpeg_unref_picture(avctx, &picture[ret]);
1738         }
1739     }
1740     return ret;
1741 }
1742
1743 static void gray_frame(AVFrame *frame)
1744 {
1745     int i, h_chroma_shift, v_chroma_shift;
1746
1747     av_pix_fmt_get_chroma_sub_sample(frame->format, &h_chroma_shift, &v_chroma_shift);
1748
1749     for(i=0; i<frame->height; i++)
1750         memset(frame->data[0] + frame->linesize[0]*i, 0x80, frame->width);
1751     for(i=0; i<FF_CEIL_RSHIFT(frame->height, v_chroma_shift); i++) {
1752         memset(frame->data[1] + frame->linesize[1]*i,
1753                0x80, FF_CEIL_RSHIFT(frame->width, h_chroma_shift));
1754         memset(frame->data[2] + frame->linesize[2]*i,
1755                0x80, FF_CEIL_RSHIFT(frame->width, h_chroma_shift));
1756     }
1757 }
1758
1759 /**
1760  * generic function called after decoding
1761  * the header and before a frame is decoded.
1762  */
1763 int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1764 {
1765     int i, ret;
1766     Picture *pic;
1767     s->mb_skipped = 0;
1768
1769     if (!ff_thread_can_start_frame(avctx)) {
1770         av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1771         return -1;
1772     }
1773
1774     /* mark & release old frames */
1775     if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1776         s->last_picture_ptr != s->next_picture_ptr &&
1777         s->last_picture_ptr->f->buf[0]) {
1778         ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1779     }
1780
1781     /* release forgotten pictures */
1782     /* if (mpeg124/h263) */
1783     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1784         if (&s->picture[i] != s->last_picture_ptr &&
1785             &s->picture[i] != s->next_picture_ptr &&
1786             s->picture[i].reference && !s->picture[i].needs_realloc) {
1787             if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1788                 av_log(avctx, AV_LOG_ERROR,
1789                        "releasing zombie picture\n");
1790             ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1791         }
1792     }
1793
1794     ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1795
1796     release_unused_pictures(s->avctx, s->picture);
1797
1798     if (s->current_picture_ptr && !s->current_picture_ptr->f->buf[0]) {
1799         // we already have a unused image
1800         // (maybe it was set before reading the header)
1801         pic = s->current_picture_ptr;
1802     } else {
1803         i   = ff_find_unused_picture(s->avctx, s->picture, 0);
1804         if (i < 0) {
1805             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1806             return i;
1807         }
1808         pic = &s->picture[i];
1809     }
1810
1811     pic->reference = 0;
1812     if (!s->droppable) {
1813         if (s->pict_type != AV_PICTURE_TYPE_B)
1814             pic->reference = 3;
1815     }
1816
1817     pic->f->coded_picture_number = s->coded_picture_number++;
1818
1819     if (ff_alloc_picture(s, pic, 0) < 0)
1820         return -1;
1821
1822     s->current_picture_ptr = pic;
1823     // FIXME use only the vars from current_pic
1824     s->current_picture_ptr->f->top_field_first = s->top_field_first;
1825     if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1826         s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1827         if (s->picture_structure != PICT_FRAME)
1828             s->current_picture_ptr->f->top_field_first =
1829                 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1830     }
1831     s->current_picture_ptr->f->interlaced_frame = !s->progressive_frame &&
1832                                                  !s->progressive_sequence;
1833     s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
1834
1835     s->current_picture_ptr->f->pict_type = s->pict_type;
1836     // if (s->avctx->flags && CODEC_FLAG_QSCALE)
1837     //     s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1838     s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1839
1840     if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1841                                    s->current_picture_ptr)) < 0)
1842         return ret;
1843
1844     if (s->pict_type != AV_PICTURE_TYPE_B) {
1845         s->last_picture_ptr = s->next_picture_ptr;
1846         if (!s->droppable)
1847             s->next_picture_ptr = s->current_picture_ptr;
1848     }
1849     ff_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1850             s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1851             s->last_picture_ptr    ? s->last_picture_ptr->f->data[0]    : NULL,
1852             s->next_picture_ptr    ? s->next_picture_ptr->f->data[0]    : NULL,
1853             s->current_picture_ptr ? s->current_picture_ptr->f->data[0] : NULL,
1854             s->pict_type, s->droppable);
1855
1856     if ((!s->last_picture_ptr || !s->last_picture_ptr->f->buf[0]) &&
1857         (s->pict_type != AV_PICTURE_TYPE_I ||
1858          s->picture_structure != PICT_FRAME)) {
1859         int h_chroma_shift, v_chroma_shift;
1860         av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1861                                          &h_chroma_shift, &v_chroma_shift);
1862         if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture_ptr && s->next_picture_ptr->f->buf[0])
1863             av_log(avctx, AV_LOG_DEBUG,
1864                    "allocating dummy last picture for B frame\n");
1865         else if (s->pict_type != AV_PICTURE_TYPE_I)
1866             av_log(avctx, AV_LOG_ERROR,
1867                    "warning: first frame is no keyframe\n");
1868         else if (s->picture_structure != PICT_FRAME)
1869             av_log(avctx, AV_LOG_DEBUG,
1870                    "allocate dummy last picture for field based first keyframe\n");
1871
1872         /* Allocate a dummy frame */
1873         i = ff_find_unused_picture(s->avctx, s->picture, 0);
1874         if (i < 0) {
1875             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1876             return i;
1877         }
1878         s->last_picture_ptr = &s->picture[i];
1879
1880         s->last_picture_ptr->reference   = 3;
1881         s->last_picture_ptr->f->key_frame = 0;
1882         s->last_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1883
1884         if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1885             s->last_picture_ptr = NULL;
1886             return -1;
1887         }
1888
1889         if (!avctx->hwaccel && !(avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)) {
1890             for(i=0; i<avctx->height; i++)
1891                 memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i,
1892                        0x80, avctx->width);
1893             if (s->last_picture_ptr->f->data[2]) {
1894                 for(i=0; i<FF_CEIL_RSHIFT(avctx->height, v_chroma_shift); i++) {
1895                     memset(s->last_picture_ptr->f->data[1] + s->last_picture_ptr->f->linesize[1]*i,
1896                         0x80, FF_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1897                     memset(s->last_picture_ptr->f->data[2] + s->last_picture_ptr->f->linesize[2]*i,
1898                         0x80, FF_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1899                 }
1900             }
1901
1902             if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1903                 for(i=0; i<avctx->height; i++)
1904                 memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i, 16, avctx->width);
1905             }
1906         }
1907
1908         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1909         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1910     }
1911     if ((!s->next_picture_ptr || !s->next_picture_ptr->f->buf[0]) &&
1912         s->pict_type == AV_PICTURE_TYPE_B) {
1913         /* Allocate a dummy frame */
1914         i = ff_find_unused_picture(s->avctx, s->picture, 0);
1915         if (i < 0) {
1916             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1917             return i;
1918         }
1919         s->next_picture_ptr = &s->picture[i];
1920
1921         s->next_picture_ptr->reference   = 3;
1922         s->next_picture_ptr->f->key_frame = 0;
1923         s->next_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1924
1925         if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1926             s->next_picture_ptr = NULL;
1927             return -1;
1928         }
1929         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1930         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1931     }
1932
1933 #if 0 // BUFREF-FIXME
1934     memset(s->last_picture.f->data, 0, sizeof(s->last_picture.f->data));
1935     memset(s->next_picture.f->data, 0, sizeof(s->next_picture.f->data));
1936 #endif
1937     if (s->last_picture_ptr) {
1938         ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1939         if (s->last_picture_ptr->f->buf[0] &&
1940             (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1941                                        s->last_picture_ptr)) < 0)
1942             return ret;
1943     }
1944     if (s->next_picture_ptr) {
1945         ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1946         if (s->next_picture_ptr->f->buf[0] &&
1947             (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1948                                        s->next_picture_ptr)) < 0)
1949             return ret;
1950     }
1951
1952     av_assert0(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1953                                                  s->last_picture_ptr->f->buf[0]));
1954
1955     if (s->picture_structure!= PICT_FRAME) {
1956         int i;
1957         for (i = 0; i < 4; i++) {
1958             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1959                 s->current_picture.f->data[i] +=
1960                     s->current_picture.f->linesize[i];
1961             }
1962             s->current_picture.f->linesize[i] *= 2;
1963             s->last_picture.f->linesize[i]    *= 2;
1964             s->next_picture.f->linesize[i]    *= 2;
1965         }
1966     }
1967
1968     /* set dequantizer, we can't do it during init as
1969      * it might change for mpeg4 and we can't do it in the header
1970      * decode as init is not called for mpeg4 there yet */
1971     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1972         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1973         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1974     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1975         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1976         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1977     } else {
1978         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1979         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1980     }
1981
1982     if (s->avctx->debug & FF_DEBUG_NOMC) {
1983         gray_frame(s->current_picture_ptr->f);
1984     }
1985
1986     return 0;
1987 }
1988
1989 /* called after a frame has been decoded. */
1990 void ff_mpv_frame_end(MpegEncContext *s)
1991 {
1992     emms_c();
1993
1994     if (s->current_picture.reference)
1995         ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1996 }
1997
1998
1999 #if FF_API_VISMV
2000 static int clip_line(int *sx, int *sy, int *ex, int *ey, int maxx)
2001 {
2002     if(*sx > *ex)
2003         return clip_line(ex, ey, sx, sy, maxx);
2004
2005     if (*sx < 0) {
2006         if (*ex < 0)
2007             return 1;
2008         *sy = *ey + (*sy - *ey) * (int64_t)*ex / (*ex - *sx);
2009         *sx = 0;
2010     }
2011
2012     if (*ex > maxx) {
2013         if (*sx > maxx)
2014             return 1;
2015         *ey = *sy + (*ey - *sy) * (int64_t)(maxx - *sx) / (*ex - *sx);
2016         *ex = maxx;
2017     }
2018     return 0;
2019 }
2020
2021
2022 /**
2023  * Draw a line from (ex, ey) -> (sx, sy).
2024  * @param w width of the image
2025  * @param h height of the image
2026  * @param stride stride/linesize of the image
2027  * @param color color of the arrow
2028  */
2029 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
2030                       int w, int h, int stride, int color)
2031 {
2032     int x, y, fr, f;
2033
2034     if (clip_line(&sx, &sy, &ex, &ey, w - 1))
2035         return;
2036     if (clip_line(&sy, &sx, &ey, &ex, h - 1))
2037         return;
2038
2039     sx = av_clip(sx, 0, w - 1);
2040     sy = av_clip(sy, 0, h - 1);
2041     ex = av_clip(ex, 0, w - 1);
2042     ey = av_clip(ey, 0, h - 1);
2043
2044     buf[sy * stride + sx] += color;
2045
2046     if (FFABS(ex - sx) > FFABS(ey - sy)) {
2047         if (sx > ex) {
2048             FFSWAP(int, sx, ex);
2049             FFSWAP(int, sy, ey);
2050         }
2051         buf += sx + sy * stride;
2052         ex  -= sx;
2053         f    = ((ey - sy) << 16) / ex;
2054         for (x = 0; x <= ex; x++) {
2055             y  = (x * f) >> 16;
2056             fr = (x * f) & 0xFFFF;
2057             buf[y * stride + x]       += (color * (0x10000 - fr)) >> 16;
2058             if(fr) buf[(y + 1) * stride + x] += (color *            fr ) >> 16;
2059         }
2060     } else {
2061         if (sy > ey) {
2062             FFSWAP(int, sx, ex);
2063             FFSWAP(int, sy, ey);
2064         }
2065         buf += sx + sy * stride;
2066         ey  -= sy;
2067         if (ey)
2068             f = ((ex - sx) << 16) / ey;
2069         else
2070             f = 0;
2071         for(y= 0; y <= ey; y++){
2072             x  = (y*f) >> 16;
2073             fr = (y*f) & 0xFFFF;
2074             buf[y * stride + x]     += (color * (0x10000 - fr)) >> 16;
2075             if(fr) buf[y * stride + x + 1] += (color *            fr ) >> 16;
2076         }
2077     }
2078 }
2079
2080 /**
2081  * Draw an arrow from (ex, ey) -> (sx, sy).
2082  * @param w width of the image
2083  * @param h height of the image
2084  * @param stride stride/linesize of the image
2085  * @param color color of the arrow
2086  */
2087 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
2088                        int ey, int w, int h, int stride, int color, int tail, int direction)
2089 {
2090     int dx,dy;
2091
2092     if (direction) {
2093         FFSWAP(int, sx, ex);
2094         FFSWAP(int, sy, ey);
2095     }
2096
2097     sx = av_clip(sx, -100, w + 100);
2098     sy = av_clip(sy, -100, h + 100);
2099     ex = av_clip(ex, -100, w + 100);
2100     ey = av_clip(ey, -100, h + 100);
2101
2102     dx = ex - sx;
2103     dy = ey - sy;
2104
2105     if (dx * dx + dy * dy > 3 * 3) {
2106         int rx =  dx + dy;
2107         int ry = -dx + dy;
2108         int length = ff_sqrt((rx * rx + ry * ry) << 8);
2109
2110         // FIXME subpixel accuracy
2111         rx = ROUNDED_DIV(rx * 3 << 4, length);
2112         ry = ROUNDED_DIV(ry * 3 << 4, length);
2113
2114         if (tail) {
2115             rx = -rx;
2116             ry = -ry;
2117         }
2118
2119         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
2120         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
2121     }
2122     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
2123 }
2124 #endif
2125
2126 static int add_mb(AVMotionVector *mb, uint32_t mb_type,
2127                   int dst_x, int dst_y,
2128                   int src_x, int src_y,
2129                   int direction)
2130 {
2131     mb->w = IS_8X8(mb_type) || IS_8X16(mb_type) ? 8 : 16;
2132     mb->h = IS_8X8(mb_type) || IS_16X8(mb_type) ? 8 : 16;
2133     mb->src_x = src_x;
2134     mb->src_y = src_y;
2135     mb->dst_x = dst_x;
2136     mb->dst_y = dst_y;
2137     mb->source = direction ? 1 : -1;
2138     mb->flags = 0; // XXX: does mb_type contain extra information that could be exported here?
2139     return 1;
2140 }
2141
2142 /**
2143  * Print debugging info for the given picture.
2144  */
2145 void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table,
2146                          uint32_t *mbtype_table, int8_t *qscale_table, int16_t (*motion_val[2])[2],
2147                          int *low_delay,
2148                          int mb_width, int mb_height, int mb_stride, int quarter_sample)
2149 {
2150     if ((avctx->flags2 & CODEC_FLAG2_EXPORT_MVS) && mbtype_table && motion_val[0]) {
2151         const int shift = 1 + quarter_sample;
2152         const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
2153         const int mv_stride      = (mb_width << mv_sample_log2) +
2154                                    (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
2155         int mb_x, mb_y, mbcount = 0;
2156
2157         /* size is width * height * 2 * 4 where 2 is for directions and 4 is
2158          * for the maximum number of MB (4 MB in case of IS_8x8) */
2159         AVMotionVector *mvs = av_malloc_array(mb_width * mb_height, 2 * 4 * sizeof(AVMotionVector));
2160         if (!mvs)
2161             return;
2162
2163         for (mb_y = 0; mb_y < mb_height; mb_y++) {
2164             for (mb_x = 0; mb_x < mb_width; mb_x++) {
2165                 int i, direction, mb_type = mbtype_table[mb_x + mb_y * mb_stride];
2166                 for (direction = 0; direction < 2; direction++) {
2167                     if (!USES_LIST(mb_type, direction))
2168                         continue;
2169                     if (IS_8X8(mb_type)) {
2170                         for (i = 0; i < 4; i++) {
2171                             int sx = mb_x * 16 + 4 + 8 * (i & 1);
2172                             int sy = mb_y * 16 + 4 + 8 * (i >> 1);
2173                             int xy = (mb_x * 2 + (i & 1) +
2174                                       (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2175                             int mx = (motion_val[direction][xy][0] >> shift) + sx;
2176                             int my = (motion_val[direction][xy][1] >> shift) + sy;
2177                             mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, direction);
2178                         }
2179                     } else if (IS_16X8(mb_type)) {
2180                         for (i = 0; i < 2; i++) {
2181                             int sx = mb_x * 16 + 8;
2182                             int sy = mb_y * 16 + 4 + 8 * i;
2183                             int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
2184                             int mx = (motion_val[direction][xy][0] >> shift);
2185                             int my = (motion_val[direction][xy][1] >> shift);
2186
2187                             if (IS_INTERLACED(mb_type))
2188                                 my *= 2;
2189
2190                             mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx + sx, my + sy, direction);
2191                         }
2192                     } else if (IS_8X16(mb_type)) {
2193                         for (i = 0; i < 2; i++) {
2194                             int sx = mb_x * 16 + 4 + 8 * i;
2195                             int sy = mb_y * 16 + 8;
2196                             int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
2197                             int mx = motion_val[direction][xy][0] >> shift;
2198                             int my = motion_val[direction][xy][1] >> shift;
2199
2200                             if (IS_INTERLACED(mb_type))
2201                                 my *= 2;
2202
2203                             mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx + sx, my + sy, direction);
2204                         }
2205                     } else {
2206                           int sx = mb_x * 16 + 8;
2207                           int sy = mb_y * 16 + 8;
2208                           int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
2209                           int mx = (motion_val[direction][xy][0]>>shift) + sx;
2210                           int my = (motion_val[direction][xy][1]>>shift) + sy;
2211                           mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, direction);
2212                     }
2213                 }
2214             }
2215         }
2216
2217         if (mbcount) {
2218             AVFrameSideData *sd;
2219
2220             av_log(avctx, AV_LOG_DEBUG, "Adding %d MVs info to frame %d\n", mbcount, avctx->frame_number);
2221             sd = av_frame_new_side_data(pict, AV_FRAME_DATA_MOTION_VECTORS, mbcount * sizeof(AVMotionVector));
2222             if (!sd) {
2223                 av_freep(&mvs);
2224                 return;
2225             }
2226             memcpy(sd->data, mvs, mbcount * sizeof(AVMotionVector));
2227         }
2228
2229         av_freep(&mvs);
2230     }
2231
2232     /* TODO: export all the following to make them accessible for users (and filters) */
2233     if (avctx->hwaccel || !mbtype_table
2234         || (avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
2235         return;
2236
2237
2238     if (avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
2239         int x,y;
2240
2241         av_log(avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
2242                av_get_picture_type_char(pict->pict_type));
2243         for (y = 0; y < mb_height; y++) {
2244             for (x = 0; x < mb_width; x++) {
2245                 if (avctx->debug & FF_DEBUG_SKIP) {
2246                     int count = mbskip_table ? mbskip_table[x + y * mb_stride] : 0;
2247                     if (count > 9)
2248                         count = 9;
2249                     av_log(avctx, AV_LOG_DEBUG, "%1d", count);
2250                 }
2251                 if (avctx->debug & FF_DEBUG_QP) {
2252                     av_log(avctx, AV_LOG_DEBUG, "%2d",
2253                            qscale_table[x + y * mb_stride]);
2254                 }
2255                 if (avctx->debug & FF_DEBUG_MB_TYPE) {
2256                     int mb_type = mbtype_table[x + y * mb_stride];
2257                     // Type & MV direction
2258                     if (IS_PCM(mb_type))
2259                         av_log(avctx, AV_LOG_DEBUG, "P");
2260                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
2261                         av_log(avctx, AV_LOG_DEBUG, "A");
2262                     else if (IS_INTRA4x4(mb_type))
2263                         av_log(avctx, AV_LOG_DEBUG, "i");
2264                     else if (IS_INTRA16x16(mb_type))
2265                         av_log(avctx, AV_LOG_DEBUG, "I");
2266                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
2267                         av_log(avctx, AV_LOG_DEBUG, "d");
2268                     else if (IS_DIRECT(mb_type))
2269                         av_log(avctx, AV_LOG_DEBUG, "D");
2270                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
2271                         av_log(avctx, AV_LOG_DEBUG, "g");
2272                     else if (IS_GMC(mb_type))
2273                         av_log(avctx, AV_LOG_DEBUG, "G");
2274                     else if (IS_SKIP(mb_type))
2275                         av_log(avctx, AV_LOG_DEBUG, "S");
2276                     else if (!USES_LIST(mb_type, 1))
2277                         av_log(avctx, AV_LOG_DEBUG, ">");
2278                     else if (!USES_LIST(mb_type, 0))
2279                         av_log(avctx, AV_LOG_DEBUG, "<");
2280                     else {
2281                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2282                         av_log(avctx, AV_LOG_DEBUG, "X");
2283                     }
2284
2285                     // segmentation
2286                     if (IS_8X8(mb_type))
2287                         av_log(avctx, AV_LOG_DEBUG, "+");
2288                     else if (IS_16X8(mb_type))
2289                         av_log(avctx, AV_LOG_DEBUG, "-");
2290                     else if (IS_8X16(mb_type))
2291                         av_log(avctx, AV_LOG_DEBUG, "|");
2292                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
2293                         av_log(avctx, AV_LOG_DEBUG, " ");
2294                     else
2295                         av_log(avctx, AV_LOG_DEBUG, "?");
2296
2297
2298                     if (IS_INTERLACED(mb_type))
2299                         av_log(avctx, AV_LOG_DEBUG, "=");
2300                     else
2301                         av_log(avctx, AV_LOG_DEBUG, " ");
2302                 }
2303             }
2304             av_log(avctx, AV_LOG_DEBUG, "\n");
2305         }
2306     }
2307
2308     if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
2309         (avctx->debug_mv)) {
2310         int mb_y;
2311         int i;
2312         int h_chroma_shift, v_chroma_shift, block_height;
2313 #if FF_API_VISMV
2314         const int shift = 1 + quarter_sample;
2315         uint8_t *ptr;
2316         const int width          = avctx->width;
2317         const int height         = avctx->height;
2318 #endif
2319         const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
2320         const int mv_stride      = (mb_width << mv_sample_log2) +
2321                                    (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
2322
2323         *low_delay = 0; // needed to see the vectors without trashing the buffers
2324
2325         avcodec_get_chroma_sub_sample(avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2326
2327         av_frame_make_writable(pict);
2328
2329         pict->opaque = NULL;
2330 #if FF_API_VISMV
2331         ptr          = pict->data[0];
2332 #endif
2333         block_height = 16 >> v_chroma_shift;
2334
2335         for (mb_y = 0; mb_y < mb_height; mb_y++) {
2336             int mb_x;
2337             for (mb_x = 0; mb_x < mb_width; mb_x++) {
2338                 const int mb_index = mb_x + mb_y * mb_stride;
2339 #if FF_API_VISMV
2340                 if ((avctx->debug_mv) && motion_val[0]) {
2341                     int type;
2342                     for (type = 0; type < 3; type++) {
2343                         int direction = 0;
2344                         switch (type) {
2345                         case 0:
2346                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
2347                                 (pict->pict_type!= AV_PICTURE_TYPE_P))
2348                                 continue;
2349                             direction = 0;
2350                             break;
2351                         case 1:
2352                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
2353                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
2354                                 continue;
2355                             direction = 0;
2356                             break;
2357                         case 2:
2358                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
2359                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
2360                                 continue;
2361                             direction = 1;
2362                             break;
2363                         }
2364                         if (!USES_LIST(mbtype_table[mb_index], direction))
2365                             continue;
2366
2367                         if (IS_8X8(mbtype_table[mb_index])) {
2368                             int i;
2369                             for (i = 0; i < 4; i++) {
2370                                 int sx = mb_x * 16 + 4 + 8 * (i & 1);
2371                                 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
2372                                 int xy = (mb_x * 2 + (i & 1) +
2373                                           (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2374                                 int mx = (motion_val[direction][xy][0] >> shift) + sx;
2375                                 int my = (motion_val[direction][xy][1] >> shift) + sy;
2376                                 draw_arrow(ptr, sx, sy, mx, my, width,
2377                                            height, pict->linesize[0], 100, 0, direction);
2378                             }
2379                         } else if (IS_16X8(mbtype_table[mb_index])) {
2380                             int i;
2381                             for (i = 0; i < 2; i++) {
2382                                 int sx = mb_x * 16 + 8;
2383                                 int sy = mb_y * 16 + 4 + 8 * i;
2384                                 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
2385                                 int mx = (motion_val[direction][xy][0] >> shift);
2386                                 int my = (motion_val[direction][xy][1] >> shift);
2387
2388                                 if (IS_INTERLACED(mbtype_table[mb_index]))
2389                                     my *= 2;
2390
2391                                 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2392                                            height, pict->linesize[0], 100, 0, direction);
2393                             }
2394                         } else if (IS_8X16(mbtype_table[mb_index])) {
2395                             int i;
2396                             for (i = 0; i < 2; i++) {
2397                                 int sx = mb_x * 16 + 4 + 8 * i;
2398                                 int sy = mb_y * 16 + 8;
2399                                 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
2400                                 int mx = motion_val[direction][xy][0] >> shift;
2401                                 int my = motion_val[direction][xy][1] >> shift;
2402
2403                                 if (IS_INTERLACED(mbtype_table[mb_index]))
2404                                     my *= 2;
2405
2406                                 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2407                                            height, pict->linesize[0], 100, 0, direction);
2408                             }
2409                         } else {
2410                               int sx= mb_x * 16 + 8;
2411                               int sy= mb_y * 16 + 8;
2412                               int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
2413                               int mx= (motion_val[direction][xy][0]>>shift) + sx;
2414                               int my= (motion_val[direction][xy][1]>>shift) + sy;
2415                               draw_arrow(ptr, sx, sy, mx, my, width, height, pict->linesize[0], 100, 0, direction);
2416                         }
2417                     }
2418                 }
2419 #endif
2420                 if ((avctx->debug & FF_DEBUG_VIS_QP)) {
2421                     uint64_t c = (qscale_table[mb_index] * 128 / 31) *
2422                                  0x0101010101010101ULL;
2423                     int y;
2424                     for (y = 0; y < block_height; y++) {
2425                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
2426                                       (block_height * mb_y + y) *
2427                                       pict->linesize[1]) = c;
2428                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
2429                                       (block_height * mb_y + y) *
2430                                       pict->linesize[2]) = c;
2431                     }
2432                 }
2433                 if ((avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
2434                     motion_val[0]) {
2435                     int mb_type = mbtype_table[mb_index];
2436                     uint64_t u,v;
2437                     int y;
2438 #define COLOR(theta, r) \
2439     u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
2440     v = (int)(128 + r * sin(theta * 3.141592 / 180));
2441
2442
2443                     u = v = 128;
2444                     if (IS_PCM(mb_type)) {
2445                         COLOR(120, 48)
2446                     } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
2447                                IS_INTRA16x16(mb_type)) {
2448                         COLOR(30, 48)
2449                     } else if (IS_INTRA4x4(mb_type)) {
2450                         COLOR(90, 48)
2451                     } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
2452                         // COLOR(120, 48)
2453                     } else if (IS_DIRECT(mb_type)) {
2454                         COLOR(150, 48)
2455                     } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
2456                         COLOR(170, 48)
2457                     } else if (IS_GMC(mb_type)) {
2458                         COLOR(190, 48)
2459                     } else if (IS_SKIP(mb_type)) {
2460                         // COLOR(180, 48)
2461                     } else if (!USES_LIST(mb_type, 1)) {
2462                         COLOR(240, 48)
2463                     } else if (!USES_LIST(mb_type, 0)) {
2464                         COLOR(0, 48)
2465                     } else {
2466                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2467                         COLOR(300,48)
2468                     }
2469
2470                     u *= 0x0101010101010101ULL;
2471                     v *= 0x0101010101010101ULL;
2472                     for (y = 0; y < block_height; y++) {
2473                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
2474                                       (block_height * mb_y + y) * pict->linesize[1]) = u;
2475                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
2476                                       (block_height * mb_y + y) * pict->linesize[2]) = v;
2477                     }
2478
2479                     // segmentation
2480                     if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
2481                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
2482                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2483                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
2484                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2485                     }
2486                     if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
2487                         for (y = 0; y < 16; y++)
2488                             pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
2489                                           pict->linesize[0]] ^= 0x80;
2490                     }
2491                     if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
2492                         int dm = 1 << (mv_sample_log2 - 2);
2493                         for (i = 0; i < 4; i++) {
2494                             int sx = mb_x * 16 + 8 * (i & 1);
2495                             int sy = mb_y * 16 + 8 * (i >> 1);
2496                             int xy = (mb_x * 2 + (i & 1) +
2497                                      (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2498                             // FIXME bidir
2499                             int32_t *mv = (int32_t *) &motion_val[0][xy];
2500                             if (mv[0] != mv[dm] ||
2501                                 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
2502                                 for (y = 0; y < 8; y++)
2503                                     pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
2504                             if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
2505                                 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
2506                                               pict->linesize[0]) ^= 0x8080808080808080ULL;
2507                         }
2508                     }
2509
2510                     if (IS_INTERLACED(mb_type) &&
2511                         avctx->codec->id == AV_CODEC_ID_H264) {
2512                         // hmm
2513                     }
2514                 }
2515                 if (mbskip_table)
2516                     mbskip_table[mb_index] = 0;
2517             }
2518         }
2519     }
2520 }
2521
2522 void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
2523 {
2524     ff_print_debug_info2(s->avctx, pict, s->mbskip_table, p->mb_type,
2525                          p->qscale_table, p->motion_val, &s->low_delay,
2526                          s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
2527 }
2528
2529 int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
2530 {
2531     AVBufferRef *ref = av_buffer_ref(p->qscale_table_buf);
2532     int offset = 2*s->mb_stride + 1;
2533     if(!ref)
2534         return AVERROR(ENOMEM);
2535     av_assert0(ref->size >= offset + s->mb_stride * ((f->height+15)/16));
2536     ref->size -= offset;
2537     ref->data += offset;
2538     return av_frame_set_qp_table(f, ref, s->mb_stride, qp_type);
2539 }
2540
2541 static inline int hpel_motion_lowres(MpegEncContext *s,
2542                                      uint8_t *dest, uint8_t *src,
2543                                      int field_based, int field_select,
2544                                      int src_x, int src_y,
2545                                      int width, int height, ptrdiff_t stride,
2546                                      int h_edge_pos, int v_edge_pos,
2547                                      int w, int h, h264_chroma_mc_func *pix_op,
2548                                      int motion_x, int motion_y)
2549 {
2550     const int lowres   = s->avctx->lowres;
2551     const int op_index = FFMIN(lowres, 3);
2552     const int s_mask   = (2 << lowres) - 1;
2553     int emu = 0;
2554     int sx, sy;
2555
2556     if (s->quarter_sample) {
2557         motion_x /= 2;
2558         motion_y /= 2;
2559     }
2560
2561     sx = motion_x & s_mask;
2562     sy = motion_y & s_mask;
2563     src_x += motion_x >> lowres + 1;
2564     src_y += motion_y >> lowres + 1;
2565
2566     src   += src_y * stride + src_x;
2567
2568     if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w,                 0) ||
2569         (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2570         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
2571                                  s->linesize, s->linesize,
2572                                  w + 1, (h + 1) << field_based,
2573                                  src_x, src_y   << field_based,
2574                                  h_edge_pos, v_edge_pos);
2575         src = s->edge_emu_buffer;
2576         emu = 1;
2577     }
2578
2579     sx = (sx << 2) >> lowres;
2580     sy = (sy << 2) >> lowres;
2581     if (field_select)
2582         src += s->linesize;
2583     pix_op[op_index](dest, src, stride, h, sx, sy);
2584     return emu;
2585 }
2586
2587 /* apply one mpeg motion vector to the three components */
2588 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2589                                                 uint8_t *dest_y,
2590                                                 uint8_t *dest_cb,
2591                                                 uint8_t *dest_cr,
2592                                                 int field_based,
2593                                                 int bottom_field,
2594                                                 int field_select,
2595                                                 uint8_t **ref_picture,
2596                                                 h264_chroma_mc_func *pix_op,
2597                                                 int motion_x, int motion_y,
2598                                                 int h, int mb_y)
2599 {
2600     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2601     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy;
2602     ptrdiff_t uvlinesize, linesize;
2603     const int lowres     = s->avctx->lowres;
2604     const int op_index   = FFMIN(lowres-1+s->chroma_x_shift, 3);
2605     const int block_s    = 8>>lowres;
2606     const int s_mask     = (2 << lowres) - 1;
2607     const int h_edge_pos = s->h_edge_pos >> lowres;
2608     const int v_edge_pos = s->v_edge_pos >> lowres;
2609     linesize   = s->current_picture.f->linesize[0] << field_based;
2610     uvlinesize = s->current_picture.f->linesize[1] << field_based;
2611
2612     // FIXME obviously not perfect but qpel will not work in lowres anyway
2613     if (s->quarter_sample) {
2614         motion_x /= 2;
2615         motion_y /= 2;
2616     }
2617
2618     if(field_based){
2619         motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2620     }
2621
2622     sx = motion_x & s_mask;
2623     sy = motion_y & s_mask;
2624     src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2625     src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2626
2627     if (s->out_format == FMT_H263) {
2628         uvsx    = ((motion_x >> 1) & s_mask) | (sx & 1);
2629         uvsy    = ((motion_y >> 1) & s_mask) | (sy & 1);
2630         uvsrc_x = src_x >> 1;
2631         uvsrc_y = src_y >> 1;
2632     } else if (s->out_format == FMT_H261) {
2633         // even chroma mv's are full pel in H261
2634         mx      = motion_x / 4;
2635         my      = motion_y / 4;
2636         uvsx    = (2 * mx) & s_mask;
2637         uvsy    = (2 * my) & s_mask;
2638         uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2639         uvsrc_y =    mb_y * block_s + (my >> lowres);
2640     } else {
2641         if(s->chroma_y_shift){
2642             mx      = motion_x / 2;
2643             my      = motion_y / 2;
2644             uvsx    = mx & s_mask;
2645             uvsy    = my & s_mask;
2646             uvsrc_x = s->mb_x * block_s                 + (mx >> lowres + 1);
2647             uvsrc_y =   (mb_y * block_s >> field_based) + (my >> lowres + 1);
2648         } else {
2649             if(s->chroma_x_shift){
2650             //Chroma422
2651                 mx = motion_x / 2;
2652                 uvsx = mx & s_mask;
2653                 uvsy = motion_y & s_mask;
2654                 uvsrc_y = src_y;
2655                 uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2656             } else {
2657             //Chroma444
2658                 uvsx = motion_x & s_mask;
2659                 uvsy = motion_y & s_mask;
2660                 uvsrc_x = src_x;
2661                 uvsrc_y = src_y;
2662             }
2663         }
2664     }
2665
2666     ptr_y  = ref_picture[0] + src_y   * linesize   + src_x;
2667     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2668     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2669
2670     if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s,       0) || uvsrc_y<0 ||
2671         (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2672         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2673                                  linesize >> field_based, linesize >> field_based,
2674                                  17, 17 + field_based,
2675                                 src_x, src_y << field_based, h_edge_pos,
2676                                 v_edge_pos);
2677         ptr_y = s->edge_emu_buffer;
2678         if (!CONFIG_GRAY || !(s->avctx->flags & CODEC_FLAG_GRAY)) {
2679             uint8_t *ubuf = s->edge_emu_buffer + 18 * s->linesize;
2680             uint8_t *vbuf =ubuf + 9 * s->uvlinesize;
2681             s->vdsp.emulated_edge_mc(ubuf,  ptr_cb,
2682                                      uvlinesize >> field_based, uvlinesize >> field_based,
2683                                      9, 9 + field_based,
2684                                     uvsrc_x, uvsrc_y << field_based,
2685                                     h_edge_pos >> 1, v_edge_pos >> 1);
2686             s->vdsp.emulated_edge_mc(vbuf,  ptr_cr,
2687                                      uvlinesize >> field_based,uvlinesize >> field_based,
2688                                      9, 9 + field_based,
2689                                     uvsrc_x, uvsrc_y << field_based,
2690                                     h_edge_pos >> 1, v_edge_pos >> 1);
2691             ptr_cb = ubuf;
2692             ptr_cr = vbuf;
2693         }
2694     }
2695
2696     // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f->data
2697     if (bottom_field) {
2698         dest_y  += s->linesize;
2699         dest_cb += s->uvlinesize;
2700         dest_cr += s->uvlinesize;
2701     }
2702
2703     if (field_select) {
2704         ptr_y   += s->linesize;
2705         ptr_cb  += s->uvlinesize;
2706         ptr_cr  += s->uvlinesize;
2707     }
2708
2709     sx = (sx << 2) >> lowres;
2710     sy = (sy << 2) >> lowres;
2711     pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2712
2713     if (!CONFIG_GRAY || !(s->avctx->flags & CODEC_FLAG_GRAY)) {
2714         int hc = s->chroma_y_shift ? (h+1-bottom_field)>>1 : h;
2715         uvsx = (uvsx << 2) >> lowres;
2716         uvsy = (uvsy << 2) >> lowres;
2717         if (hc) {
2718             pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
2719             pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
2720         }
2721     }
2722     // FIXME h261 lowres loop filter
2723 }
2724
2725 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2726                                             uint8_t *dest_cb, uint8_t *dest_cr,
2727                                             uint8_t **ref_picture,
2728                                             h264_chroma_mc_func * pix_op,
2729                                             int mx, int my)
2730 {
2731     const int lowres     = s->avctx->lowres;
2732     const int op_index   = FFMIN(lowres, 3);
2733     const int block_s    = 8 >> lowres;
2734     const int s_mask     = (2 << lowres) - 1;
2735     const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2736     const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2737     int emu = 0, src_x, src_y, sx, sy;
2738     ptrdiff_t offset;
2739     uint8_t *ptr;
2740
2741     if (s->quarter_sample) {
2742         mx /= 2;
2743         my /= 2;
2744     }
2745
2746     /* In case of 8X8, we construct a single chroma motion vector
2747        with a special rounding */
2748     mx = ff_h263_round_chroma(mx);
2749     my = ff_h263_round_chroma(my);
2750
2751     sx = mx & s_mask;
2752     sy = my & s_mask;
2753     src_x = s->mb_x * block_s + (mx >> lowres + 1);
2754     src_y = s->mb_y * block_s + (my >> lowres + 1);
2755
2756     offset = src_y * s->uvlinesize + src_x;
2757     ptr = ref_picture[1] + offset;
2758     if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2759         (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2760         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
2761                                  s->uvlinesize, s->uvlinesize,
2762                                  9, 9,
2763                                  src_x, src_y, h_edge_pos, v_edge_pos);
2764         ptr = s->edge_emu_buffer;
2765         emu = 1;
2766     }
2767     sx = (sx << 2) >> lowres;
2768     sy = (sy << 2) >> lowres;
2769     pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2770
2771     ptr = ref_picture[2] + offset;
2772     if (emu) {
2773         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
2774                                  s->uvlinesize, s->uvlinesize,
2775                                  9, 9,
2776                                  src_x, src_y, h_edge_pos, v_edge_pos);
2777         ptr = s->edge_emu_buffer;
2778     }
2779     pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2780 }
2781
2782 /**
2783  * motion compensation of a single macroblock
2784  * @param s context
2785  * @param dest_y luma destination pointer
2786  * @param dest_cb chroma cb/u destination pointer
2787  * @param dest_cr chroma cr/v destination pointer
2788  * @param dir direction (0->forward, 1->backward)
2789  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2790  * @param pix_op halfpel motion compensation function (average or put normally)
2791  * the motion vectors are taken from s->mv and the MV type from s->mv_type
2792  */
2793 static inline void MPV_motion_lowres(MpegEncContext *s,
2794                                      uint8_t *dest_y, uint8_t *dest_cb,
2795                                      uint8_t *dest_cr,
2796                                      int dir, uint8_t **ref_picture,
2797                                      h264_chroma_mc_func *pix_op)
2798 {
2799     int mx, my;
2800     int mb_x, mb_y, i;
2801     const int lowres  = s->avctx->lowres;
2802     const int block_s = 8 >>lowres;
2803
2804     mb_x = s->mb_x;
2805     mb_y = s->mb_y;
2806
2807     switch (s->mv_type) {
2808     case MV_TYPE_16X16:
2809         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2810                            0, 0, 0,
2811                            ref_picture, pix_op,
2812                            s->mv[dir][0][0], s->mv[dir][0][1],
2813                            2 * block_s, mb_y);
2814         break;
2815     case MV_TYPE_8X8:
2816         mx = 0;
2817         my = 0;
2818         for (i = 0; i < 4; i++) {
2819             hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2820                                s->linesize) * block_s,
2821                                ref_picture[0], 0, 0,
2822                                (2 * mb_x + (i & 1)) * block_s,
2823                                (2 * mb_y + (i >> 1)) * block_s,
2824                                s->width, s->height, s->linesize,
2825                                s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2826                                block_s, block_s, pix_op,
2827                                s->mv[dir][i][0], s->mv[dir][i][1]);
2828
2829             mx += s->mv[dir][i][0];
2830             my += s->mv[dir][i][1];
2831         }
2832
2833         if (!CONFIG_GRAY || !(s->avctx->flags & CODEC_FLAG_GRAY))
2834             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2835                                      pix_op, mx, my);
2836         break;
2837     case MV_TYPE_FIELD:
2838         if (s->picture_structure == PICT_FRAME) {
2839             /* top field */
2840             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2841                                1, 0, s->field_select[dir][0],
2842                                ref_picture, pix_op,
2843                                s->mv[dir][0][0], s->mv[dir][0][1],
2844                                block_s, mb_y);
2845             /* bottom field */
2846             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2847                                1, 1, s->field_select[dir][1],
2848                                ref_picture, pix_op,
2849                                s->mv[dir][1][0], s->mv[dir][1][1],
2850                                block_s, mb_y);
2851         } else {
2852             if (s->picture_structure != s->field_select[dir][0] + 1 &&
2853                 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2854                 ref_picture = s->current_picture_ptr->f->data;
2855
2856             }
2857             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2858                                0, 0, s->field_select[dir][0],
2859                                ref_picture, pix_op,
2860                                s->mv[dir][0][0],
2861                                s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2862             }
2863         break;
2864     case MV_TYPE_16X8:
2865         for (i = 0; i < 2; i++) {
2866             uint8_t **ref2picture;
2867
2868             if (s->picture_structure == s->field_select[dir][i] + 1 ||
2869                 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2870                 ref2picture = ref_picture;
2871             } else {
2872                 ref2picture = s->current_picture_ptr->f->data;
2873             }
2874
2875             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2876                                0, 0, s->field_select[dir][i],
2877                                ref2picture, pix_op,
2878                                s->mv[dir][i][0], s->mv[dir][i][1] +
2879                                2 * block_s * i, block_s, mb_y >> 1);
2880
2881             dest_y  +=  2 * block_s *  s->linesize;
2882             dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2883             dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2884         }
2885         break;
2886     case MV_TYPE_DMV:
2887         if (s->picture_structure == PICT_FRAME) {
2888             for (i = 0; i < 2; i++) {
2889                 int j;
2890                 for (j = 0; j < 2; j++) {
2891                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2892                                        1, j, j ^ i,
2893                                        ref_picture, pix_op,
2894                                        s->mv[dir][2 * i + j][0],
2895                                        s->mv[dir][2 * i + j][1],
2896                                        block_s, mb_y);
2897                 }
2898                 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2899             }
2900         } else {
2901             for (i = 0; i < 2; i++) {
2902                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2903                                    0, 0, s->picture_structure != i + 1,
2904                                    ref_picture, pix_op,
2905                                    s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2906                                    2 * block_s, mb_y >> 1);
2907
2908                 // after put we make avg of the same block
2909                 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2910
2911                 // opposite parity is always in the same
2912                 // frame if this is second field
2913                 if (!s->first_field) {
2914                     ref_picture = s->current_picture_ptr->f->data;
2915                 }
2916             }
2917         }
2918         break;
2919     default:
2920         av_assert2(0);
2921     }
2922 }
2923
2924 /**
2925  * find the lowest MB row referenced in the MVs
2926  */
2927 int ff_mpv_lowest_referenced_row(MpegEncContext *s, int dir)
2928 {
2929     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2930     int my, off, i, mvs;
2931
2932     if (s->picture_structure != PICT_FRAME || s->mcsel)
2933         goto unhandled;
2934
2935     switch (s->mv_type) {
2936         case MV_TYPE_16X16:
2937             mvs = 1;
2938             break;
2939         case MV_TYPE_16X8:
2940             mvs = 2;
2941             break;
2942         case MV_TYPE_8X8:
2943             mvs = 4;
2944             break;
2945         default:
2946             goto unhandled;
2947     }
2948
2949     for (i = 0; i < mvs; i++) {
2950         my = s->mv[dir][i][1];
2951         my_max = FFMAX(my_max, my);
2952         my_min = FFMIN(my_min, my);
2953     }
2954
2955     off = ((FFMAX(-my_min, my_max)<<qpel_shift) + 63) >> 6;
2956
2957     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2958 unhandled:
2959     return s->mb_height-1;
2960 }
2961
2962 /* put block[] to dest[] */
2963 static inline void put_dct(MpegEncContext *s,
2964                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2965 {
2966     s->dct_unquantize_intra(s, block, i, qscale);
2967     s->idsp.idct_put(dest, line_size, block);
2968 }
2969
2970 /* add block[] to dest[] */
2971 static inline void add_dct(MpegEncContext *s,
2972                            int16_t *block, int i, uint8_t *dest, int line_size)
2973 {
2974     if (s->block_last_index[i] >= 0) {
2975         s->idsp.idct_add(dest, line_size, block);
2976     }
2977 }
2978
2979 static inline void add_dequant_dct(MpegEncContext *s,
2980                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2981 {
2982     if (s->block_last_index[i] >= 0) {
2983         s->dct_unquantize_inter(s, block, i, qscale);
2984
2985         s->idsp.idct_add(dest, line_size, block);
2986     }
2987 }
2988
2989 /**
2990  * Clean dc, ac, coded_block for the current non-intra MB.
2991  */
2992 void ff_clean_intra_table_entries(MpegEncContext *s)
2993 {
2994     int wrap = s->b8_stride;
2995     int xy = s->block_index[0];
2996
2997     s->dc_val[0][xy           ] =
2998     s->dc_val[0][xy + 1       ] =
2999     s->dc_val[0][xy     + wrap] =
3000     s->dc_val[0][xy + 1 + wrap] = 1024;
3001     /* ac pred */
3002     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3003     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3004     if (s->msmpeg4_version>=3) {
3005         s->coded_block[xy           ] =
3006         s->coded_block[xy + 1       ] =
3007         s->coded_block[xy     + wrap] =
3008         s->coded_block[xy + 1 + wrap] = 0;
3009     }
3010     /* chroma */
3011     wrap = s->mb_stride;
3012     xy = s->mb_x + s->mb_y * wrap;
3013     s->dc_val[1][xy] =
3014     s->dc_val[2][xy] = 1024;
3015     /* ac pred */
3016     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3017     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3018
3019     s->mbintra_table[xy]= 0;
3020 }
3021
3022 /* generic function called after a macroblock has been parsed by the
3023    decoder or after it has been encoded by the encoder.
3024
3025    Important variables used:
3026    s->mb_intra : true if intra macroblock
3027    s->mv_dir   : motion vector direction
3028    s->mv_type  : motion vector type
3029    s->mv       : motion vector
3030    s->interlaced_dct : true if interlaced dct used (mpeg2)
3031  */
3032 static av_always_inline
3033 void mpv_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
3034                             int lowres_flag, int is_mpeg12)
3035 {
3036     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3037
3038     if (CONFIG_XVMC &&
3039         s->avctx->hwaccel && s->avctx->hwaccel->decode_mb) {
3040         s->avctx->hwaccel->decode_mb(s);//xvmc uses pblocks
3041         return;
3042     }
3043
3044     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3045        /* print DCT coefficients */
3046        int i,j;
3047        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
3048        for(i=0; i<6; i++){
3049            for(j=0; j<64; j++){
3050                av_log(s->avctx, AV_LOG_DEBUG, "%5d",
3051                       block[i][s->idsp.idct_permutation[j]]);
3052            }
3053            av_log(s->avctx, AV_LOG_DEBUG, "\n");
3054        }
3055     }
3056
3057     s->current_picture.qscale_table[mb_xy] = s->qscale;
3058
3059     /* update DC predictors for P macroblocks */
3060     if (!s->mb_intra) {
3061         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
3062             if(s->mbintra_table[mb_xy])
3063                 ff_clean_intra_table_entries(s);
3064         } else {
3065             s->last_dc[0] =
3066             s->last_dc[1] =
3067             s->last_dc[2] = 128 << s->intra_dc_precision;
3068         }
3069     }
3070     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
3071         s->mbintra_table[mb_xy]=1;
3072
3073     if ((s->avctx->flags & CODEC_FLAG_PSNR) || s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor ||
3074         !(s->encoding && (s->intra_only || s->pict_type == AV_PICTURE_TYPE_B) &&
3075           s->avctx->mb_decision != FF_MB_DECISION_RD)) { // FIXME precalc
3076         uint8_t *dest_y, *dest_cb, *dest_cr;
3077         int dct_linesize, dct_offset;
3078         op_pixels_func (*op_pix)[4];
3079         qpel_mc_func (*op_qpix)[16];
3080         const int linesize   = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
3081         const int uvlinesize = s->current_picture.f->linesize[1];
3082         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3083         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3084
3085         /* avoid copy if macroblock skipped in last frame too */
3086         /* skip only during decoding as we might trash the buffers during encoding a bit */
3087         if(!s->encoding){
3088             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3089
3090             if (s->mb_skipped) {
3091                 s->mb_skipped= 0;
3092                 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
3093                 *mbskip_ptr = 1;
3094             } else if(!s->current_picture.reference) {
3095                 *mbskip_ptr = 1;
3096             } else{
3097                 *mbskip_ptr = 0; /* not skipped */
3098             }
3099         }
3100
3101         dct_linesize = linesize << s->interlaced_dct;
3102         dct_offset   = s->interlaced_dct ? linesize : linesize * block_size;
3103
3104         if(readable){
3105             dest_y=  s->dest[0];
3106             dest_cb= s->dest[1];
3107             dest_cr= s->dest[2];
3108         }else{
3109             dest_y = s->b_scratchpad;
3110             dest_cb= s->b_scratchpad+16*linesize;
3111             dest_cr= s->b_scratchpad+32*linesize;
3112         }
3113
3114         if (!s->mb_intra) {
3115             /* motion handling */
3116             /* decoding or more than one mb_type (MC was already done otherwise) */
3117             if(!s->encoding){
3118
3119                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
3120                     if (s->mv_dir & MV_DIR_FORWARD) {
3121                         ff_thread_await_progress(&s->last_picture_ptr->tf,
3122                                                  ff_mpv_lowest_referenced_row(s, 0),
3123                                                  0);
3124                     }
3125                     if (s->mv_dir & MV_DIR_BACKWARD) {
3126                         ff_thread_await_progress(&s->next_picture_ptr->tf,
3127                                                  ff_mpv_lowest_referenced_row(s, 1),
3128                                                  0);
3129                     }
3130                 }
3131
3132                 if(lowres_flag){
3133                     h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
3134
3135                     if (s->mv_dir & MV_DIR_FORWARD) {
3136                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix);
3137                         op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
3138                     }
3139                     if (s->mv_dir & MV_DIR_BACKWARD) {
3140                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix);
3141                     }
3142                 }else{
3143                     op_qpix = s->me.qpel_put;
3144                     if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
3145                         op_pix = s->hdsp.put_pixels_tab;
3146                     }else{
3147                         op_pix = s->hdsp.put_no_rnd_pixels_tab;
3148                     }
3149                     if (s->mv_dir & MV_DIR_FORWARD) {
3150                         ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
3151                         op_pix = s->hdsp.avg_pixels_tab;
3152                         op_qpix= s->me.qpel_avg;
3153                     }
3154                     if (s->mv_dir & MV_DIR_BACKWARD) {
3155                         ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
3156                     }
3157                 }
3158             }
3159
3160             /* skip dequant / idct if we are really late ;) */
3161             if(s->avctx->skip_idct){
3162                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
3163                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
3164                    || s->avctx->skip_idct >= AVDISCARD_ALL)
3165                     goto skip_idct;
3166             }
3167
3168             /* add dct residue */
3169             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
3170                                 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
3171                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3172                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3173                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3174                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3175
3176                 if (!CONFIG_GRAY || !(s->avctx->flags & CODEC_FLAG_GRAY)) {
3177                     if (s->chroma_y_shift){
3178                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3179                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3180                     }else{
3181                         dct_linesize >>= 1;
3182                         dct_offset >>=1;
3183                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
3184                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
3185                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
3186                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
3187                     }
3188                 }
3189             } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
3190                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
3191                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
3192                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
3193                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3194
3195                 if (!CONFIG_GRAY || !(s->avctx->flags & CODEC_FLAG_GRAY)) {
3196                     if(s->chroma_y_shift){//Chroma420
3197                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
3198                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
3199                     }else{
3200                         //chroma422
3201                         dct_linesize = uvlinesize << s->interlaced_dct;
3202                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
3203
3204                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
3205                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
3206                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3207                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3208                         if(!s->chroma_x_shift){//Chroma444
3209                             add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
3210                             add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
3211                             add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
3212                             add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
3213                         }
3214                     }
3215                 }//fi gray
3216             }
3217             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
3218                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3219             }
3220         } else {
3221             /* dct only in intra block */
3222             if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
3223                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3224                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3225                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3226                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3227
3228                 if (!CONFIG_GRAY || !(s->avctx->flags & CODEC_FLAG_GRAY)) {
3229                     if(s->chroma_y_shift){
3230                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3231                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3232                     }else{
3233                         dct_offset >>=1;
3234                         dct_linesize >>=1;
3235                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
3236                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
3237                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
3238                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
3239                     }
3240                 }
3241             }else{
3242                 s->idsp.idct_put(dest_y,                           dct_linesize, block[0]);
3243                 s->idsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
3244                 s->idsp.idct_put(dest_y + dct_offset,              dct_linesize, block[2]);
3245                 s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3246
3247                 if (!CONFIG_GRAY || !(s->avctx->flags & CODEC_FLAG_GRAY)) {
3248                     if(s->chroma_y_shift){
3249                         s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
3250                         s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
3251                     }else{
3252
3253                         dct_linesize = uvlinesize << s->interlaced_dct;
3254                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
3255
3256                         s->idsp.idct_put(dest_cb,              dct_linesize, block[4]);
3257                         s->idsp.idct_put(dest_cr,              dct_linesize, block[5]);
3258                         s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3259                         s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3260                         if(!s->chroma_x_shift){//Chroma444
3261                             s->idsp.idct_put(dest_cb + block_size,              dct_linesize, block[8]);
3262                             s->idsp.idct_put(dest_cr + block_size,              dct_linesize, block[9]);
3263                             s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
3264                             s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
3265                         }
3266                     }
3267                 }//gray
3268             }
3269         }
3270 skip_idct:
3271         if(!readable){
3272             s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3273             if (!CONFIG_GRAY || !(s->avctx->flags & CODEC_FLAG_GRAY)) {
3274                 s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3275                 s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3276             }
3277         }
3278     }
3279 }
3280
3281 void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64])
3282 {
3283 #if !CONFIG_SMALL
3284     if(s->out_format == FMT_MPEG1) {
3285         if(s->avctx->lowres) mpv_decode_mb_internal(s, block, 1, 1);
3286         else                 mpv_decode_mb_internal(s, block, 0, 1);
3287     } else
3288 #endif
3289     if(s->avctx->lowres) mpv_decode_mb_internal(s, block, 1, 0);
3290     else                  mpv_decode_mb_internal(s, block, 0, 0);
3291 }
3292
3293 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
3294 {
3295     ff_draw_horiz_band(s->avctx, s->current_picture_ptr->f,
3296                        s->last_picture_ptr ? s->last_picture_ptr->f : NULL, y, h, s->picture_structure,
3297                        s->first_field, s->low_delay);
3298 }
3299
3300 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3301     const int linesize   = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
3302     const int uvlinesize = s->current_picture.f->linesize[1];
3303     const int mb_size= 4 - s->avctx->lowres;
3304
3305     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3306     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3307     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3308     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3309     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3310     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;
3311     //block_index is not used by mpeg2, so it is not affected by chroma_format
3312
3313     s->dest[0] = s->current_picture.f->data[0] + (int)((s->mb_x - 1U) <<  mb_size);
3314     s->dest[1] = s->current_picture.f->data[1] + (int)((s->mb_x - 1U) << (mb_size - s->chroma_x_shift));
3315     s->dest[2] = s->current_picture.f->data[2] + (int)((s->mb_x - 1U) << (mb_size - s->chroma_x_shift));
3316
3317     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3318     {
3319         if(s->picture_structure==PICT_FRAME){
3320         s->dest[0] += s->mb_y *   linesize << mb_size;
3321         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3322         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3323         }else{
3324             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
3325             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
3326             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
3327             av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
3328         }
3329     }
3330 }
3331
3332 /**
3333  * Permute an 8x8 block.
3334  * @param block the block which will be permuted according to the given permutation vector
3335  * @param permutation the permutation vector
3336  * @param last the last non zero coefficient in scantable order, used to speed the permutation up
3337  * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
3338  *                  (inverse) permutated to scantable order!
3339  */
3340 void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
3341 {
3342     int i;
3343     int16_t temp[64];
3344
3345     if(last<=0) return;
3346     //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
3347
3348     for(i=0; i<=last; i++){
3349         const int j= scantable[i];
3350         temp[j]= block[j];
3351         block[j]=0;
3352     }
3353
3354     for(i=0; i<=last; i++){
3355         const int j= scantable[i];
3356         const int perm_j= permutation[j];
3357         block[perm_j]= temp[j];
3358     }
3359 }
3360
3361 void ff_mpeg_flush(AVCodecContext *avctx){
3362     int i;
3363     MpegEncContext *s = avctx->priv_data;
3364
3365     if (!s || !s->picture)
3366         return;
3367
3368     for (i = 0; i < MAX_PICTURE_COUNT; i++)
3369         ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
3370     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3371
3372     ff_mpeg_unref_picture(s->avctx, &s->current_picture);
3373     ff_mpeg_unref_picture(s->avctx, &s->last_picture);
3374     ff_mpeg_unref_picture(s->avctx, &s->next_picture);
3375
3376     s->mb_x= s->mb_y= 0;
3377     s->closed_gop= 0;
3378
3379     s->parse_context.state= -1;
3380     s->parse_context.frame_start_found= 0;
3381     s->parse_context.overread= 0;
3382     s->parse_context.overread_index= 0;
3383     s->parse_context.index= 0;
3384     s->parse_context.last_index= 0;
3385     s->bitstream_buffer_size=0;
3386     s->pp_time=0;
3387 }
3388
3389 /**
3390  * set qscale and update qscale dependent variables.
3391  */
3392 void ff_set_qscale(MpegEncContext * s, int qscale)
3393 {
3394     if (qscale < 1)
3395         qscale = 1;
3396     else if (qscale > 31)
3397         qscale = 31;
3398
3399     s->qscale = qscale;
3400     s->chroma_qscale= s->chroma_qscale_table[qscale];
3401
3402     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
3403     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
3404 }
3405
3406 void ff_mpv_report_decode_progress(MpegEncContext *s)
3407 {
3408     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
3409         ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
3410 }