ed4ca3561dc5e82bc9e6359a9f057715f1c2250b
[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)
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])
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] && &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 && !s->current_picture_ptr->f->buf[0]) {
1784         // we already have a unused image
1785         // (maybe it was set before reading the header)
1786         pic = s->current_picture_ptr;
1787     } else {
1788         i   = ff_find_unused_picture(s, 0);
1789         if (i < 0) {
1790             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1791             return i;
1792         }
1793         pic = &s->picture[i];
1794     }
1795
1796     pic->reference = 0;
1797     if (!s->droppable) {
1798         if (s->pict_type != AV_PICTURE_TYPE_B)
1799             pic->reference = 3;
1800     }
1801
1802     pic->f->coded_picture_number = s->coded_picture_number++;
1803
1804     if (ff_alloc_picture(s, pic, 0) < 0)
1805         return -1;
1806
1807     s->current_picture_ptr = pic;
1808     // FIXME use only the vars from current_pic
1809     s->current_picture_ptr->f->top_field_first = s->top_field_first;
1810     if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1811         s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1812         if (s->picture_structure != PICT_FRAME)
1813             s->current_picture_ptr->f->top_field_first =
1814                 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1815     }
1816     s->current_picture_ptr->f->interlaced_frame = !s->progressive_frame &&
1817                                                  !s->progressive_sequence;
1818     s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
1819
1820     s->current_picture_ptr->f->pict_type = s->pict_type;
1821     // if (s->flags && CODEC_FLAG_QSCALE)
1822     //     s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1823     s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1824
1825     if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1826                                    s->current_picture_ptr)) < 0)
1827         return ret;
1828
1829     if (s->pict_type != AV_PICTURE_TYPE_B) {
1830         s->last_picture_ptr = s->next_picture_ptr;
1831         if (!s->droppable)
1832             s->next_picture_ptr = s->current_picture_ptr;
1833     }
1834     av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1835             s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1836             s->last_picture_ptr    ? s->last_picture_ptr->f->data[0]    : NULL,
1837             s->next_picture_ptr    ? s->next_picture_ptr->f->data[0]    : NULL,
1838             s->current_picture_ptr ? s->current_picture_ptr->f->data[0] : NULL,
1839             s->pict_type, s->droppable);
1840
1841     if ((!s->last_picture_ptr || !s->last_picture_ptr->f->buf[0]) &&
1842         (s->pict_type != AV_PICTURE_TYPE_I ||
1843          s->picture_structure != PICT_FRAME)) {
1844         int h_chroma_shift, v_chroma_shift;
1845         av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1846                                          &h_chroma_shift, &v_chroma_shift);
1847         if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture_ptr && s->next_picture_ptr->f->buf[0])
1848             av_log(avctx, AV_LOG_DEBUG,
1849                    "allocating dummy last picture for B frame\n");
1850         else if (s->pict_type != AV_PICTURE_TYPE_I)
1851             av_log(avctx, AV_LOG_ERROR,
1852                    "warning: first frame is no keyframe\n");
1853         else if (s->picture_structure != PICT_FRAME)
1854             av_log(avctx, AV_LOG_DEBUG,
1855                    "allocate dummy last picture for field based first keyframe\n");
1856
1857         /* Allocate a dummy frame */
1858         i = ff_find_unused_picture(s, 0);
1859         if (i < 0) {
1860             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1861             return i;
1862         }
1863         s->last_picture_ptr = &s->picture[i];
1864
1865         s->last_picture_ptr->reference   = 3;
1866         s->last_picture_ptr->f->key_frame = 0;
1867         s->last_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1868
1869         if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1870             s->last_picture_ptr = NULL;
1871             return -1;
1872         }
1873
1874         if (!avctx->hwaccel && !(avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)) {
1875             for(i=0; i<avctx->height; i++)
1876                 memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i,
1877                        0x80, avctx->width);
1878             for(i=0; i<FF_CEIL_RSHIFT(avctx->height, v_chroma_shift); i++) {
1879                 memset(s->last_picture_ptr->f->data[1] + s->last_picture_ptr->f->linesize[1]*i,
1880                        0x80, FF_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1881                 memset(s->last_picture_ptr->f->data[2] + s->last_picture_ptr->f->linesize[2]*i,
1882                        0x80, FF_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1883             }
1884
1885             if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1886                 for(i=0; i<avctx->height; i++)
1887                 memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i, 16, avctx->width);
1888             }
1889         }
1890
1891         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1892         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1893     }
1894     if ((!s->next_picture_ptr || !s->next_picture_ptr->f->buf[0]) &&
1895         s->pict_type == AV_PICTURE_TYPE_B) {
1896         /* Allocate a dummy frame */
1897         i = ff_find_unused_picture(s, 0);
1898         if (i < 0) {
1899             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1900             return i;
1901         }
1902         s->next_picture_ptr = &s->picture[i];
1903
1904         s->next_picture_ptr->reference   = 3;
1905         s->next_picture_ptr->f->key_frame = 0;
1906         s->next_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1907
1908         if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1909             s->next_picture_ptr = NULL;
1910             return -1;
1911         }
1912         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1913         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1914     }
1915
1916 #if 0 // BUFREF-FIXME
1917     memset(s->last_picture.f->data, 0, sizeof(s->last_picture.f->data));
1918     memset(s->next_picture.f->data, 0, sizeof(s->next_picture.f->data));
1919 #endif
1920     if (s->last_picture_ptr) {
1921         ff_mpeg_unref_picture(s, &s->last_picture);
1922         if (s->last_picture_ptr->f->buf[0] &&
1923             (ret = ff_mpeg_ref_picture(s, &s->last_picture,
1924                                        s->last_picture_ptr)) < 0)
1925             return ret;
1926     }
1927     if (s->next_picture_ptr) {
1928         ff_mpeg_unref_picture(s, &s->next_picture);
1929         if (s->next_picture_ptr->f->buf[0] &&
1930             (ret = ff_mpeg_ref_picture(s, &s->next_picture,
1931                                        s->next_picture_ptr)) < 0)
1932             return ret;
1933     }
1934
1935     av_assert0(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1936                                                  s->last_picture_ptr->f->buf[0]));
1937
1938     if (s->picture_structure!= PICT_FRAME) {
1939         int i;
1940         for (i = 0; i < 4; i++) {
1941             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1942                 s->current_picture.f->data[i] +=
1943                     s->current_picture.f->linesize[i];
1944             }
1945             s->current_picture.f->linesize[i] *= 2;
1946             s->last_picture.f->linesize[i]    *= 2;
1947             s->next_picture.f->linesize[i]    *= 2;
1948         }
1949     }
1950
1951     s->err_recognition = avctx->err_recognition;
1952
1953     /* set dequantizer, we can't do it during init as
1954      * it might change for mpeg4 and we can't do it in the header
1955      * decode as init is not called for mpeg4 there yet */
1956     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1957         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1958         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1959     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1960         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1961         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1962     } else {
1963         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1964         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1965     }
1966
1967     if (s->avctx->debug & FF_DEBUG_NOMC) {
1968         gray_frame(s->current_picture_ptr->f);
1969     }
1970
1971     return 0;
1972 }
1973
1974 /* called after a frame has been decoded. */
1975 void ff_mpv_frame_end(MpegEncContext *s)
1976 {
1977     emms_c();
1978
1979     if (s->current_picture.reference)
1980         ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1981 }
1982
1983
1984 static int clip_line(int *sx, int *sy, int *ex, int *ey, int maxx)
1985 {
1986     if(*sx > *ex)
1987         return clip_line(ex, ey, sx, sy, maxx);
1988
1989     if (*sx < 0) {
1990         if (*ex < 0)
1991             return 1;
1992         *sy = *ey + (*sy - *ey) * (int64_t)*ex / (*ex - *sx);
1993         *sx = 0;
1994     }
1995
1996     if (*ex > maxx) {
1997         if (*sx > maxx)
1998             return 1;
1999         *ey = *sy + (*ey - *sy) * (int64_t)(maxx - *sx) / (*ex - *sx);
2000         *ex = maxx;
2001     }
2002     return 0;
2003 }
2004
2005
2006 /**
2007  * Draw a line from (ex, ey) -> (sx, sy).
2008  * @param w width of the image
2009  * @param h height of the image
2010  * @param stride stride/linesize of the image
2011  * @param color color of the arrow
2012  */
2013 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
2014                       int w, int h, int stride, int color)
2015 {
2016     int x, y, fr, f;
2017
2018     if (clip_line(&sx, &sy, &ex, &ey, w - 1))
2019         return;
2020     if (clip_line(&sy, &sx, &ey, &ex, h - 1))
2021         return;
2022
2023     sx = av_clip(sx, 0, w - 1);
2024     sy = av_clip(sy, 0, h - 1);
2025     ex = av_clip(ex, 0, w - 1);
2026     ey = av_clip(ey, 0, h - 1);
2027
2028     buf[sy * stride + sx] += color;
2029
2030     if (FFABS(ex - sx) > FFABS(ey - sy)) {
2031         if (sx > ex) {
2032             FFSWAP(int, sx, ex);
2033             FFSWAP(int, sy, ey);
2034         }
2035         buf += sx + sy * stride;
2036         ex  -= sx;
2037         f    = ((ey - sy) << 16) / ex;
2038         for (x = 0; x <= ex; x++) {
2039             y  = (x * f) >> 16;
2040             fr = (x * f) & 0xFFFF;
2041             buf[y * stride + x]       += (color * (0x10000 - fr)) >> 16;
2042             if(fr) buf[(y + 1) * stride + x] += (color *            fr ) >> 16;
2043         }
2044     } else {
2045         if (sy > ey) {
2046             FFSWAP(int, sx, ex);
2047             FFSWAP(int, sy, ey);
2048         }
2049         buf += sx + sy * stride;
2050         ey  -= sy;
2051         if (ey)
2052             f = ((ex - sx) << 16) / ey;
2053         else
2054             f = 0;
2055         for(y= 0; y <= ey; y++){
2056             x  = (y*f) >> 16;
2057             fr = (y*f) & 0xFFFF;
2058             buf[y * stride + x]     += (color * (0x10000 - fr)) >> 16;
2059             if(fr) buf[y * stride + x + 1] += (color *            fr ) >> 16;
2060         }
2061     }
2062 }
2063
2064 /**
2065  * Draw an arrow from (ex, ey) -> (sx, sy).
2066  * @param w width of the image
2067  * @param h height of the image
2068  * @param stride stride/linesize of the image
2069  * @param color color of the arrow
2070  */
2071 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
2072                        int ey, int w, int h, int stride, int color, int tail, int direction)
2073 {
2074     int dx,dy;
2075
2076     if (direction) {
2077         FFSWAP(int, sx, ex);
2078         FFSWAP(int, sy, ey);
2079     }
2080
2081     sx = av_clip(sx, -100, w + 100);
2082     sy = av_clip(sy, -100, h + 100);
2083     ex = av_clip(ex, -100, w + 100);
2084     ey = av_clip(ey, -100, h + 100);
2085
2086     dx = ex - sx;
2087     dy = ey - sy;
2088
2089     if (dx * dx + dy * dy > 3 * 3) {
2090         int rx =  dx + dy;
2091         int ry = -dx + dy;
2092         int length = ff_sqrt((rx * rx + ry * ry) << 8);
2093
2094         // FIXME subpixel accuracy
2095         rx = ROUNDED_DIV(rx * 3 << 4, length);
2096         ry = ROUNDED_DIV(ry * 3 << 4, length);
2097
2098         if (tail) {
2099             rx = -rx;
2100             ry = -ry;
2101         }
2102
2103         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
2104         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
2105     }
2106     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
2107 }
2108
2109 /**
2110  * Print debugging info for the given picture.
2111  */
2112 void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table,
2113                          uint32_t *mbtype_table, int8_t *qscale_table, int16_t (*motion_val[2])[2],
2114                          int *low_delay,
2115                          int mb_width, int mb_height, int mb_stride, int quarter_sample)
2116 {
2117     if (avctx->hwaccel || !mbtype_table
2118         || (avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
2119         return;
2120
2121
2122     if (avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
2123         int x,y;
2124
2125         av_log(avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
2126                av_get_picture_type_char(pict->pict_type));
2127         for (y = 0; y < mb_height; y++) {
2128             for (x = 0; x < mb_width; x++) {
2129                 if (avctx->debug & FF_DEBUG_SKIP) {
2130                     int count = mbskip_table[x + y * mb_stride];
2131                     if (count > 9)
2132                         count = 9;
2133                     av_log(avctx, AV_LOG_DEBUG, "%1d", count);
2134                 }
2135                 if (avctx->debug & FF_DEBUG_QP) {
2136                     av_log(avctx, AV_LOG_DEBUG, "%2d",
2137                            qscale_table[x + y * mb_stride]);
2138                 }
2139                 if (avctx->debug & FF_DEBUG_MB_TYPE) {
2140                     int mb_type = mbtype_table[x + y * mb_stride];
2141                     // Type & MV direction
2142                     if (IS_PCM(mb_type))
2143                         av_log(avctx, AV_LOG_DEBUG, "P");
2144                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
2145                         av_log(avctx, AV_LOG_DEBUG, "A");
2146                     else if (IS_INTRA4x4(mb_type))
2147                         av_log(avctx, AV_LOG_DEBUG, "i");
2148                     else if (IS_INTRA16x16(mb_type))
2149                         av_log(avctx, AV_LOG_DEBUG, "I");
2150                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
2151                         av_log(avctx, AV_LOG_DEBUG, "d");
2152                     else if (IS_DIRECT(mb_type))
2153                         av_log(avctx, AV_LOG_DEBUG, "D");
2154                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
2155                         av_log(avctx, AV_LOG_DEBUG, "g");
2156                     else if (IS_GMC(mb_type))
2157                         av_log(avctx, AV_LOG_DEBUG, "G");
2158                     else if (IS_SKIP(mb_type))
2159                         av_log(avctx, AV_LOG_DEBUG, "S");
2160                     else if (!USES_LIST(mb_type, 1))
2161                         av_log(avctx, AV_LOG_DEBUG, ">");
2162                     else if (!USES_LIST(mb_type, 0))
2163                         av_log(avctx, AV_LOG_DEBUG, "<");
2164                     else {
2165                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2166                         av_log(avctx, AV_LOG_DEBUG, "X");
2167                     }
2168
2169                     // segmentation
2170                     if (IS_8X8(mb_type))
2171                         av_log(avctx, AV_LOG_DEBUG, "+");
2172                     else if (IS_16X8(mb_type))
2173                         av_log(avctx, AV_LOG_DEBUG, "-");
2174                     else if (IS_8X16(mb_type))
2175                         av_log(avctx, AV_LOG_DEBUG, "|");
2176                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
2177                         av_log(avctx, AV_LOG_DEBUG, " ");
2178                     else
2179                         av_log(avctx, AV_LOG_DEBUG, "?");
2180
2181
2182                     if (IS_INTERLACED(mb_type))
2183                         av_log(avctx, AV_LOG_DEBUG, "=");
2184                     else
2185                         av_log(avctx, AV_LOG_DEBUG, " ");
2186                 }
2187             }
2188             av_log(avctx, AV_LOG_DEBUG, "\n");
2189         }
2190     }
2191
2192     if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
2193         (avctx->debug_mv)) {
2194         const int shift = 1 + quarter_sample;
2195         int mb_y;
2196         uint8_t *ptr;
2197         int i;
2198         int h_chroma_shift, v_chroma_shift, block_height;
2199         const int width          = avctx->width;
2200         const int height         = avctx->height;
2201         const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
2202         const int mv_stride      = (mb_width << mv_sample_log2) +
2203                                    (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
2204
2205         *low_delay = 0; // needed to see the vectors without trashing the buffers
2206
2207         avcodec_get_chroma_sub_sample(avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2208
2209         av_frame_make_writable(pict);
2210
2211         pict->opaque = NULL;
2212         ptr          = pict->data[0];
2213         block_height = 16 >> v_chroma_shift;
2214
2215         for (mb_y = 0; mb_y < mb_height; mb_y++) {
2216             int mb_x;
2217             for (mb_x = 0; mb_x < mb_width; mb_x++) {
2218                 const int mb_index = mb_x + mb_y * mb_stride;
2219                 if ((avctx->debug_mv) && motion_val[0]) {
2220                     int type;
2221                     for (type = 0; type < 3; type++) {
2222                         int direction = 0;
2223                         switch (type) {
2224                         case 0:
2225                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
2226                                 (pict->pict_type!= AV_PICTURE_TYPE_P))
2227                                 continue;
2228                             direction = 0;
2229                             break;
2230                         case 1:
2231                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
2232                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
2233                                 continue;
2234                             direction = 0;
2235                             break;
2236                         case 2:
2237                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
2238                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
2239                                 continue;
2240                             direction = 1;
2241                             break;
2242                         }
2243                         if (!USES_LIST(mbtype_table[mb_index], direction))
2244                             continue;
2245
2246                         if (IS_8X8(mbtype_table[mb_index])) {
2247                             int i;
2248                             for (i = 0; i < 4; i++) {
2249                                 int sx = mb_x * 16 + 4 + 8 * (i & 1);
2250                                 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
2251                                 int xy = (mb_x * 2 + (i & 1) +
2252                                           (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2253                                 int mx = (motion_val[direction][xy][0] >> shift) + sx;
2254                                 int my = (motion_val[direction][xy][1] >> shift) + sy;
2255                                 draw_arrow(ptr, sx, sy, mx, my, width,
2256                                            height, pict->linesize[0], 100, 0, direction);
2257                             }
2258                         } else if (IS_16X8(mbtype_table[mb_index])) {
2259                             int i;
2260                             for (i = 0; i < 2; i++) {
2261                                 int sx = mb_x * 16 + 8;
2262                                 int sy = mb_y * 16 + 4 + 8 * i;
2263                                 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
2264                                 int mx = (motion_val[direction][xy][0] >> shift);
2265                                 int my = (motion_val[direction][xy][1] >> shift);
2266
2267                                 if (IS_INTERLACED(mbtype_table[mb_index]))
2268                                     my *= 2;
2269
2270                                 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2271                                            height, pict->linesize[0], 100, 0, direction);
2272                             }
2273                         } else if (IS_8X16(mbtype_table[mb_index])) {
2274                             int i;
2275                             for (i = 0; i < 2; i++) {
2276                                 int sx = mb_x * 16 + 4 + 8 * i;
2277                                 int sy = mb_y * 16 + 8;
2278                                 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
2279                                 int mx = motion_val[direction][xy][0] >> shift;
2280                                 int my = motion_val[direction][xy][1] >> shift;
2281
2282                                 if (IS_INTERLACED(mbtype_table[mb_index]))
2283                                     my *= 2;
2284
2285                                 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2286                                            height, pict->linesize[0], 100, 0, direction);
2287                             }
2288                         } else {
2289                               int sx= mb_x * 16 + 8;
2290                               int sy= mb_y * 16 + 8;
2291                               int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
2292                               int mx= (motion_val[direction][xy][0]>>shift) + sx;
2293                               int my= (motion_val[direction][xy][1]>>shift) + sy;
2294                               draw_arrow(ptr, sx, sy, mx, my, width, height, pict->linesize[0], 100, 0, direction);
2295                         }
2296                     }
2297                 }
2298                 if ((avctx->debug & FF_DEBUG_VIS_QP)) {
2299                     uint64_t c = (qscale_table[mb_index] * 128 / 31) *
2300                                  0x0101010101010101ULL;
2301                     int y;
2302                     for (y = 0; y < block_height; y++) {
2303                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
2304                                       (block_height * mb_y + y) *
2305                                       pict->linesize[1]) = c;
2306                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
2307                                       (block_height * mb_y + y) *
2308                                       pict->linesize[2]) = c;
2309                     }
2310                 }
2311                 if ((avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
2312                     motion_val[0]) {
2313                     int mb_type = mbtype_table[mb_index];
2314                     uint64_t u,v;
2315                     int y;
2316 #define COLOR(theta, r) \
2317     u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
2318     v = (int)(128 + r * sin(theta * 3.141592 / 180));
2319
2320
2321                     u = v = 128;
2322                     if (IS_PCM(mb_type)) {
2323                         COLOR(120, 48)
2324                     } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
2325                                IS_INTRA16x16(mb_type)) {
2326                         COLOR(30, 48)
2327                     } else if (IS_INTRA4x4(mb_type)) {
2328                         COLOR(90, 48)
2329                     } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
2330                         // COLOR(120, 48)
2331                     } else if (IS_DIRECT(mb_type)) {
2332                         COLOR(150, 48)
2333                     } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
2334                         COLOR(170, 48)
2335                     } else if (IS_GMC(mb_type)) {
2336                         COLOR(190, 48)
2337                     } else if (IS_SKIP(mb_type)) {
2338                         // COLOR(180, 48)
2339                     } else if (!USES_LIST(mb_type, 1)) {
2340                         COLOR(240, 48)
2341                     } else if (!USES_LIST(mb_type, 0)) {
2342                         COLOR(0, 48)
2343                     } else {
2344                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2345                         COLOR(300,48)
2346                     }
2347
2348                     u *= 0x0101010101010101ULL;
2349                     v *= 0x0101010101010101ULL;
2350                     for (y = 0; y < block_height; y++) {
2351                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
2352                                       (block_height * mb_y + y) * pict->linesize[1]) = u;
2353                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
2354                                       (block_height * mb_y + y) * pict->linesize[2]) = v;
2355                     }
2356
2357                     // segmentation
2358                     if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
2359                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
2360                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2361                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
2362                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2363                     }
2364                     if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
2365                         for (y = 0; y < 16; y++)
2366                             pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
2367                                           pict->linesize[0]] ^= 0x80;
2368                     }
2369                     if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
2370                         int dm = 1 << (mv_sample_log2 - 2);
2371                         for (i = 0; i < 4; i++) {
2372                             int sx = mb_x * 16 + 8 * (i & 1);
2373                             int sy = mb_y * 16 + 8 * (i >> 1);
2374                             int xy = (mb_x * 2 + (i & 1) +
2375                                      (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2376                             // FIXME bidir
2377                             int32_t *mv = (int32_t *) &motion_val[0][xy];
2378                             if (mv[0] != mv[dm] ||
2379                                 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
2380                                 for (y = 0; y < 8; y++)
2381                                     pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
2382                             if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
2383                                 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
2384                                               pict->linesize[0]) ^= 0x8080808080808080ULL;
2385                         }
2386                     }
2387
2388                     if (IS_INTERLACED(mb_type) &&
2389                         avctx->codec->id == AV_CODEC_ID_H264) {
2390                         // hmm
2391                     }
2392                 }
2393                 mbskip_table[mb_index] = 0;
2394             }
2395         }
2396     }
2397 }
2398
2399 void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
2400 {
2401     ff_print_debug_info2(s->avctx, pict, s->mbskip_table, p->mb_type,
2402                          p->qscale_table, p->motion_val, &s->low_delay,
2403                          s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
2404 }
2405
2406 int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
2407 {
2408     AVBufferRef *ref = av_buffer_ref(p->qscale_table_buf);
2409     int offset = 2*s->mb_stride + 1;
2410     if(!ref)
2411         return AVERROR(ENOMEM);
2412     av_assert0(ref->size >= offset + s->mb_stride * ((f->height+15)/16));
2413     ref->size -= offset;
2414     ref->data += offset;
2415     return av_frame_set_qp_table(f, ref, s->mb_stride, qp_type);
2416 }
2417
2418 static inline int hpel_motion_lowres(MpegEncContext *s,
2419                                      uint8_t *dest, uint8_t *src,
2420                                      int field_based, int field_select,
2421                                      int src_x, int src_y,
2422                                      int width, int height, ptrdiff_t stride,
2423                                      int h_edge_pos, int v_edge_pos,
2424                                      int w, int h, h264_chroma_mc_func *pix_op,
2425                                      int motion_x, int motion_y)
2426 {
2427     const int lowres   = s->avctx->lowres;
2428     const int op_index = FFMIN(lowres, 3);
2429     const int s_mask   = (2 << lowres) - 1;
2430     int emu = 0;
2431     int sx, sy;
2432
2433     if (s->quarter_sample) {
2434         motion_x /= 2;
2435         motion_y /= 2;
2436     }
2437
2438     sx = motion_x & s_mask;
2439     sy = motion_y & s_mask;
2440     src_x += motion_x >> lowres + 1;
2441     src_y += motion_y >> lowres + 1;
2442
2443     src   += src_y * stride + src_x;
2444
2445     if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w,                 0) ||
2446         (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2447         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
2448                                  s->linesize, s->linesize,
2449                                  w + 1, (h + 1) << field_based,
2450                                  src_x, src_y   << field_based,
2451                                  h_edge_pos, v_edge_pos);
2452         src = s->edge_emu_buffer;
2453         emu = 1;
2454     }
2455
2456     sx = (sx << 2) >> lowres;
2457     sy = (sy << 2) >> lowres;
2458     if (field_select)
2459         src += s->linesize;
2460     pix_op[op_index](dest, src, stride, h, sx, sy);
2461     return emu;
2462 }
2463
2464 /* apply one mpeg motion vector to the three components */
2465 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2466                                                 uint8_t *dest_y,
2467                                                 uint8_t *dest_cb,
2468                                                 uint8_t *dest_cr,
2469                                                 int field_based,
2470                                                 int bottom_field,
2471                                                 int field_select,
2472                                                 uint8_t **ref_picture,
2473                                                 h264_chroma_mc_func *pix_op,
2474                                                 int motion_x, int motion_y,
2475                                                 int h, int mb_y)
2476 {
2477     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2478     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy;
2479     ptrdiff_t uvlinesize, linesize;
2480     const int lowres     = s->avctx->lowres;
2481     const int op_index   = FFMIN(lowres-1+s->chroma_x_shift, 3);
2482     const int block_s    = 8>>lowres;
2483     const int s_mask     = (2 << lowres) - 1;
2484     const int h_edge_pos = s->h_edge_pos >> lowres;
2485     const int v_edge_pos = s->v_edge_pos >> lowres;
2486     linesize   = s->current_picture.f->linesize[0] << field_based;
2487     uvlinesize = s->current_picture.f->linesize[1] << field_based;
2488
2489     // FIXME obviously not perfect but qpel will not work in lowres anyway
2490     if (s->quarter_sample) {
2491         motion_x /= 2;
2492         motion_y /= 2;
2493     }
2494
2495     if(field_based){
2496         motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2497     }
2498
2499     sx = motion_x & s_mask;
2500     sy = motion_y & s_mask;
2501     src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2502     src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2503
2504     if (s->out_format == FMT_H263) {
2505         uvsx    = ((motion_x >> 1) & s_mask) | (sx & 1);
2506         uvsy    = ((motion_y >> 1) & s_mask) | (sy & 1);
2507         uvsrc_x = src_x >> 1;
2508         uvsrc_y = src_y >> 1;
2509     } else if (s->out_format == FMT_H261) {
2510         // even chroma mv's are full pel in H261
2511         mx      = motion_x / 4;
2512         my      = motion_y / 4;
2513         uvsx    = (2 * mx) & s_mask;
2514         uvsy    = (2 * my) & s_mask;
2515         uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2516         uvsrc_y =    mb_y * block_s + (my >> lowres);
2517     } else {
2518         if(s->chroma_y_shift){
2519             mx      = motion_x / 2;
2520             my      = motion_y / 2;
2521             uvsx    = mx & s_mask;
2522             uvsy    = my & s_mask;
2523             uvsrc_x = s->mb_x * block_s                 + (mx >> lowres + 1);
2524             uvsrc_y =   (mb_y * block_s >> field_based) + (my >> lowres + 1);
2525         } else {
2526             if(s->chroma_x_shift){
2527             //Chroma422
2528                 mx = motion_x / 2;
2529                 uvsx = mx & s_mask;
2530                 uvsy = motion_y & s_mask;
2531                 uvsrc_y = src_y;
2532                 uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2533             } else {
2534             //Chroma444
2535                 uvsx = motion_x & s_mask;
2536                 uvsy = motion_y & s_mask;
2537                 uvsrc_x = src_x;
2538                 uvsrc_y = src_y;
2539             }
2540         }
2541     }
2542
2543     ptr_y  = ref_picture[0] + src_y   * linesize   + src_x;
2544     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2545     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2546
2547     if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s,       0) || uvsrc_y<0 ||
2548         (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2549         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2550                                  linesize >> field_based, linesize >> field_based,
2551                                  17, 17 + field_based,
2552                                 src_x, src_y << field_based, h_edge_pos,
2553                                 v_edge_pos);
2554         ptr_y = s->edge_emu_buffer;
2555         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2556             uint8_t *ubuf = s->edge_emu_buffer + 18 * s->linesize;
2557             uint8_t *vbuf =ubuf + 9 * s->uvlinesize;
2558             s->vdsp.emulated_edge_mc(ubuf,  ptr_cb,
2559                                      uvlinesize >> field_based, uvlinesize >> field_based,
2560                                      9, 9 + field_based,
2561                                     uvsrc_x, uvsrc_y << field_based,
2562                                     h_edge_pos >> 1, v_edge_pos >> 1);
2563             s->vdsp.emulated_edge_mc(vbuf,  ptr_cr,
2564                                      uvlinesize >> field_based,uvlinesize >> field_based,
2565                                      9, 9 + field_based,
2566                                     uvsrc_x, uvsrc_y << field_based,
2567                                     h_edge_pos >> 1, v_edge_pos >> 1);
2568             ptr_cb = ubuf;
2569             ptr_cr = vbuf;
2570         }
2571     }
2572
2573     // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f->data
2574     if (bottom_field) {
2575         dest_y  += s->linesize;
2576         dest_cb += s->uvlinesize;
2577         dest_cr += s->uvlinesize;
2578     }
2579
2580     if (field_select) {
2581         ptr_y   += s->linesize;
2582         ptr_cb  += s->uvlinesize;
2583         ptr_cr  += s->uvlinesize;
2584     }
2585
2586     sx = (sx << 2) >> lowres;
2587     sy = (sy << 2) >> lowres;
2588     pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2589
2590     if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2591         int hc = s->chroma_y_shift ? (h+1-bottom_field)>>1 : h;
2592         uvsx = (uvsx << 2) >> lowres;
2593         uvsy = (uvsy << 2) >> lowres;
2594         if (hc) {
2595             pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
2596             pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
2597         }
2598     }
2599     // FIXME h261 lowres loop filter
2600 }
2601
2602 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2603                                             uint8_t *dest_cb, uint8_t *dest_cr,
2604                                             uint8_t **ref_picture,
2605                                             h264_chroma_mc_func * pix_op,
2606                                             int mx, int my)
2607 {
2608     const int lowres     = s->avctx->lowres;
2609     const int op_index   = FFMIN(lowres, 3);
2610     const int block_s    = 8 >> lowres;
2611     const int s_mask     = (2 << lowres) - 1;
2612     const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2613     const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2614     int emu = 0, src_x, src_y, sx, sy;
2615     ptrdiff_t offset;
2616     uint8_t *ptr;
2617
2618     if (s->quarter_sample) {
2619         mx /= 2;
2620         my /= 2;
2621     }
2622
2623     /* In case of 8X8, we construct a single chroma motion vector
2624        with a special rounding */
2625     mx = ff_h263_round_chroma(mx);
2626     my = ff_h263_round_chroma(my);
2627
2628     sx = mx & s_mask;
2629     sy = my & s_mask;
2630     src_x = s->mb_x * block_s + (mx >> lowres + 1);
2631     src_y = s->mb_y * block_s + (my >> lowres + 1);
2632
2633     offset = src_y * s->uvlinesize + src_x;
2634     ptr = ref_picture[1] + offset;
2635     if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2636         (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2637         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
2638                                  s->uvlinesize, s->uvlinesize,
2639                                  9, 9,
2640                                  src_x, src_y, h_edge_pos, v_edge_pos);
2641         ptr = s->edge_emu_buffer;
2642         emu = 1;
2643     }
2644     sx = (sx << 2) >> lowres;
2645     sy = (sy << 2) >> lowres;
2646     pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2647
2648     ptr = ref_picture[2] + offset;
2649     if (emu) {
2650         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
2651                                  s->uvlinesize, s->uvlinesize,
2652                                  9, 9,
2653                                  src_x, src_y, h_edge_pos, v_edge_pos);
2654         ptr = s->edge_emu_buffer;
2655     }
2656     pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2657 }
2658
2659 /**
2660  * motion compensation of a single macroblock
2661  * @param s context
2662  * @param dest_y luma destination pointer
2663  * @param dest_cb chroma cb/u destination pointer
2664  * @param dest_cr chroma cr/v destination pointer
2665  * @param dir direction (0->forward, 1->backward)
2666  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2667  * @param pix_op halfpel motion compensation function (average or put normally)
2668  * the motion vectors are taken from s->mv and the MV type from s->mv_type
2669  */
2670 static inline void MPV_motion_lowres(MpegEncContext *s,
2671                                      uint8_t *dest_y, uint8_t *dest_cb,
2672                                      uint8_t *dest_cr,
2673                                      int dir, uint8_t **ref_picture,
2674                                      h264_chroma_mc_func *pix_op)
2675 {
2676     int mx, my;
2677     int mb_x, mb_y, i;
2678     const int lowres  = s->avctx->lowres;
2679     const int block_s = 8 >>lowres;
2680
2681     mb_x = s->mb_x;
2682     mb_y = s->mb_y;
2683
2684     switch (s->mv_type) {
2685     case MV_TYPE_16X16:
2686         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2687                            0, 0, 0,
2688                            ref_picture, pix_op,
2689                            s->mv[dir][0][0], s->mv[dir][0][1],
2690                            2 * block_s, mb_y);
2691         break;
2692     case MV_TYPE_8X8:
2693         mx = 0;
2694         my = 0;
2695         for (i = 0; i < 4; i++) {
2696             hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2697                                s->linesize) * block_s,
2698                                ref_picture[0], 0, 0,
2699                                (2 * mb_x + (i & 1)) * block_s,
2700                                (2 * mb_y + (i >> 1)) * block_s,
2701                                s->width, s->height, s->linesize,
2702                                s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2703                                block_s, block_s, pix_op,
2704                                s->mv[dir][i][0], s->mv[dir][i][1]);
2705
2706             mx += s->mv[dir][i][0];
2707             my += s->mv[dir][i][1];
2708         }
2709
2710         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2711             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2712                                      pix_op, mx, my);
2713         break;
2714     case MV_TYPE_FIELD:
2715         if (s->picture_structure == PICT_FRAME) {
2716             /* top field */
2717             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2718                                1, 0, s->field_select[dir][0],
2719                                ref_picture, pix_op,
2720                                s->mv[dir][0][0], s->mv[dir][0][1],
2721                                block_s, mb_y);
2722             /* bottom field */
2723             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2724                                1, 1, s->field_select[dir][1],
2725                                ref_picture, pix_op,
2726                                s->mv[dir][1][0], s->mv[dir][1][1],
2727                                block_s, mb_y);
2728         } else {
2729             if (s->picture_structure != s->field_select[dir][0] + 1 &&
2730                 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2731                 ref_picture = s->current_picture_ptr->f->data;
2732
2733             }
2734             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2735                                0, 0, s->field_select[dir][0],
2736                                ref_picture, pix_op,
2737                                s->mv[dir][0][0],
2738                                s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2739             }
2740         break;
2741     case MV_TYPE_16X8:
2742         for (i = 0; i < 2; i++) {
2743             uint8_t **ref2picture;
2744
2745             if (s->picture_structure == s->field_select[dir][i] + 1 ||
2746                 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2747                 ref2picture = ref_picture;
2748             } else {
2749                 ref2picture = s->current_picture_ptr->f->data;
2750             }
2751
2752             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2753                                0, 0, s->field_select[dir][i],
2754                                ref2picture, pix_op,
2755                                s->mv[dir][i][0], s->mv[dir][i][1] +
2756                                2 * block_s * i, block_s, mb_y >> 1);
2757
2758             dest_y  +=  2 * block_s *  s->linesize;
2759             dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2760             dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2761         }
2762         break;
2763     case MV_TYPE_DMV:
2764         if (s->picture_structure == PICT_FRAME) {
2765             for (i = 0; i < 2; i++) {
2766                 int j;
2767                 for (j = 0; j < 2; j++) {
2768                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2769                                        1, j, j ^ i,
2770                                        ref_picture, pix_op,
2771                                        s->mv[dir][2 * i + j][0],
2772                                        s->mv[dir][2 * i + j][1],
2773                                        block_s, mb_y);
2774                 }
2775                 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2776             }
2777         } else {
2778             for (i = 0; i < 2; i++) {
2779                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2780                                    0, 0, s->picture_structure != i + 1,
2781                                    ref_picture, pix_op,
2782                                    s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2783                                    2 * block_s, mb_y >> 1);
2784
2785                 // after put we make avg of the same block
2786                 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2787
2788                 // opposite parity is always in the same
2789                 // frame if this is second field
2790                 if (!s->first_field) {
2791                     ref_picture = s->current_picture_ptr->f->data;
2792                 }
2793             }
2794         }
2795         break;
2796     default:
2797         av_assert2(0);
2798     }
2799 }
2800
2801 /**
2802  * find the lowest MB row referenced in the MVs
2803  */
2804 int ff_mpv_lowest_referenced_row(MpegEncContext *s, int dir)
2805 {
2806     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2807     int my, off, i, mvs;
2808
2809     if (s->picture_structure != PICT_FRAME || s->mcsel)
2810         goto unhandled;
2811
2812     switch (s->mv_type) {
2813         case MV_TYPE_16X16:
2814             mvs = 1;
2815             break;
2816         case MV_TYPE_16X8:
2817             mvs = 2;
2818             break;
2819         case MV_TYPE_8X8:
2820             mvs = 4;
2821             break;
2822         default:
2823             goto unhandled;
2824     }
2825
2826     for (i = 0; i < mvs; i++) {
2827         my = s->mv[dir][i][1]<<qpel_shift;
2828         my_max = FFMAX(my_max, my);
2829         my_min = FFMIN(my_min, my);
2830     }
2831
2832     off = (FFMAX(-my_min, my_max) + 63) >> 6;
2833
2834     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2835 unhandled:
2836     return s->mb_height-1;
2837 }
2838
2839 /* put block[] to dest[] */
2840 static inline void put_dct(MpegEncContext *s,
2841                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2842 {
2843     s->dct_unquantize_intra(s, block, i, qscale);
2844     s->idsp.idct_put(dest, line_size, block);
2845 }
2846
2847 /* add block[] to dest[] */
2848 static inline void add_dct(MpegEncContext *s,
2849                            int16_t *block, int i, uint8_t *dest, int line_size)
2850 {
2851     if (s->block_last_index[i] >= 0) {
2852         s->idsp.idct_add(dest, line_size, block);
2853     }
2854 }
2855
2856 static inline void add_dequant_dct(MpegEncContext *s,
2857                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2858 {
2859     if (s->block_last_index[i] >= 0) {
2860         s->dct_unquantize_inter(s, block, i, qscale);
2861
2862         s->idsp.idct_add(dest, line_size, block);
2863     }
2864 }
2865
2866 /**
2867  * Clean dc, ac, coded_block for the current non-intra MB.
2868  */
2869 void ff_clean_intra_table_entries(MpegEncContext *s)
2870 {
2871     int wrap = s->b8_stride;
2872     int xy = s->block_index[0];
2873
2874     s->dc_val[0][xy           ] =
2875     s->dc_val[0][xy + 1       ] =
2876     s->dc_val[0][xy     + wrap] =
2877     s->dc_val[0][xy + 1 + wrap] = 1024;
2878     /* ac pred */
2879     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2880     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2881     if (s->msmpeg4_version>=3) {
2882         s->coded_block[xy           ] =
2883         s->coded_block[xy + 1       ] =
2884         s->coded_block[xy     + wrap] =
2885         s->coded_block[xy + 1 + wrap] = 0;
2886     }
2887     /* chroma */
2888     wrap = s->mb_stride;
2889     xy = s->mb_x + s->mb_y * wrap;
2890     s->dc_val[1][xy] =
2891     s->dc_val[2][xy] = 1024;
2892     /* ac pred */
2893     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2894     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2895
2896     s->mbintra_table[xy]= 0;
2897 }
2898
2899 /* generic function called after a macroblock has been parsed by the
2900    decoder or after it has been encoded by the encoder.
2901
2902    Important variables used:
2903    s->mb_intra : true if intra macroblock
2904    s->mv_dir   : motion vector direction
2905    s->mv_type  : motion vector type
2906    s->mv       : motion vector
2907    s->interlaced_dct : true if interlaced dct used (mpeg2)
2908  */
2909 static av_always_inline
2910 void mpv_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
2911                             int lowres_flag, int is_mpeg12)
2912 {
2913     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2914
2915     if (CONFIG_XVMC &&
2916         s->avctx->hwaccel && s->avctx->hwaccel->decode_mb) {
2917         s->avctx->hwaccel->decode_mb(s);//xvmc uses pblocks
2918         return;
2919     }
2920
2921     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2922        /* print DCT coefficients */
2923        int i,j;
2924        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2925        for(i=0; i<6; i++){
2926            for(j=0; j<64; j++){
2927                av_log(s->avctx, AV_LOG_DEBUG, "%5d",
2928                       block[i][s->idsp.idct_permutation[j]]);
2929            }
2930            av_log(s->avctx, AV_LOG_DEBUG, "\n");
2931        }
2932     }
2933
2934     s->current_picture.qscale_table[mb_xy] = s->qscale;
2935
2936     /* update DC predictors for P macroblocks */
2937     if (!s->mb_intra) {
2938         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2939             if(s->mbintra_table[mb_xy])
2940                 ff_clean_intra_table_entries(s);
2941         } else {
2942             s->last_dc[0] =
2943             s->last_dc[1] =
2944             s->last_dc[2] = 128 << s->intra_dc_precision;
2945         }
2946     }
2947     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2948         s->mbintra_table[mb_xy]=1;
2949
2950     if (   (s->flags&CODEC_FLAG_PSNR)
2951         || s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor
2952         || !(s->encoding && (s->intra_only || s->pict_type==AV_PICTURE_TYPE_B) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
2953         uint8_t *dest_y, *dest_cb, *dest_cr;
2954         int dct_linesize, dct_offset;
2955         op_pixels_func (*op_pix)[4];
2956         qpel_mc_func (*op_qpix)[16];
2957         const int linesize   = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
2958         const int uvlinesize = s->current_picture.f->linesize[1];
2959         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2960         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2961
2962         /* avoid copy if macroblock skipped in last frame too */
2963         /* skip only during decoding as we might trash the buffers during encoding a bit */
2964         if(!s->encoding){
2965             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2966
2967             if (s->mb_skipped) {
2968                 s->mb_skipped= 0;
2969                 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2970                 *mbskip_ptr = 1;
2971             } else if(!s->current_picture.reference) {
2972                 *mbskip_ptr = 1;
2973             } else{
2974                 *mbskip_ptr = 0; /* not skipped */
2975             }
2976         }
2977
2978         dct_linesize = linesize << s->interlaced_dct;
2979         dct_offset   = s->interlaced_dct ? linesize : linesize * block_size;
2980
2981         if(readable){
2982             dest_y=  s->dest[0];
2983             dest_cb= s->dest[1];
2984             dest_cr= s->dest[2];
2985         }else{
2986             dest_y = s->b_scratchpad;
2987             dest_cb= s->b_scratchpad+16*linesize;
2988             dest_cr= s->b_scratchpad+32*linesize;
2989         }
2990
2991         if (!s->mb_intra) {
2992             /* motion handling */
2993             /* decoding or more than one mb_type (MC was already done otherwise) */
2994             if(!s->encoding){
2995
2996                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2997                     if (s->mv_dir & MV_DIR_FORWARD) {
2998                         ff_thread_await_progress(&s->last_picture_ptr->tf,
2999                                                  ff_mpv_lowest_referenced_row(s, 0),
3000                                                  0);
3001                     }
3002                     if (s->mv_dir & MV_DIR_BACKWARD) {
3003                         ff_thread_await_progress(&s->next_picture_ptr->tf,
3004                                                  ff_mpv_lowest_referenced_row(s, 1),
3005                                                  0);
3006                     }
3007                 }
3008
3009                 if(lowres_flag){
3010                     h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
3011
3012                     if (s->mv_dir & MV_DIR_FORWARD) {
3013                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix);
3014                         op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
3015                     }
3016                     if (s->mv_dir & MV_DIR_BACKWARD) {
3017                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix);
3018                     }
3019                 }else{
3020                     op_qpix = s->me.qpel_put;
3021                     if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
3022                         op_pix = s->hdsp.put_pixels_tab;
3023                     }else{
3024                         op_pix = s->hdsp.put_no_rnd_pixels_tab;
3025                     }
3026                     if (s->mv_dir & MV_DIR_FORWARD) {
3027                         ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
3028                         op_pix = s->hdsp.avg_pixels_tab;
3029                         op_qpix= s->me.qpel_avg;
3030                     }
3031                     if (s->mv_dir & MV_DIR_BACKWARD) {
3032                         ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
3033                     }
3034                 }
3035             }
3036
3037             /* skip dequant / idct if we are really late ;) */
3038             if(s->avctx->skip_idct){
3039                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
3040                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
3041                    || s->avctx->skip_idct >= AVDISCARD_ALL)
3042                     goto skip_idct;
3043             }
3044
3045             /* add dct residue */
3046             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
3047                                 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
3048                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3049                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3050                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3051                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3052
3053                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
3054                     if (s->chroma_y_shift){
3055                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3056                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3057                     }else{
3058                         dct_linesize >>= 1;
3059                         dct_offset >>=1;
3060                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
3061                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
3062                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
3063                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
3064                     }
3065                 }
3066             } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
3067                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
3068                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
3069                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
3070                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3071
3072                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
3073                     if(s->chroma_y_shift){//Chroma420
3074                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
3075                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
3076                     }else{
3077                         //chroma422
3078                         dct_linesize = uvlinesize << s->interlaced_dct;
3079                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
3080
3081                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
3082                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
3083                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3084                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3085                         if(!s->chroma_x_shift){//Chroma444
3086                             add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
3087                             add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
3088                             add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
3089                             add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
3090                         }
3091                     }
3092                 }//fi gray
3093             }
3094             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
3095                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3096             }
3097         } else {
3098             /* dct only in intra block */
3099             if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
3100                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3101                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3102                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3103                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3104
3105                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
3106                     if(s->chroma_y_shift){
3107                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3108                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3109                     }else{
3110                         dct_offset >>=1;
3111                         dct_linesize >>=1;
3112                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
3113                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
3114                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
3115                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
3116                     }
3117                 }
3118             }else{
3119                 s->idsp.idct_put(dest_y,                           dct_linesize, block[0]);
3120                 s->idsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
3121                 s->idsp.idct_put(dest_y + dct_offset,              dct_linesize, block[2]);
3122                 s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3123
3124                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
3125                     if(s->chroma_y_shift){
3126                         s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
3127                         s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
3128                     }else{
3129
3130                         dct_linesize = uvlinesize << s->interlaced_dct;
3131                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
3132
3133                         s->idsp.idct_put(dest_cb,              dct_linesize, block[4]);
3134                         s->idsp.idct_put(dest_cr,              dct_linesize, block[5]);
3135                         s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3136                         s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3137                         if(!s->chroma_x_shift){//Chroma444
3138                             s->idsp.idct_put(dest_cb + block_size,              dct_linesize, block[8]);
3139                             s->idsp.idct_put(dest_cr + block_size,              dct_linesize, block[9]);
3140                             s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
3141                             s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
3142                         }
3143                     }
3144                 }//gray
3145             }
3146         }
3147 skip_idct:
3148         if(!readable){
3149             s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3150             s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3151             s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3152         }
3153     }
3154 }
3155
3156 void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64])
3157 {
3158 #if !CONFIG_SMALL
3159     if(s->out_format == FMT_MPEG1) {
3160         if(s->avctx->lowres) mpv_decode_mb_internal(s, block, 1, 1);
3161         else                 mpv_decode_mb_internal(s, block, 0, 1);
3162     } else
3163 #endif
3164     if(s->avctx->lowres) mpv_decode_mb_internal(s, block, 1, 0);
3165     else                  mpv_decode_mb_internal(s, block, 0, 0);
3166 }
3167
3168 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
3169 {
3170     ff_draw_horiz_band(s->avctx, s->current_picture_ptr->f,
3171                        s->last_picture_ptr ? s->last_picture_ptr->f : NULL, y, h, s->picture_structure,
3172                        s->first_field, s->low_delay);
3173 }
3174
3175 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3176     const int linesize   = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
3177     const int uvlinesize = s->current_picture.f->linesize[1];
3178     const int mb_size= 4 - s->avctx->lowres;
3179
3180     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3181     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3182     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3183     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3184     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3185     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;
3186     //block_index is not used by mpeg2, so it is not affected by chroma_format
3187
3188     s->dest[0] = s->current_picture.f->data[0] + ((s->mb_x - 1) <<  mb_size);
3189     s->dest[1] = s->current_picture.f->data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3190     s->dest[2] = s->current_picture.f->data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3191
3192     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3193     {
3194         if(s->picture_structure==PICT_FRAME){
3195         s->dest[0] += s->mb_y *   linesize << mb_size;
3196         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3197         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3198         }else{
3199             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
3200             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
3201             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
3202             av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
3203         }
3204     }
3205 }
3206
3207 /**
3208  * Permute an 8x8 block.
3209  * @param block the block which will be permuted according to the given permutation vector
3210  * @param permutation the permutation vector
3211  * @param last the last non zero coefficient in scantable order, used to speed the permutation up
3212  * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
3213  *                  (inverse) permutated to scantable order!
3214  */
3215 void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
3216 {
3217     int i;
3218     int16_t temp[64];
3219
3220     if(last<=0) return;
3221     //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
3222
3223     for(i=0; i<=last; i++){
3224         const int j= scantable[i];
3225         temp[j]= block[j];
3226         block[j]=0;
3227     }
3228
3229     for(i=0; i<=last; i++){
3230         const int j= scantable[i];
3231         const int perm_j= permutation[j];
3232         block[perm_j]= temp[j];
3233     }
3234 }
3235
3236 void ff_mpeg_flush(AVCodecContext *avctx){
3237     int i;
3238     MpegEncContext *s = avctx->priv_data;
3239
3240     if (!s || !s->picture)
3241         return;
3242
3243     for (i = 0; i < MAX_PICTURE_COUNT; i++)
3244         ff_mpeg_unref_picture(s, &s->picture[i]);
3245     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3246
3247     ff_mpeg_unref_picture(s, &s->current_picture);
3248     ff_mpeg_unref_picture(s, &s->last_picture);
3249     ff_mpeg_unref_picture(s, &s->next_picture);
3250
3251     s->mb_x= s->mb_y= 0;
3252     s->closed_gop= 0;
3253
3254     s->parse_context.state= -1;
3255     s->parse_context.frame_start_found= 0;
3256     s->parse_context.overread= 0;
3257     s->parse_context.overread_index= 0;
3258     s->parse_context.index= 0;
3259     s->parse_context.last_index= 0;
3260     s->bitstream_buffer_size=0;
3261     s->pp_time=0;
3262 }
3263
3264 /**
3265  * set qscale and update qscale dependent variables.
3266  */
3267 void ff_set_qscale(MpegEncContext * s, int qscale)
3268 {
3269     if (qscale < 1)
3270         qscale = 1;
3271     else if (qscale > 31)
3272         qscale = 31;
3273
3274     s->qscale = qscale;
3275     s->chroma_qscale= s->chroma_qscale_table[qscale];
3276
3277     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
3278     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
3279 }
3280
3281 void ff_mpv_report_decode_progress(MpegEncContext *s)
3282 {
3283     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
3284         ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
3285 }