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