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