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