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