mpegvideo: cosmetics: Lowercase ugly uppercase MPV_ function name prefixes
[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 Libav.
9  *
10  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24
25 /**
26  * @file
27  * The simplest mpeg encoder (well, it was the simplest!).
28  */
29
30 #include "libavutil/attributes.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/internal.h"
34 #include "libavutil/timer.h"
35 #include "avcodec.h"
36 #include "blockdsp.h"
37 #include "idctdsp.h"
38 #include "internal.h"
39 #include "mathops.h"
40 #include "mpegutils.h"
41 #include "mpegvideo.h"
42 #include "mjpegenc.h"
43 #include "msmpeg4.h"
44 #include "qpeldsp.h"
45 #include "xvmc_internal.h"
46 #include "thread.h"
47 #include <limits.h>
48
49 static const uint8_t ff_default_chroma_qscale_table[32] = {
50 //   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15
51      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
52     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
53 };
54
55 const uint8_t ff_mpeg1_dc_scale_table[128] = {
56 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
57     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
58     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
59     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
60     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
61     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
62     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
63     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
64     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
65 };
66
67 static const uint8_t mpeg2_dc_scale_table1[128] = {
68 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
69     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
70     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
71     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
72     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
73     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
74     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
75     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
76     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
77 };
78
79 static const uint8_t mpeg2_dc_scale_table2[128] = {
80 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
81     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
82     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
83     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
84     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
85     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
86     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
87     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
88     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
89 };
90
91 static const uint8_t mpeg2_dc_scale_table3[128] = {
92 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
93     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
94     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
95     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
96     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
97     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
98     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
99     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
100     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
101 };
102
103 const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
104     ff_mpeg1_dc_scale_table,
105     mpeg2_dc_scale_table1,
106     mpeg2_dc_scale_table2,
107     mpeg2_dc_scale_table3,
108 };
109
110 const uint8_t ff_alternate_horizontal_scan[64] = {
111      0,  1,  2,  3,  8,  9, 16, 17,
112     10, 11,  4,  5,  6,  7, 15, 14,
113     13, 12, 19, 18, 24, 25, 32, 33,
114     26, 27, 20, 21, 22, 23, 28, 29,
115     30, 31, 34, 35, 40, 41, 48, 49,
116     42, 43, 36, 37, 38, 39, 44, 45,
117     46, 47, 50, 51, 56, 57, 58, 59,
118     52, 53, 54, 55, 60, 61, 62, 63,
119 };
120
121 const uint8_t ff_alternate_vertical_scan[64] = {
122      0,  8, 16, 24,  1,  9,  2, 10,
123     17, 25, 32, 40, 48, 56, 57, 49,
124     41, 33, 26, 18,  3, 11,  4, 12,
125     19, 27, 34, 42, 50, 58, 35, 43,
126     51, 59, 20, 28,  5, 13,  6, 14,
127     21, 29, 36, 44, 52, 60, 37, 45,
128     53, 61, 22, 30,  7, 15, 23, 31,
129     38, 46, 54, 62, 39, 47, 55, 63,
130 };
131
132 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
133                                    int16_t *block, int n, int qscale)
134 {
135     int i, level, nCoeffs;
136     const uint16_t *quant_matrix;
137
138     nCoeffs= s->block_last_index[n];
139
140     if (n < 4)
141         block[0] = block[0] * s->y_dc_scale;
142     else
143         block[0] = block[0] * s->c_dc_scale;
144     /* XXX: only mpeg1 */
145     quant_matrix = s->intra_matrix;
146     for(i=1;i<=nCoeffs;i++) {
147         int j= s->intra_scantable.permutated[i];
148         level = block[j];
149         if (level) {
150             if (level < 0) {
151                 level = -level;
152                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
153                 level = (level - 1) | 1;
154                 level = -level;
155             } else {
156                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
157                 level = (level - 1) | 1;
158             }
159             block[j] = level;
160         }
161     }
162 }
163
164 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
165                                    int16_t *block, int n, int qscale)
166 {
167     int i, level, nCoeffs;
168     const uint16_t *quant_matrix;
169
170     nCoeffs= s->block_last_index[n];
171
172     quant_matrix = s->inter_matrix;
173     for(i=0; i<=nCoeffs; i++) {
174         int j= s->intra_scantable.permutated[i];
175         level = block[j];
176         if (level) {
177             if (level < 0) {
178                 level = -level;
179                 level = (((level << 1) + 1) * qscale *
180                          ((int) (quant_matrix[j]))) >> 4;
181                 level = (level - 1) | 1;
182                 level = -level;
183             } else {
184                 level = (((level << 1) + 1) * qscale *
185                          ((int) (quant_matrix[j]))) >> 4;
186                 level = (level - 1) | 1;
187             }
188             block[j] = level;
189         }
190     }
191 }
192
193 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
194                                    int16_t *block, int n, int qscale)
195 {
196     int i, level, nCoeffs;
197     const uint16_t *quant_matrix;
198
199     if(s->alternate_scan) nCoeffs= 63;
200     else nCoeffs= s->block_last_index[n];
201
202     if (n < 4)
203         block[0] = block[0] * s->y_dc_scale;
204     else
205         block[0] = block[0] * s->c_dc_scale;
206     quant_matrix = s->intra_matrix;
207     for(i=1;i<=nCoeffs;i++) {
208         int j= s->intra_scantable.permutated[i];
209         level = block[j];
210         if (level) {
211             if (level < 0) {
212                 level = -level;
213                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
214                 level = -level;
215             } else {
216                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
217             }
218             block[j] = level;
219         }
220     }
221 }
222
223 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
224                                    int16_t *block, int n, int qscale)
225 {
226     int i, level, nCoeffs;
227     const uint16_t *quant_matrix;
228     int sum=-1;
229
230     if(s->alternate_scan) nCoeffs= 63;
231     else nCoeffs= s->block_last_index[n];
232
233     if (n < 4)
234         block[0] = block[0] * s->y_dc_scale;
235     else
236         block[0] = block[0] * s->c_dc_scale;
237     quant_matrix = s->intra_matrix;
238     for(i=1;i<=nCoeffs;i++) {
239         int j= s->intra_scantable.permutated[i];
240         level = block[j];
241         if (level) {
242             if (level < 0) {
243                 level = -level;
244                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
245                 level = -level;
246             } else {
247                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
248             }
249             block[j] = level;
250             sum+=level;
251         }
252     }
253     block[63]^=sum&1;
254 }
255
256 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
257                                    int16_t *block, int n, int qscale)
258 {
259     int i, level, nCoeffs;
260     const uint16_t *quant_matrix;
261     int sum=-1;
262
263     if(s->alternate_scan) nCoeffs= 63;
264     else nCoeffs= s->block_last_index[n];
265
266     quant_matrix = s->inter_matrix;
267     for(i=0; i<=nCoeffs; i++) {
268         int j= s->intra_scantable.permutated[i];
269         level = block[j];
270         if (level) {
271             if (level < 0) {
272                 level = -level;
273                 level = (((level << 1) + 1) * qscale *
274                          ((int) (quant_matrix[j]))) >> 4;
275                 level = -level;
276             } else {
277                 level = (((level << 1) + 1) * qscale *
278                          ((int) (quant_matrix[j]))) >> 4;
279             }
280             block[j] = level;
281             sum+=level;
282         }
283     }
284     block[63]^=sum&1;
285 }
286
287 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
288                                   int16_t *block, int n, int qscale)
289 {
290     int i, level, qmul, qadd;
291     int nCoeffs;
292
293     assert(s->block_last_index[n]>=0);
294
295     qmul = qscale << 1;
296
297     if (!s->h263_aic) {
298         if (n < 4)
299             block[0] = block[0] * s->y_dc_scale;
300         else
301             block[0] = block[0] * s->c_dc_scale;
302         qadd = (qscale - 1) | 1;
303     }else{
304         qadd = 0;
305     }
306     if(s->ac_pred)
307         nCoeffs=63;
308     else
309         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
310
311     for(i=1; i<=nCoeffs; i++) {
312         level = block[i];
313         if (level) {
314             if (level < 0) {
315                 level = level * qmul - qadd;
316             } else {
317                 level = level * qmul + qadd;
318             }
319             block[i] = level;
320         }
321     }
322 }
323
324 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
325                                   int16_t *block, int n, int qscale)
326 {
327     int i, level, qmul, qadd;
328     int nCoeffs;
329
330     assert(s->block_last_index[n]>=0);
331
332     qadd = (qscale - 1) | 1;
333     qmul = qscale << 1;
334
335     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
336
337     for(i=0; i<=nCoeffs; i++) {
338         level = block[i];
339         if (level) {
340             if (level < 0) {
341                 level = level * qmul - qadd;
342             } else {
343                 level = level * qmul + qadd;
344             }
345             block[i] = level;
346         }
347     }
348 }
349
350 static void mpeg_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
351                               int (*mv)[2][4][2],
352                               int mb_x, int mb_y, int mb_intra, int mb_skipped)
353 {
354     MpegEncContext *s = opaque;
355
356     s->mv_dir     = mv_dir;
357     s->mv_type    = mv_type;
358     s->mb_intra   = mb_intra;
359     s->mb_skipped = mb_skipped;
360     s->mb_x       = mb_x;
361     s->mb_y       = mb_y;
362     memcpy(s->mv, mv, sizeof(*mv));
363
364     ff_init_block_index(s);
365     ff_update_block_index(s);
366
367     s->bdsp.clear_blocks(s->block[0]);
368
369     s->dest[0] = s->current_picture.f->data[0] + (s->mb_y *  16                       * s->linesize)   + s->mb_x *  16;
370     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);
371     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);
372
373     assert(ref == 0);
374     ff_mpv_decode_mb(s, s->block);
375 }
376
377 /* init common dct for both encoder and decoder */
378 static av_cold int dct_init(MpegEncContext *s)
379 {
380     ff_blockdsp_init(&s->bdsp, s->avctx);
381     ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
382     ff_me_cmp_init(&s->mecc, s->avctx);
383     ff_mpegvideodsp_init(&s->mdsp);
384     ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
385
386     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
387     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
388     s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
389     s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
390     s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
391     if (s->flags & CODEC_FLAG_BITEXACT)
392         s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
393     s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
394
395     if (HAVE_INTRINSICS_NEON)
396         ff_mpv_common_init_neon(s);
397
398     if (ARCH_ARM)
399         ff_mpv_common_init_arm(s);
400     if (ARCH_PPC)
401         ff_mpv_common_init_ppc(s);
402     if (ARCH_X86)
403         ff_mpv_common_init_x86(s);
404
405     return 0;
406 }
407
408 av_cold void ff_mpv_idct_init(MpegEncContext *s)
409 {
410     ff_idctdsp_init(&s->idsp, s->avctx);
411
412     /* load & permutate scantables
413      * note: only wmv uses different ones
414      */
415     if (s->alternate_scan) {
416         ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
417         ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
418     } else {
419         ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
420         ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
421     }
422     ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
423     ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
424 }
425
426 static int frame_size_alloc(MpegEncContext *s, int linesize)
427 {
428     int alloc_size = FFALIGN(FFABS(linesize) + 32, 32);
429
430     // edge emu needs blocksize + filter length - 1
431     // (= 17x17 for  halfpel / 21x21 for  h264)
432     // VC1 computes luma and chroma simultaneously and needs 19X19 + 9x9
433     // at uvlinesize. It supports only YUV420 so 24x24 is enough
434     // linesize * interlaced * MBsize
435     FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer, alloc_size * 2 * 24,
436                       fail);
437
438     FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad, alloc_size * 2 * 16 * 3,
439                       fail)
440     s->me.temp         = s->me.scratchpad;
441     s->rd_scratchpad   = s->me.scratchpad;
442     s->b_scratchpad    = s->me.scratchpad;
443     s->obmc_scratchpad = s->me.scratchpad + 16;
444
445     return 0;
446 fail:
447     av_freep(&s->edge_emu_buffer);
448     return AVERROR(ENOMEM);
449 }
450
451 /**
452  * Allocate a frame buffer
453  */
454 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
455 {
456     int edges_needed = av_codec_is_encoder(s->avctx->codec);
457     int r, ret;
458
459     pic->tf.f = pic->f;
460     if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
461         s->codec_id != AV_CODEC_ID_VC1IMAGE  &&
462         s->codec_id != AV_CODEC_ID_MSS2) {
463         if (edges_needed) {
464             pic->f->width  = s->avctx->width  + 2 * EDGE_WIDTH;
465             pic->f->height = s->avctx->height + 2 * EDGE_WIDTH;
466         }
467
468         r = ff_thread_get_buffer(s->avctx, &pic->tf,
469                                  pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
470     } else {
471         pic->f->width  = s->avctx->width;
472         pic->f->height = s->avctx->height;
473         pic->f->format = s->avctx->pix_fmt;
474         r = avcodec_default_get_buffer2(s->avctx, pic->f, 0);
475     }
476
477     if (r < 0 || !pic->f->buf[0]) {
478         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %p)\n",
479                r, pic->f->data[0]);
480         return -1;
481     }
482
483     if (edges_needed) {
484         int i;
485         for (i = 0; pic->f->data[i]; i++) {
486             int offset = (EDGE_WIDTH >> (i ? s->chroma_y_shift : 0)) *
487                          pic->f->linesize[i] +
488                          (EDGE_WIDTH >> (i ? s->chroma_x_shift : 0));
489             pic->f->data[i] += offset;
490         }
491         pic->f->width  = s->avctx->width;
492         pic->f->height = s->avctx->height;
493     }
494
495     if (s->avctx->hwaccel) {
496         assert(!pic->hwaccel_picture_private);
497         if (s->avctx->hwaccel->frame_priv_data_size) {
498             pic->hwaccel_priv_buf = av_buffer_allocz(s->avctx->hwaccel->frame_priv_data_size);
499             if (!pic->hwaccel_priv_buf) {
500                 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
501                 return -1;
502             }
503             pic->hwaccel_picture_private = pic->hwaccel_priv_buf->data;
504         }
505     }
506
507     if (s->linesize && (s->linesize   != pic->f->linesize[0] ||
508                         s->uvlinesize != pic->f->linesize[1])) {
509         av_log(s->avctx, AV_LOG_ERROR,
510                "get_buffer() failed (stride changed)\n");
511         ff_mpeg_unref_picture(s, pic);
512         return -1;
513     }
514
515     if (pic->f->linesize[1] != pic->f->linesize[2]) {
516         av_log(s->avctx, AV_LOG_ERROR,
517                "get_buffer() failed (uv stride mismatch)\n");
518         ff_mpeg_unref_picture(s, pic);
519         return -1;
520     }
521
522     if (!s->edge_emu_buffer &&
523         (ret = frame_size_alloc(s, pic->f->linesize[0])) < 0) {
524         av_log(s->avctx, AV_LOG_ERROR,
525                "get_buffer() failed to allocate context scratch buffers.\n");
526         ff_mpeg_unref_picture(s, pic);
527         return ret;
528     }
529
530     return 0;
531 }
532
533 void ff_free_picture_tables(Picture *pic)
534 {
535     int i;
536
537     av_buffer_unref(&pic->mb_var_buf);
538     av_buffer_unref(&pic->mc_mb_var_buf);
539     av_buffer_unref(&pic->mb_mean_buf);
540     av_buffer_unref(&pic->mbskip_table_buf);
541     av_buffer_unref(&pic->qscale_table_buf);
542     av_buffer_unref(&pic->mb_type_buf);
543
544     for (i = 0; i < 2; i++) {
545         av_buffer_unref(&pic->motion_val_buf[i]);
546         av_buffer_unref(&pic->ref_index_buf[i]);
547     }
548 }
549
550 static int alloc_picture_tables(MpegEncContext *s, Picture *pic)
551 {
552     const int big_mb_num    = s->mb_stride * (s->mb_height + 1) + 1;
553     const int mb_array_size = s->mb_stride * s->mb_height;
554     const int b8_array_size = s->b8_stride * s->mb_height * 2;
555     int i;
556
557
558     pic->mbskip_table_buf = av_buffer_allocz(mb_array_size + 2);
559     pic->qscale_table_buf = av_buffer_allocz(big_mb_num + s->mb_stride);
560     pic->mb_type_buf      = av_buffer_allocz((big_mb_num + s->mb_stride) *
561                                              sizeof(uint32_t));
562     if (!pic->mbskip_table_buf || !pic->qscale_table_buf || !pic->mb_type_buf)
563         return AVERROR(ENOMEM);
564
565     if (s->encoding) {
566         pic->mb_var_buf    = av_buffer_allocz(mb_array_size * sizeof(int16_t));
567         pic->mc_mb_var_buf = av_buffer_allocz(mb_array_size * sizeof(int16_t));
568         pic->mb_mean_buf   = av_buffer_allocz(mb_array_size);
569         if (!pic->mb_var_buf || !pic->mc_mb_var_buf || !pic->mb_mean_buf)
570             return AVERROR(ENOMEM);
571     }
572
573     if (s->out_format == FMT_H263 || s->encoding) {
574         int mv_size        = 2 * (b8_array_size + 4) * sizeof(int16_t);
575         int ref_index_size = 4 * mb_array_size;
576
577         for (i = 0; mv_size && i < 2; i++) {
578             pic->motion_val_buf[i] = av_buffer_allocz(mv_size);
579             pic->ref_index_buf[i]  = av_buffer_allocz(ref_index_size);
580             if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i])
581                 return AVERROR(ENOMEM);
582         }
583     }
584
585     return 0;
586 }
587
588 static int make_tables_writable(Picture *pic)
589 {
590     int ret, i;
591 #define MAKE_WRITABLE(table) \
592 do {\
593     if (pic->table &&\
594        (ret = av_buffer_make_writable(&pic->table)) < 0)\
595     return ret;\
596 } while (0)
597
598     MAKE_WRITABLE(mb_var_buf);
599     MAKE_WRITABLE(mc_mb_var_buf);
600     MAKE_WRITABLE(mb_mean_buf);
601     MAKE_WRITABLE(mbskip_table_buf);
602     MAKE_WRITABLE(qscale_table_buf);
603     MAKE_WRITABLE(mb_type_buf);
604
605     for (i = 0; i < 2; i++) {
606         MAKE_WRITABLE(motion_val_buf[i]);
607         MAKE_WRITABLE(ref_index_buf[i]);
608     }
609
610     return 0;
611 }
612
613 /**
614  * Allocate a Picture.
615  * The pixels are allocated/set by calling get_buffer() if shared = 0
616  */
617 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
618 {
619     int i, ret;
620
621     if (shared) {
622         assert(pic->f->data[0]);
623         pic->shared = 1;
624     } else {
625         assert(!pic->f->buf[0]);
626
627         if (alloc_frame_buffer(s, pic) < 0)
628             return -1;
629
630         s->linesize   = pic->f->linesize[0];
631         s->uvlinesize = pic->f->linesize[1];
632     }
633
634     if (!pic->qscale_table_buf)
635         ret = alloc_picture_tables(s, pic);
636     else
637         ret = make_tables_writable(pic);
638     if (ret < 0)
639         goto fail;
640
641     if (s->encoding) {
642         pic->mb_var    = (uint16_t*)pic->mb_var_buf->data;
643         pic->mc_mb_var = (uint16_t*)pic->mc_mb_var_buf->data;
644         pic->mb_mean   = pic->mb_mean_buf->data;
645     }
646
647     pic->mbskip_table = pic->mbskip_table_buf->data;
648     pic->qscale_table = pic->qscale_table_buf->data + 2 * s->mb_stride + 1;
649     pic->mb_type      = (uint32_t*)pic->mb_type_buf->data + 2 * s->mb_stride + 1;
650
651     if (pic->motion_val_buf[0]) {
652         for (i = 0; i < 2; i++) {
653             pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
654             pic->ref_index[i]  = pic->ref_index_buf[i]->data;
655         }
656     }
657
658     return 0;
659 fail:
660     av_log(s->avctx, AV_LOG_ERROR, "Error allocating a picture.\n");
661     ff_mpeg_unref_picture(s, pic);
662     ff_free_picture_tables(pic);
663     return AVERROR(ENOMEM);
664 }
665
666 /**
667  * Deallocate a picture.
668  */
669 void ff_mpeg_unref_picture(MpegEncContext *s, Picture *pic)
670 {
671     int off = offsetof(Picture, mb_mean) + sizeof(pic->mb_mean);
672
673     pic->tf.f = pic->f;
674     /* WM Image / Screen codecs allocate internal buffers with different
675      * dimensions / colorspaces; ignore user-defined callbacks for these. */
676     if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
677         s->codec_id != AV_CODEC_ID_VC1IMAGE  &&
678         s->codec_id != AV_CODEC_ID_MSS2)
679         ff_thread_release_buffer(s->avctx, &pic->tf);
680     else if (pic->f)
681         av_frame_unref(pic->f);
682
683     av_buffer_unref(&pic->hwaccel_priv_buf);
684
685     if (pic->needs_realloc)
686         ff_free_picture_tables(pic);
687
688     memset((uint8_t*)pic + off, 0, sizeof(*pic) - off);
689 }
690
691 static int update_picture_tables(Picture *dst, Picture *src)
692 {
693      int i;
694
695 #define UPDATE_TABLE(table)\
696 do {\
697     if (src->table &&\
698         (!dst->table || dst->table->buffer != src->table->buffer)) {\
699         av_buffer_unref(&dst->table);\
700         dst->table = av_buffer_ref(src->table);\
701         if (!dst->table) {\
702             ff_free_picture_tables(dst);\
703             return AVERROR(ENOMEM);\
704         }\
705     }\
706 } while (0)
707
708     UPDATE_TABLE(mb_var_buf);
709     UPDATE_TABLE(mc_mb_var_buf);
710     UPDATE_TABLE(mb_mean_buf);
711     UPDATE_TABLE(mbskip_table_buf);
712     UPDATE_TABLE(qscale_table_buf);
713     UPDATE_TABLE(mb_type_buf);
714     for (i = 0; i < 2; i++) {
715         UPDATE_TABLE(motion_val_buf[i]);
716         UPDATE_TABLE(ref_index_buf[i]);
717     }
718
719     dst->mb_var        = src->mb_var;
720     dst->mc_mb_var     = src->mc_mb_var;
721     dst->mb_mean       = src->mb_mean;
722     dst->mbskip_table  = src->mbskip_table;
723     dst->qscale_table  = src->qscale_table;
724     dst->mb_type       = src->mb_type;
725     for (i = 0; i < 2; i++) {
726         dst->motion_val[i] = src->motion_val[i];
727         dst->ref_index[i]  = src->ref_index[i];
728     }
729
730     return 0;
731 }
732
733 int ff_mpeg_ref_picture(MpegEncContext *s, Picture *dst, Picture *src)
734 {
735     int ret;
736
737     av_assert0(!dst->f->buf[0]);
738     av_assert0(src->f->buf[0]);
739
740     src->tf.f = src->f;
741     dst->tf.f = dst->f;
742     ret = ff_thread_ref_frame(&dst->tf, &src->tf);
743     if (ret < 0)
744         goto fail;
745
746     ret = update_picture_tables(dst, src);
747     if (ret < 0)
748         goto fail;
749
750     if (src->hwaccel_picture_private) {
751         dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
752         if (!dst->hwaccel_priv_buf)
753             goto fail;
754         dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
755     }
756
757     dst->field_picture           = src->field_picture;
758     dst->mb_var_sum              = src->mb_var_sum;
759     dst->mc_mb_var_sum           = src->mc_mb_var_sum;
760     dst->b_frame_score           = src->b_frame_score;
761     dst->needs_realloc           = src->needs_realloc;
762     dst->reference               = src->reference;
763     dst->shared                  = src->shared;
764
765     return 0;
766 fail:
767     ff_mpeg_unref_picture(s, dst);
768     return ret;
769 }
770
771 static void exchange_uv(MpegEncContext *s)
772 {
773     int16_t (*tmp)[64];
774
775     tmp           = s->pblocks[4];
776     s->pblocks[4] = s->pblocks[5];
777     s->pblocks[5] = tmp;
778 }
779
780 static int init_duplicate_context(MpegEncContext *s)
781 {
782     int y_size = s->b8_stride * (2 * s->mb_height + 1);
783     int c_size = s->mb_stride * (s->mb_height + 1);
784     int yc_size = y_size + 2 * c_size;
785     int i;
786
787     s->edge_emu_buffer =
788     s->me.scratchpad   =
789     s->me.temp         =
790     s->rd_scratchpad   =
791     s->b_scratchpad    =
792     s->obmc_scratchpad = NULL;
793
794     if (s->encoding) {
795         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
796                           ME_MAP_SIZE * sizeof(uint32_t), fail)
797         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
798                           ME_MAP_SIZE * sizeof(uint32_t), fail)
799         if (s->avctx->noise_reduction) {
800             FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
801                               2 * 64 * sizeof(int), fail)
802         }
803     }
804     FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(int16_t), fail)
805     s->block = s->blocks[0];
806
807     for (i = 0; i < 12; i++) {
808         s->pblocks[i] = &s->block[i];
809     }
810     if (s->avctx->codec_tag == AV_RL32("VCR2"))
811         exchange_uv(s);
812
813     if (s->out_format == FMT_H263) {
814         /* ac values */
815         FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
816                           yc_size * sizeof(int16_t) * 16, fail);
817         s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
818         s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
819         s->ac_val[2] = s->ac_val[1] + c_size;
820     }
821
822     return 0;
823 fail:
824     return -1; // free() through ff_mpv_common_end()
825 }
826
827 static void free_duplicate_context(MpegEncContext *s)
828 {
829     if (s == NULL)
830         return;
831
832     av_freep(&s->edge_emu_buffer);
833     av_freep(&s->me.scratchpad);
834     s->me.temp =
835     s->rd_scratchpad =
836     s->b_scratchpad =
837     s->obmc_scratchpad = NULL;
838
839     av_freep(&s->dct_error_sum);
840     av_freep(&s->me.map);
841     av_freep(&s->me.score_map);
842     av_freep(&s->blocks);
843     av_freep(&s->ac_val_base);
844     s->block = NULL;
845 }
846
847 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
848 {
849 #define COPY(a) bak->a = src->a
850     COPY(edge_emu_buffer);
851     COPY(me.scratchpad);
852     COPY(me.temp);
853     COPY(rd_scratchpad);
854     COPY(b_scratchpad);
855     COPY(obmc_scratchpad);
856     COPY(me.map);
857     COPY(me.score_map);
858     COPY(blocks);
859     COPY(block);
860     COPY(start_mb_y);
861     COPY(end_mb_y);
862     COPY(me.map_generation);
863     COPY(pb);
864     COPY(dct_error_sum);
865     COPY(dct_count[0]);
866     COPY(dct_count[1]);
867     COPY(ac_val_base);
868     COPY(ac_val[0]);
869     COPY(ac_val[1]);
870     COPY(ac_val[2]);
871 #undef COPY
872 }
873
874 int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
875 {
876     MpegEncContext bak;
877     int i, ret;
878     // FIXME copy only needed parts
879     // START_TIMER
880     backup_duplicate_context(&bak, dst);
881     memcpy(dst, src, sizeof(MpegEncContext));
882     backup_duplicate_context(dst, &bak);
883     for (i = 0; i < 12; i++) {
884         dst->pblocks[i] = &dst->block[i];
885     }
886     if (dst->avctx->codec_tag == AV_RL32("VCR2"))
887         exchange_uv(dst);
888     if (!dst->edge_emu_buffer &&
889         (ret = frame_size_alloc(dst, dst->linesize)) < 0) {
890         av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
891                "scratch buffers.\n");
892         return ret;
893     }
894     // STOP_TIMER("update_duplicate_context")
895     // about 10k cycles / 0.01 sec for  1000frames on 1ghz with 2 threads
896     return 0;
897 }
898
899 int ff_mpeg_update_thread_context(AVCodecContext *dst,
900                                   const AVCodecContext *src)
901 {
902     int i, ret;
903     MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
904
905     if (dst == src || !s1->context_initialized)
906         return 0;
907
908     // FIXME can parameters change on I-frames?
909     // in that case dst may need a reinit
910     if (!s->context_initialized) {
911         memcpy(s, s1, sizeof(MpegEncContext));
912
913         s->avctx                 = dst;
914         s->bitstream_buffer      = NULL;
915         s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
916
917         ff_mpv_idct_init(s);
918         ff_mpv_common_init(s);
919     }
920
921     if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
922         int err;
923         s->context_reinit = 0;
924         s->height = s1->height;
925         s->width  = s1->width;
926         if ((err = ff_mpv_common_frame_size_change(s)) < 0)
927             return err;
928     }
929
930     s->avctx->coded_height  = s1->avctx->coded_height;
931     s->avctx->coded_width   = s1->avctx->coded_width;
932     s->avctx->width         = s1->avctx->width;
933     s->avctx->height        = s1->avctx->height;
934
935     s->coded_picture_number = s1->coded_picture_number;
936     s->picture_number       = s1->picture_number;
937
938     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
939         ff_mpeg_unref_picture(s, &s->picture[i]);
940         if (s1->picture[i].f->buf[0] &&
941             (ret = ff_mpeg_ref_picture(s, &s->picture[i], &s1->picture[i])) < 0)
942             return ret;
943     }
944
945 #define UPDATE_PICTURE(pic)\
946 do {\
947     ff_mpeg_unref_picture(s, &s->pic);\
948     if (s1->pic.f->buf[0])\
949         ret = ff_mpeg_ref_picture(s, &s->pic, &s1->pic);\
950     else\
951         ret = update_picture_tables(&s->pic, &s1->pic);\
952     if (ret < 0)\
953         return ret;\
954 } while (0)
955
956     UPDATE_PICTURE(current_picture);
957     UPDATE_PICTURE(last_picture);
958     UPDATE_PICTURE(next_picture);
959
960     s->last_picture_ptr    = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
961     s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
962     s->next_picture_ptr    = REBASE_PICTURE(s1->next_picture_ptr,    s, s1);
963
964     // Error/bug resilience
965     s->next_p_frame_damaged = s1->next_p_frame_damaged;
966     s->workaround_bugs      = s1->workaround_bugs;
967
968     // MPEG4 timing info
969     memcpy(&s->last_time_base, &s1->last_time_base,
970            (char *) &s1->pb_field_time + sizeof(s1->pb_field_time) -
971            (char *) &s1->last_time_base);
972
973     // B-frame info
974     s->max_b_frames = s1->max_b_frames;
975     s->low_delay    = s1->low_delay;
976     s->droppable    = s1->droppable;
977
978     // DivX handling (doesn't work)
979     s->divx_packed  = s1->divx_packed;
980
981     if (s1->bitstream_buffer) {
982         if (s1->bitstream_buffer_size +
983             FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
984             av_fast_malloc(&s->bitstream_buffer,
985                            &s->allocated_bitstream_buffer_size,
986                            s1->allocated_bitstream_buffer_size);
987             s->bitstream_buffer_size = s1->bitstream_buffer_size;
988         memcpy(s->bitstream_buffer, s1->bitstream_buffer,
989                s1->bitstream_buffer_size);
990         memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
991                FF_INPUT_BUFFER_PADDING_SIZE);
992     }
993
994     // linesize dependend scratch buffer allocation
995     if (!s->edge_emu_buffer)
996         if (s1->linesize) {
997             if (frame_size_alloc(s, s1->linesize) < 0) {
998                 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
999                        "scratch buffers.\n");
1000                 return AVERROR(ENOMEM);
1001             }
1002         } else {
1003             av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
1004                    "be allocated due to unknown size.\n");
1005             return AVERROR_BUG;
1006         }
1007
1008     // MPEG2/interlacing info
1009     memcpy(&s->progressive_sequence, &s1->progressive_sequence,
1010            (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
1011
1012     if (!s1->first_field) {
1013         s->last_pict_type = s1->pict_type;
1014         if (s1->current_picture_ptr)
1015             s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f->quality;
1016     }
1017
1018     return 0;
1019 }
1020
1021 /**
1022  * Set the given MpegEncContext to common defaults
1023  * (same for encoding and decoding).
1024  * The changed fields will not depend upon the
1025  * prior state of the MpegEncContext.
1026  */
1027 void ff_mpv_common_defaults(MpegEncContext *s)
1028 {
1029     s->y_dc_scale_table      =
1030     s->c_dc_scale_table      = ff_mpeg1_dc_scale_table;
1031     s->chroma_qscale_table   = ff_default_chroma_qscale_table;
1032     s->progressive_frame     = 1;
1033     s->progressive_sequence  = 1;
1034     s->picture_structure     = PICT_FRAME;
1035
1036     s->coded_picture_number  = 0;
1037     s->picture_number        = 0;
1038
1039     s->f_code                = 1;
1040     s->b_code                = 1;
1041
1042     s->slice_context_count   = 1;
1043 }
1044
1045 /**
1046  * Set the given MpegEncContext to defaults for decoding.
1047  * the changed fields will not depend upon
1048  * the prior state of the MpegEncContext.
1049  */
1050 void ff_mpv_decode_defaults(MpegEncContext *s)
1051 {
1052     ff_mpv_common_defaults(s);
1053 }
1054
1055 static int init_er(MpegEncContext *s)
1056 {
1057     ERContext *er = &s->er;
1058     int mb_array_size = s->mb_height * s->mb_stride;
1059     int i;
1060
1061     er->avctx       = s->avctx;
1062     er->mecc        = &s->mecc;
1063
1064     er->mb_index2xy = s->mb_index2xy;
1065     er->mb_num      = s->mb_num;
1066     er->mb_width    = s->mb_width;
1067     er->mb_height   = s->mb_height;
1068     er->mb_stride   = s->mb_stride;
1069     er->b8_stride   = s->b8_stride;
1070
1071     er->er_temp_buffer     = av_malloc(s->mb_height * s->mb_stride);
1072     er->error_status_table = av_mallocz(mb_array_size);
1073     if (!er->er_temp_buffer || !er->error_status_table)
1074         goto fail;
1075
1076     er->mbskip_table  = s->mbskip_table;
1077     er->mbintra_table = s->mbintra_table;
1078
1079     for (i = 0; i < FF_ARRAY_ELEMS(s->dc_val); i++)
1080         er->dc_val[i] = s->dc_val[i];
1081
1082     er->decode_mb = mpeg_er_decode_mb;
1083     er->opaque    = s;
1084
1085     return 0;
1086 fail:
1087     av_freep(&er->er_temp_buffer);
1088     av_freep(&er->error_status_table);
1089     return AVERROR(ENOMEM);
1090 }
1091
1092 /**
1093  * Initialize and allocates MpegEncContext fields dependent on the resolution.
1094  */
1095 static int init_context_frame(MpegEncContext *s)
1096 {
1097     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
1098
1099     s->mb_width   = (s->width + 15) / 16;
1100     s->mb_stride  = s->mb_width + 1;
1101     s->b8_stride  = s->mb_width * 2 + 1;
1102     mb_array_size = s->mb_height * s->mb_stride;
1103     mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
1104
1105     /* set default edge pos, will be overriden
1106      * in decode_header if needed */
1107     s->h_edge_pos = s->mb_width * 16;
1108     s->v_edge_pos = s->mb_height * 16;
1109
1110     s->mb_num     = s->mb_width * s->mb_height;
1111
1112     s->block_wrap[0] =
1113     s->block_wrap[1] =
1114     s->block_wrap[2] =
1115     s->block_wrap[3] = s->b8_stride;
1116     s->block_wrap[4] =
1117     s->block_wrap[5] = s->mb_stride;
1118
1119     y_size  = s->b8_stride * (2 * s->mb_height + 1);
1120     c_size  = s->mb_stride * (s->mb_height + 1);
1121     yc_size = y_size + 2   * c_size;
1122
1123     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
1124                       fail); // error ressilience code looks cleaner with this
1125     for (y = 0; y < s->mb_height; y++)
1126         for (x = 0; x < s->mb_width; x++)
1127             s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
1128
1129     s->mb_index2xy[s->mb_height * s->mb_width] =
1130         (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
1131
1132     if (s->encoding) {
1133         /* Allocate MV tables */
1134         FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,
1135                           mv_table_size * 2 * sizeof(int16_t), fail);
1136         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,
1137                           mv_table_size * 2 * sizeof(int16_t), fail);
1138         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,
1139                           mv_table_size * 2 * sizeof(int16_t), fail);
1140         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,
1141                           mv_table_size * 2 * sizeof(int16_t), fail);
1142         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,
1143                           mv_table_size * 2 * sizeof(int16_t), fail);
1144         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,
1145                           mv_table_size * 2 * sizeof(int16_t), fail);
1146         s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;
1147         s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;
1148         s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;
1149         s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base +
1150                                    s->mb_stride + 1;
1151         s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base +
1152                                    s->mb_stride + 1;
1153         s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;
1154
1155         /* Allocate MB type table */
1156         FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size *
1157                           sizeof(uint16_t), fail); // needed for encoding
1158
1159         FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size *
1160                           sizeof(int), fail);
1161
1162         FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
1163                          mb_array_size * sizeof(float), fail);
1164         FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
1165                          mb_array_size * sizeof(float), fail);
1166
1167     }
1168
1169     if (s->codec_id == AV_CODEC_ID_MPEG4 ||
1170         (s->flags & CODEC_FLAG_INTERLACED_ME)) {
1171         /* interlaced direct mode decoding tables */
1172         for (i = 0; i < 2; i++) {
1173             int j, k;
1174             for (j = 0; j < 2; j++) {
1175                 for (k = 0; k < 2; k++) {
1176                     FF_ALLOCZ_OR_GOTO(s->avctx,
1177                                       s->b_field_mv_table_base[i][j][k],
1178                                       mv_table_size * 2 * sizeof(int16_t),
1179                                       fail);
1180                     s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
1181                                                    s->mb_stride + 1;
1182                 }
1183                 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j],
1184                                   mb_array_size * 2 * sizeof(uint8_t), fail);
1185                 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j],
1186                                   mv_table_size * 2 * sizeof(int16_t), fail);
1187                 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]
1188                                             + s->mb_stride + 1;
1189             }
1190             FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i],
1191                               mb_array_size * 2 * sizeof(uint8_t), fail);
1192         }
1193     }
1194     if (s->out_format == FMT_H263) {
1195         /* cbp values */
1196         FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
1197         s->coded_block = s->coded_block_base + s->b8_stride + 1;
1198
1199         /* cbp, ac_pred, pred_dir */
1200         FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table,
1201                           mb_array_size * sizeof(uint8_t), fail);
1202         FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table,
1203                           mb_array_size * sizeof(uint8_t), fail);
1204     }
1205
1206     if (s->h263_pred || s->h263_plus || !s->encoding) {
1207         /* dc values */
1208         // MN: we need these for  error resilience of intra-frames
1209         FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base,
1210                           yc_size * sizeof(int16_t), fail);
1211         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
1212         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
1213         s->dc_val[2] = s->dc_val[1] + c_size;
1214         for (i = 0; i < yc_size; i++)
1215             s->dc_val_base[i] = 1024;
1216     }
1217
1218     /* which mb is a intra block */
1219     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
1220     memset(s->mbintra_table, 1, mb_array_size);
1221
1222     /* init macroblock skip table */
1223     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
1224     // Note the + 1 is for  a quicker mpeg4 slice_end detection
1225
1226     return init_er(s);
1227 fail:
1228     return AVERROR(ENOMEM);
1229 }
1230
1231 /**
1232  * init common structure for both encoder and decoder.
1233  * this assumes that some variables like width/height are already set
1234  */
1235 av_cold int ff_mpv_common_init(MpegEncContext *s)
1236 {
1237     int i;
1238     int nb_slices = (HAVE_THREADS &&
1239                      s->avctx->active_thread_type & FF_THREAD_SLICE) ?
1240                     s->avctx->thread_count : 1;
1241
1242     if (s->encoding && s->avctx->slices)
1243         nb_slices = s->avctx->slices;
1244
1245     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1246         s->mb_height = (s->height + 31) / 32 * 2;
1247     else
1248         s->mb_height = (s->height + 15) / 16;
1249
1250     if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
1251         av_log(s->avctx, AV_LOG_ERROR,
1252                "decoding to AV_PIX_FMT_NONE is not supported.\n");
1253         return -1;
1254     }
1255
1256     if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
1257         int max_slices;
1258         if (s->mb_height)
1259             max_slices = FFMIN(MAX_THREADS, s->mb_height);
1260         else
1261             max_slices = MAX_THREADS;
1262         av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
1263                " reducing to %d\n", nb_slices, max_slices);
1264         nb_slices = max_slices;
1265     }
1266
1267     if ((s->width || s->height) &&
1268         av_image_check_size(s->width, s->height, 0, s->avctx))
1269         return -1;
1270
1271     dct_init(s);
1272
1273     s->flags  = s->avctx->flags;
1274     s->flags2 = s->avctx->flags2;
1275
1276     /* set chroma shifts */
1277     av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1278                                      &s->chroma_x_shift,
1279                                      &s->chroma_y_shift);
1280
1281     /* convert fourcc to upper case */
1282     s->codec_tag          = avpriv_toupper4(s->avctx->codec_tag);
1283
1284     s->stream_codec_tag   = avpriv_toupper4(s->avctx->stream_codec_tag);
1285
1286     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
1287                       MAX_PICTURE_COUNT * sizeof(Picture), fail);
1288     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1289         s->picture[i].f = av_frame_alloc();
1290         if (!s->picture[i].f)
1291             goto fail;
1292     }
1293     memset(&s->next_picture, 0, sizeof(s->next_picture));
1294     memset(&s->last_picture, 0, sizeof(s->last_picture));
1295     memset(&s->current_picture, 0, sizeof(s->current_picture));
1296     memset(&s->new_picture, 0, sizeof(s->new_picture));
1297     s->next_picture.f = av_frame_alloc();
1298     if (!s->next_picture.f)
1299         goto fail;
1300     s->last_picture.f = av_frame_alloc();
1301     if (!s->last_picture.f)
1302         goto fail;
1303     s->current_picture.f = av_frame_alloc();
1304     if (!s->current_picture.f)
1305         goto fail;
1306     s->new_picture.f = av_frame_alloc();
1307     if (!s->new_picture.f)
1308         goto fail;
1309
1310     if (s->width && s->height) {
1311         if (init_context_frame(s))
1312             goto fail;
1313
1314         s->parse_context.state = -1;
1315     }
1316
1317     s->context_initialized = 1;
1318     s->thread_context[0]   = s;
1319
1320     if (s->width && s->height) {
1321         if (nb_slices > 1) {
1322             for (i = 1; i < nb_slices; i++) {
1323                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1324                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1325             }
1326
1327             for (i = 0; i < nb_slices; i++) {
1328                 if (init_duplicate_context(s->thread_context[i]) < 0)
1329                     goto fail;
1330                     s->thread_context[i]->start_mb_y =
1331                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1332                     s->thread_context[i]->end_mb_y   =
1333                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1334             }
1335         } else {
1336             if (init_duplicate_context(s) < 0)
1337                 goto fail;
1338             s->start_mb_y = 0;
1339             s->end_mb_y   = s->mb_height;
1340         }
1341         s->slice_context_count = nb_slices;
1342     }
1343
1344     return 0;
1345  fail:
1346     ff_mpv_common_end(s);
1347     return -1;
1348 }
1349
1350 /**
1351  * Frees and resets MpegEncContext fields depending on the resolution.
1352  * Is used during resolution changes to avoid a full reinitialization of the
1353  * codec.
1354  */
1355 static int free_context_frame(MpegEncContext *s)
1356 {
1357     int i, j, k;
1358
1359     av_freep(&s->mb_type);
1360     av_freep(&s->p_mv_table_base);
1361     av_freep(&s->b_forw_mv_table_base);
1362     av_freep(&s->b_back_mv_table_base);
1363     av_freep(&s->b_bidir_forw_mv_table_base);
1364     av_freep(&s->b_bidir_back_mv_table_base);
1365     av_freep(&s->b_direct_mv_table_base);
1366     s->p_mv_table            = NULL;
1367     s->b_forw_mv_table       = NULL;
1368     s->b_back_mv_table       = NULL;
1369     s->b_bidir_forw_mv_table = NULL;
1370     s->b_bidir_back_mv_table = NULL;
1371     s->b_direct_mv_table     = NULL;
1372     for (i = 0; i < 2; i++) {
1373         for (j = 0; j < 2; j++) {
1374             for (k = 0; k < 2; k++) {
1375                 av_freep(&s->b_field_mv_table_base[i][j][k]);
1376                 s->b_field_mv_table[i][j][k] = NULL;
1377             }
1378             av_freep(&s->b_field_select_table[i][j]);
1379             av_freep(&s->p_field_mv_table_base[i][j]);
1380             s->p_field_mv_table[i][j] = NULL;
1381         }
1382         av_freep(&s->p_field_select_table[i]);
1383     }
1384
1385     av_freep(&s->dc_val_base);
1386     av_freep(&s->coded_block_base);
1387     av_freep(&s->mbintra_table);
1388     av_freep(&s->cbp_table);
1389     av_freep(&s->pred_dir_table);
1390
1391     av_freep(&s->mbskip_table);
1392
1393     av_freep(&s->er.error_status_table);
1394     av_freep(&s->er.er_temp_buffer);
1395     av_freep(&s->mb_index2xy);
1396     av_freep(&s->lambda_table);
1397     av_freep(&s->cplx_tab);
1398     av_freep(&s->bits_tab);
1399
1400     s->linesize = s->uvlinesize = 0;
1401
1402     return 0;
1403 }
1404
1405 int ff_mpv_common_frame_size_change(MpegEncContext *s)
1406 {
1407     int i, err = 0;
1408
1409     if (s->slice_context_count > 1) {
1410         for (i = 0; i < s->slice_context_count; i++) {
1411             free_duplicate_context(s->thread_context[i]);
1412         }
1413         for (i = 1; i < s->slice_context_count; i++) {
1414             av_freep(&s->thread_context[i]);
1415         }
1416     } else
1417         free_duplicate_context(s);
1418
1419     if ((err = free_context_frame(s)) < 0)
1420         return err;
1421
1422     if (s->picture)
1423         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1424                 s->picture[i].needs_realloc = 1;
1425         }
1426
1427     s->last_picture_ptr         =
1428     s->next_picture_ptr         =
1429     s->current_picture_ptr      = NULL;
1430
1431     // init
1432     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1433         s->mb_height = (s->height + 31) / 32 * 2;
1434     else
1435         s->mb_height = (s->height + 15) / 16;
1436
1437     if ((s->width || s->height) &&
1438         av_image_check_size(s->width, s->height, 0, s->avctx))
1439         return AVERROR_INVALIDDATA;
1440
1441     if ((err = init_context_frame(s)))
1442         goto fail;
1443
1444     s->thread_context[0]   = s;
1445
1446     if (s->width && s->height) {
1447         int nb_slices = s->slice_context_count;
1448         if (nb_slices > 1) {
1449             for (i = 1; i < nb_slices; i++) {
1450                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1451                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1452             }
1453
1454             for (i = 0; i < nb_slices; i++) {
1455                 if (init_duplicate_context(s->thread_context[i]) < 0)
1456                     goto fail;
1457                     s->thread_context[i]->start_mb_y =
1458                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1459                     s->thread_context[i]->end_mb_y   =
1460                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1461             }
1462         } else {
1463             if (init_duplicate_context(s) < 0)
1464                 goto fail;
1465             s->start_mb_y = 0;
1466             s->end_mb_y   = s->mb_height;
1467         }
1468         s->slice_context_count = nb_slices;
1469     }
1470
1471     return 0;
1472  fail:
1473     ff_mpv_common_end(s);
1474     return err;
1475 }
1476
1477 /* init common structure for both encoder and decoder */
1478 void ff_mpv_common_end(MpegEncContext *s)
1479 {
1480     int i;
1481
1482     if (s->slice_context_count > 1) {
1483         for (i = 0; i < s->slice_context_count; i++) {
1484             free_duplicate_context(s->thread_context[i]);
1485         }
1486         for (i = 1; i < s->slice_context_count; i++) {
1487             av_freep(&s->thread_context[i]);
1488         }
1489         s->slice_context_count = 1;
1490     } else free_duplicate_context(s);
1491
1492     av_freep(&s->parse_context.buffer);
1493     s->parse_context.buffer_size = 0;
1494
1495     av_freep(&s->bitstream_buffer);
1496     s->allocated_bitstream_buffer_size = 0;
1497
1498     if (s->picture) {
1499         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1500             ff_free_picture_tables(&s->picture[i]);
1501             ff_mpeg_unref_picture(s, &s->picture[i]);
1502             av_frame_free(&s->picture[i].f);
1503         }
1504     }
1505     av_freep(&s->picture);
1506     ff_free_picture_tables(&s->last_picture);
1507     ff_mpeg_unref_picture(s, &s->last_picture);
1508     av_frame_free(&s->last_picture.f);
1509     ff_free_picture_tables(&s->current_picture);
1510     ff_mpeg_unref_picture(s, &s->current_picture);
1511     av_frame_free(&s->current_picture.f);
1512     ff_free_picture_tables(&s->next_picture);
1513     ff_mpeg_unref_picture(s, &s->next_picture);
1514     av_frame_free(&s->next_picture.f);
1515     ff_free_picture_tables(&s->new_picture);
1516     ff_mpeg_unref_picture(s, &s->new_picture);
1517     av_frame_free(&s->new_picture.f);
1518
1519     free_context_frame(s);
1520
1521     s->context_initialized      = 0;
1522     s->last_picture_ptr         =
1523     s->next_picture_ptr         =
1524     s->current_picture_ptr      = NULL;
1525     s->linesize = s->uvlinesize = 0;
1526 }
1527
1528 av_cold void ff_init_rl(RLTable *rl,
1529                         uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1530 {
1531     int8_t  max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1532     uint8_t index_run[MAX_RUN + 1];
1533     int last, run, level, start, end, i;
1534
1535     /* If table is static, we can quit if rl->max_level[0] is not NULL */
1536     if (static_store && rl->max_level[0])
1537         return;
1538
1539     /* compute max_level[], max_run[] and index_run[] */
1540     for (last = 0; last < 2; last++) {
1541         if (last == 0) {
1542             start = 0;
1543             end = rl->last;
1544         } else {
1545             start = rl->last;
1546             end = rl->n;
1547         }
1548
1549         memset(max_level, 0, MAX_RUN + 1);
1550         memset(max_run, 0, MAX_LEVEL + 1);
1551         memset(index_run, rl->n, MAX_RUN + 1);
1552         for (i = start; i < end; i++) {
1553             run   = rl->table_run[i];
1554             level = rl->table_level[i];
1555             if (index_run[run] == rl->n)
1556                 index_run[run] = i;
1557             if (level > max_level[run])
1558                 max_level[run] = level;
1559             if (run > max_run[level])
1560                 max_run[level] = run;
1561         }
1562         if (static_store)
1563             rl->max_level[last] = static_store[last];
1564         else
1565             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1566         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1567         if (static_store)
1568             rl->max_run[last]   = static_store[last] + MAX_RUN + 1;
1569         else
1570             rl->max_run[last]   = av_malloc(MAX_LEVEL + 1);
1571         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1572         if (static_store)
1573             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1574         else
1575             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1576         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1577     }
1578 }
1579
1580 av_cold void ff_init_vlc_rl(RLTable *rl)
1581 {
1582     int i, q;
1583
1584     for (q = 0; q < 32; q++) {
1585         int qmul = q * 2;
1586         int qadd = (q - 1) | 1;
1587
1588         if (q == 0) {
1589             qmul = 1;
1590             qadd = 0;
1591         }
1592         for (i = 0; i < rl->vlc.table_size; i++) {
1593             int code = rl->vlc.table[i][0];
1594             int len  = rl->vlc.table[i][1];
1595             int level, run;
1596
1597             if (len == 0) { // illegal code
1598                 run   = 66;
1599                 level = MAX_LEVEL;
1600             } else if (len < 0) { // more bits needed
1601                 run   = 0;
1602                 level = code;
1603             } else {
1604                 if (code == rl->n) { // esc
1605                     run   = 66;
1606                     level =  0;
1607                 } else {
1608                     run   = rl->table_run[code] + 1;
1609                     level = rl->table_level[code] * qmul + qadd;
1610                     if (code >= rl->last) run += 192;
1611                 }
1612             }
1613             rl->rl_vlc[q][i].len   = len;
1614             rl->rl_vlc[q][i].level = level;
1615             rl->rl_vlc[q][i].run   = run;
1616         }
1617     }
1618 }
1619
1620 static void release_unused_pictures(MpegEncContext *s)
1621 {
1622     int i;
1623
1624     /* release non reference frames */
1625     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1626         if (!s->picture[i].reference)
1627             ff_mpeg_unref_picture(s, &s->picture[i]);
1628     }
1629 }
1630
1631 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1632 {
1633     if (pic->f->buf[0] == NULL)
1634         return 1;
1635     if (pic->needs_realloc && !(pic->reference & DELAYED_PIC_REF))
1636         return 1;
1637     return 0;
1638 }
1639
1640 static int find_unused_picture(MpegEncContext *s, int shared)
1641 {
1642     int i;
1643
1644     if (shared) {
1645         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1646             if (s->picture[i].f->buf[0] == NULL)
1647                 return i;
1648         }
1649     } else {
1650         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1651             if (pic_is_unused(s, &s->picture[i]))
1652                 return i;
1653         }
1654     }
1655
1656     return AVERROR_INVALIDDATA;
1657 }
1658
1659 int ff_find_unused_picture(MpegEncContext *s, int shared)
1660 {
1661     int ret = find_unused_picture(s, shared);
1662
1663     if (ret >= 0 && ret < MAX_PICTURE_COUNT) {
1664         if (s->picture[ret].needs_realloc) {
1665             s->picture[ret].needs_realloc = 0;
1666             ff_free_picture_tables(&s->picture[ret]);
1667             ff_mpeg_unref_picture(s, &s->picture[ret]);
1668         }
1669     }
1670     return ret;
1671 }
1672
1673 /**
1674  * generic function called after decoding
1675  * the header and before a frame is decoded.
1676  */
1677 int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1678 {
1679     int i, ret;
1680     Picture *pic;
1681     s->mb_skipped = 0;
1682
1683     /* mark & release old frames */
1684     if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1685         s->last_picture_ptr != s->next_picture_ptr &&
1686         s->last_picture_ptr->f->buf[0]) {
1687         ff_mpeg_unref_picture(s, s->last_picture_ptr);
1688     }
1689
1690     /* release forgotten pictures */
1691     /* if (mpeg124/h263) */
1692     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1693         if (&s->picture[i] != s->last_picture_ptr &&
1694             &s->picture[i] != s->next_picture_ptr &&
1695             s->picture[i].reference && !s->picture[i].needs_realloc) {
1696             if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1697                 av_log(avctx, AV_LOG_ERROR,
1698                        "releasing zombie picture\n");
1699             ff_mpeg_unref_picture(s, &s->picture[i]);
1700         }
1701     }
1702
1703     ff_mpeg_unref_picture(s, &s->current_picture);
1704
1705     release_unused_pictures(s);
1706
1707     if (s->current_picture_ptr &&
1708         s->current_picture_ptr->f->buf[0] == NULL) {
1709         // we already have a unused image
1710         // (maybe it was set before reading the header)
1711         pic = s->current_picture_ptr;
1712     } else {
1713         i   = ff_find_unused_picture(s, 0);
1714         if (i < 0) {
1715             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1716             return i;
1717         }
1718         pic = &s->picture[i];
1719     }
1720
1721     pic->reference = 0;
1722     if (!s->droppable) {
1723         if (s->pict_type != AV_PICTURE_TYPE_B)
1724             pic->reference = 3;
1725     }
1726
1727     pic->f->coded_picture_number = s->coded_picture_number++;
1728
1729     if (ff_alloc_picture(s, pic, 0) < 0)
1730         return -1;
1731
1732     s->current_picture_ptr = pic;
1733     // FIXME use only the vars from current_pic
1734     s->current_picture_ptr->f->top_field_first = s->top_field_first;
1735     if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1736         s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1737         if (s->picture_structure != PICT_FRAME)
1738             s->current_picture_ptr->f->top_field_first =
1739                 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1740     }
1741     s->current_picture_ptr->f->interlaced_frame = !s->progressive_frame &&
1742                                                  !s->progressive_sequence;
1743     s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
1744
1745     s->current_picture_ptr->f->pict_type = s->pict_type;
1746     // if (s->flags && CODEC_FLAG_QSCALE)
1747     //     s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1748     s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1749
1750     if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1751                                    s->current_picture_ptr)) < 0)
1752         return ret;
1753
1754     if (s->pict_type != AV_PICTURE_TYPE_B) {
1755         s->last_picture_ptr = s->next_picture_ptr;
1756         if (!s->droppable)
1757             s->next_picture_ptr = s->current_picture_ptr;
1758     }
1759     av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1760             s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1761             s->last_picture_ptr    ? s->last_picture_ptr->f->data[0]    : NULL,
1762             s->next_picture_ptr    ? s->next_picture_ptr->f->data[0]    : NULL,
1763             s->current_picture_ptr ? s->current_picture_ptr->f->data[0] : NULL,
1764             s->pict_type, s->droppable);
1765
1766     if ((s->last_picture_ptr == NULL ||
1767          s->last_picture_ptr->f->buf[0] == NULL) &&
1768         (s->pict_type != AV_PICTURE_TYPE_I ||
1769          s->picture_structure != PICT_FRAME)) {
1770         int h_chroma_shift, v_chroma_shift;
1771         av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1772                                          &h_chroma_shift, &v_chroma_shift);
1773         if (s->pict_type != AV_PICTURE_TYPE_I)
1774             av_log(avctx, AV_LOG_ERROR,
1775                    "warning: first frame is no keyframe\n");
1776         else if (s->picture_structure != PICT_FRAME)
1777             av_log(avctx, AV_LOG_INFO,
1778                    "allocate dummy last picture for field based first keyframe\n");
1779
1780         /* Allocate a dummy frame */
1781         i = ff_find_unused_picture(s, 0);
1782         if (i < 0) {
1783             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1784             return i;
1785         }
1786         s->last_picture_ptr = &s->picture[i];
1787
1788         s->last_picture_ptr->reference   = 3;
1789         s->last_picture_ptr->f->pict_type = AV_PICTURE_TYPE_I;
1790
1791         if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1792             s->last_picture_ptr = NULL;
1793             return -1;
1794         }
1795
1796         memset(s->last_picture_ptr->f->data[0], 0,
1797                avctx->height * s->last_picture_ptr->f->linesize[0]);
1798         memset(s->last_picture_ptr->f->data[1], 0x80,
1799                (avctx->height >> v_chroma_shift) *
1800                s->last_picture_ptr->f->linesize[1]);
1801         memset(s->last_picture_ptr->f->data[2], 0x80,
1802                (avctx->height >> v_chroma_shift) *
1803                s->last_picture_ptr->f->linesize[2]);
1804
1805         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1806         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1807     }
1808     if ((s->next_picture_ptr == NULL ||
1809          s->next_picture_ptr->f->buf[0] == NULL) &&
1810         s->pict_type == AV_PICTURE_TYPE_B) {
1811         /* Allocate a dummy frame */
1812         i = ff_find_unused_picture(s, 0);
1813         if (i < 0) {
1814             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1815             return i;
1816         }
1817         s->next_picture_ptr = &s->picture[i];
1818
1819         s->next_picture_ptr->reference   = 3;
1820         s->next_picture_ptr->f->pict_type = AV_PICTURE_TYPE_I;
1821
1822         if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1823             s->next_picture_ptr = NULL;
1824             return -1;
1825         }
1826         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1827         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1828     }
1829
1830     if (s->last_picture_ptr) {
1831         ff_mpeg_unref_picture(s, &s->last_picture);
1832         if (s->last_picture_ptr->f->buf[0] &&
1833             (ret = ff_mpeg_ref_picture(s, &s->last_picture,
1834                                        s->last_picture_ptr)) < 0)
1835             return ret;
1836     }
1837     if (s->next_picture_ptr) {
1838         ff_mpeg_unref_picture(s, &s->next_picture);
1839         if (s->next_picture_ptr->f->buf[0] &&
1840             (ret = ff_mpeg_ref_picture(s, &s->next_picture,
1841                                        s->next_picture_ptr)) < 0)
1842             return ret;
1843     }
1844
1845     if (s->pict_type != AV_PICTURE_TYPE_I &&
1846         !(s->last_picture_ptr && s->last_picture_ptr->f->buf[0])) {
1847         av_log(s, AV_LOG_ERROR,
1848                "Non-reference picture received and no reference available\n");
1849         return AVERROR_INVALIDDATA;
1850     }
1851
1852     if (s->picture_structure!= PICT_FRAME) {
1853         int i;
1854         for (i = 0; i < 4; i++) {
1855             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1856                 s->current_picture.f->data[i] +=
1857                     s->current_picture.f->linesize[i];
1858             }
1859             s->current_picture.f->linesize[i] *= 2;
1860             s->last_picture.f->linesize[i]    *= 2;
1861             s->next_picture.f->linesize[i]    *= 2;
1862         }
1863     }
1864
1865     s->err_recognition = avctx->err_recognition;
1866
1867     /* set dequantizer, we can't do it during init as
1868      * it might change for mpeg4 and we can't do it in the header
1869      * decode as init is not called for mpeg4 there yet */
1870     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1871         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1872         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1873     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1874         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1875         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1876     } else {
1877         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1878         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1879     }
1880
1881 #if FF_API_XVMC
1882 FF_DISABLE_DEPRECATION_WARNINGS
1883     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1884         return ff_xvmc_field_start(s, avctx);
1885 FF_ENABLE_DEPRECATION_WARNINGS
1886 #endif /* FF_API_XVMC */
1887
1888     return 0;
1889 }
1890
1891 /* called after a frame has been decoded. */
1892 void ff_mpv_frame_end(MpegEncContext *s)
1893 {
1894 #if FF_API_XVMC
1895 FF_DISABLE_DEPRECATION_WARNINGS
1896     /* redraw edges for the frame if decoding didn't complete */
1897     // just to make sure that all data is rendered.
1898     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1899         ff_xvmc_field_end(s);
1900     } else
1901 FF_ENABLE_DEPRECATION_WARNINGS
1902 #endif /* FF_API_XVMC */
1903
1904     emms_c();
1905
1906     if (s->current_picture.reference)
1907         ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1908 }
1909
1910 /**
1911  * Print debugging info for the given picture.
1912  */
1913 void ff_print_debug_info(MpegEncContext *s, Picture *p)
1914 {
1915     AVFrame *pict;
1916     if (s->avctx->hwaccel || !p || !p->mb_type)
1917         return;
1918     pict = p->f;
1919
1920     if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1921         int x,y;
1922
1923         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1924         switch (pict->pict_type) {
1925         case AV_PICTURE_TYPE_I:
1926             av_log(s->avctx,AV_LOG_DEBUG,"I\n");
1927             break;
1928         case AV_PICTURE_TYPE_P:
1929             av_log(s->avctx,AV_LOG_DEBUG,"P\n");
1930             break;
1931         case AV_PICTURE_TYPE_B:
1932             av_log(s->avctx,AV_LOG_DEBUG,"B\n");
1933             break;
1934         case AV_PICTURE_TYPE_S:
1935             av_log(s->avctx,AV_LOG_DEBUG,"S\n");
1936             break;
1937         case AV_PICTURE_TYPE_SI:
1938             av_log(s->avctx,AV_LOG_DEBUG,"SI\n");
1939             break;
1940         case AV_PICTURE_TYPE_SP:
1941             av_log(s->avctx,AV_LOG_DEBUG,"SP\n");
1942             break;
1943         }
1944         for (y = 0; y < s->mb_height; y++) {
1945             for (x = 0; x < s->mb_width; x++) {
1946                 if (s->avctx->debug & FF_DEBUG_SKIP) {
1947                     int count = s->mbskip_table[x + y * s->mb_stride];
1948                     if (count > 9)
1949                         count = 9;
1950                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1951                 }
1952                 if (s->avctx->debug & FF_DEBUG_QP) {
1953                     av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1954                            p->qscale_table[x + y * s->mb_stride]);
1955                 }
1956                 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1957                     int mb_type = p->mb_type[x + y * s->mb_stride];
1958                     // Type & MV direction
1959                     if (IS_PCM(mb_type))
1960                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1961                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1962                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1963                     else if (IS_INTRA4x4(mb_type))
1964                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1965                     else if (IS_INTRA16x16(mb_type))
1966                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1967                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1968                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1969                     else if (IS_DIRECT(mb_type))
1970                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1971                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1972                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1973                     else if (IS_GMC(mb_type))
1974                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1975                     else if (IS_SKIP(mb_type))
1976                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1977                     else if (!USES_LIST(mb_type, 1))
1978                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1979                     else if (!USES_LIST(mb_type, 0))
1980                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1981                     else {
1982                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1983                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1984                     }
1985
1986                     // segmentation
1987                     if (IS_8X8(mb_type))
1988                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1989                     else if (IS_16X8(mb_type))
1990                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1991                     else if (IS_8X16(mb_type))
1992                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1993                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1994                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1995                     else
1996                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1997
1998
1999                     if (IS_INTERLACED(mb_type))
2000                         av_log(s->avctx, AV_LOG_DEBUG, "=");
2001                     else
2002                         av_log(s->avctx, AV_LOG_DEBUG, " ");
2003                 }
2004             }
2005             av_log(s->avctx, AV_LOG_DEBUG, "\n");
2006         }
2007     }
2008 }
2009
2010 /**
2011  * find the lowest MB row referenced in the MVs
2012  */
2013 int ff_mpv_lowest_referenced_row(MpegEncContext *s, int dir)
2014 {
2015     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2016     int my, off, i, mvs;
2017
2018     if (s->picture_structure != PICT_FRAME || s->mcsel)
2019         goto unhandled;
2020
2021     switch (s->mv_type) {
2022         case MV_TYPE_16X16:
2023             mvs = 1;
2024             break;
2025         case MV_TYPE_16X8:
2026             mvs = 2;
2027             break;
2028         case MV_TYPE_8X8:
2029             mvs = 4;
2030             break;
2031         default:
2032             goto unhandled;
2033     }
2034
2035     for (i = 0; i < mvs; i++) {
2036         my = s->mv[dir][i][1]<<qpel_shift;
2037         my_max = FFMAX(my_max, my);
2038         my_min = FFMIN(my_min, my);
2039     }
2040
2041     off = (FFMAX(-my_min, my_max) + 63) >> 6;
2042
2043     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2044 unhandled:
2045     return s->mb_height-1;
2046 }
2047
2048 /* put block[] to dest[] */
2049 static inline void put_dct(MpegEncContext *s,
2050                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2051 {
2052     s->dct_unquantize_intra(s, block, i, qscale);
2053     s->idsp.idct_put(dest, line_size, block);
2054 }
2055
2056 /* add block[] to dest[] */
2057 static inline void add_dct(MpegEncContext *s,
2058                            int16_t *block, int i, uint8_t *dest, int line_size)
2059 {
2060     if (s->block_last_index[i] >= 0) {
2061         s->idsp.idct_add(dest, line_size, block);
2062     }
2063 }
2064
2065 static inline void add_dequant_dct(MpegEncContext *s,
2066                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2067 {
2068     if (s->block_last_index[i] >= 0) {
2069         s->dct_unquantize_inter(s, block, i, qscale);
2070
2071         s->idsp.idct_add(dest, line_size, block);
2072     }
2073 }
2074
2075 /**
2076  * Clean dc, ac, coded_block for the current non-intra MB.
2077  */
2078 void ff_clean_intra_table_entries(MpegEncContext *s)
2079 {
2080     int wrap = s->b8_stride;
2081     int xy = s->block_index[0];
2082
2083     s->dc_val[0][xy           ] =
2084     s->dc_val[0][xy + 1       ] =
2085     s->dc_val[0][xy     + wrap] =
2086     s->dc_val[0][xy + 1 + wrap] = 1024;
2087     /* ac pred */
2088     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2089     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2090     if (s->msmpeg4_version>=3) {
2091         s->coded_block[xy           ] =
2092         s->coded_block[xy + 1       ] =
2093         s->coded_block[xy     + wrap] =
2094         s->coded_block[xy + 1 + wrap] = 0;
2095     }
2096     /* chroma */
2097     wrap = s->mb_stride;
2098     xy = s->mb_x + s->mb_y * wrap;
2099     s->dc_val[1][xy] =
2100     s->dc_val[2][xy] = 1024;
2101     /* ac pred */
2102     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2103     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2104
2105     s->mbintra_table[xy]= 0;
2106 }
2107
2108 /* generic function called after a macroblock has been parsed by the
2109    decoder or after it has been encoded by the encoder.
2110
2111    Important variables used:
2112    s->mb_intra : true if intra macroblock
2113    s->mv_dir   : motion vector direction
2114    s->mv_type  : motion vector type
2115    s->mv       : motion vector
2116    s->interlaced_dct : true if interlaced dct used (mpeg2)
2117  */
2118 static av_always_inline
2119 void mpv_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
2120                             int is_mpeg12)
2121 {
2122     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2123
2124 #if FF_API_XVMC
2125 FF_DISABLE_DEPRECATION_WARNINGS
2126     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2127         ff_xvmc_decode_mb(s);//xvmc uses pblocks
2128         return;
2129     }
2130 FF_ENABLE_DEPRECATION_WARNINGS
2131 #endif /* FF_API_XVMC */
2132
2133     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2134        /* print DCT coefficients */
2135        int i,j;
2136        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2137        for(i=0; i<6; i++){
2138            for(j=0; j<64; j++){
2139                av_log(s->avctx, AV_LOG_DEBUG, "%5d",
2140                       block[i][s->idsp.idct_permutation[j]]);
2141            }
2142            av_log(s->avctx, AV_LOG_DEBUG, "\n");
2143        }
2144     }
2145
2146     s->current_picture.qscale_table[mb_xy] = s->qscale;
2147
2148     /* update DC predictors for P macroblocks */
2149     if (!s->mb_intra) {
2150         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2151             if(s->mbintra_table[mb_xy])
2152                 ff_clean_intra_table_entries(s);
2153         } else {
2154             s->last_dc[0] =
2155             s->last_dc[1] =
2156             s->last_dc[2] = 128 << s->intra_dc_precision;
2157         }
2158     }
2159     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2160         s->mbintra_table[mb_xy]=1;
2161
2162     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==AV_PICTURE_TYPE_B) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
2163         uint8_t *dest_y, *dest_cb, *dest_cr;
2164         int dct_linesize, dct_offset;
2165         op_pixels_func (*op_pix)[4];
2166         qpel_mc_func (*op_qpix)[16];
2167         const int linesize   = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
2168         const int uvlinesize = s->current_picture.f->linesize[1];
2169         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band;
2170         const int block_size = 8;
2171
2172         /* avoid copy if macroblock skipped in last frame too */
2173         /* skip only during decoding as we might trash the buffers during encoding a bit */
2174         if(!s->encoding){
2175             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2176
2177             if (s->mb_skipped) {
2178                 s->mb_skipped= 0;
2179                 assert(s->pict_type!=AV_PICTURE_TYPE_I);
2180                 *mbskip_ptr = 1;
2181             } else if(!s->current_picture.reference) {
2182                 *mbskip_ptr = 1;
2183             } else{
2184                 *mbskip_ptr = 0; /* not skipped */
2185             }
2186         }
2187
2188         dct_linesize = linesize << s->interlaced_dct;
2189         dct_offset   = s->interlaced_dct ? linesize : linesize * block_size;
2190
2191         if(readable){
2192             dest_y=  s->dest[0];
2193             dest_cb= s->dest[1];
2194             dest_cr= s->dest[2];
2195         }else{
2196             dest_y = s->b_scratchpad;
2197             dest_cb= s->b_scratchpad+16*linesize;
2198             dest_cr= s->b_scratchpad+32*linesize;
2199         }
2200
2201         if (!s->mb_intra) {
2202             /* motion handling */
2203             /* decoding or more than one mb_type (MC was already done otherwise) */
2204             if(!s->encoding){
2205
2206                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2207                     if (s->mv_dir & MV_DIR_FORWARD) {
2208                         ff_thread_await_progress(&s->last_picture_ptr->tf,
2209                                                  ff_mpv_lowest_referenced_row(s, 0),
2210                                                  0);
2211                     }
2212                     if (s->mv_dir & MV_DIR_BACKWARD) {
2213                         ff_thread_await_progress(&s->next_picture_ptr->tf,
2214                                                  ff_mpv_lowest_referenced_row(s, 1),
2215                                                  0);
2216                     }
2217                 }
2218
2219                 op_qpix= s->me.qpel_put;
2220                 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2221                     op_pix = s->hdsp.put_pixels_tab;
2222                 }else{
2223                     op_pix = s->hdsp.put_no_rnd_pixels_tab;
2224                 }
2225                 if (s->mv_dir & MV_DIR_FORWARD) {
2226                     ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
2227                     op_pix = s->hdsp.avg_pixels_tab;
2228                     op_qpix= s->me.qpel_avg;
2229                 }
2230                 if (s->mv_dir & MV_DIR_BACKWARD) {
2231                     ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
2232                 }
2233             }
2234
2235             /* skip dequant / idct if we are really late ;) */
2236             if(s->avctx->skip_idct){
2237                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2238                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2239                    || s->avctx->skip_idct >= AVDISCARD_ALL)
2240                     goto skip_idct;
2241             }
2242
2243             /* add dct residue */
2244             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2245                                 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2246                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2247                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2248                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2249                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2250
2251                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2252                     if (s->chroma_y_shift){
2253                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2254                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2255                     }else{
2256                         dct_linesize >>= 1;
2257                         dct_offset >>=1;
2258                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2259                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2260                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2261                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2262                     }
2263                 }
2264             } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2265                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2266                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2267                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2268                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2269
2270                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2271                     if(s->chroma_y_shift){//Chroma420
2272                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
2273                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
2274                     }else{
2275                         //chroma422
2276                         dct_linesize = uvlinesize << s->interlaced_dct;
2277                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize * 8;
2278
2279                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
2280                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
2281                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2282                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2283                         if(!s->chroma_x_shift){//Chroma444
2284                             add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2285                             add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2286                             add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2287                             add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2288                         }
2289                     }
2290                 }//fi gray
2291             }
2292             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2293                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2294             }
2295         } else {
2296             /* dct only in intra block */
2297             if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2298                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2299                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2300                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2301                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2302
2303                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2304                     if(s->chroma_y_shift){
2305                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2306                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2307                     }else{
2308                         dct_offset >>=1;
2309                         dct_linesize >>=1;
2310                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2311                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2312                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2313                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2314                     }
2315                 }
2316             }else{
2317                 s->idsp.idct_put(dest_y,                           dct_linesize, block[0]);
2318                 s->idsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2319                 s->idsp.idct_put(dest_y + dct_offset,              dct_linesize, block[2]);
2320                 s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2321
2322                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2323                     if(s->chroma_y_shift){
2324                         s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
2325                         s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
2326                     }else{
2327
2328                         dct_linesize = uvlinesize << s->interlaced_dct;
2329                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize * 8;
2330
2331                         s->idsp.idct_put(dest_cb,              dct_linesize, block[4]);
2332                         s->idsp.idct_put(dest_cr,              dct_linesize, block[5]);
2333                         s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2334                         s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2335                         if(!s->chroma_x_shift){//Chroma444
2336                             s->idsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
2337                             s->idsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
2338                             s->idsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2339                             s->idsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2340                         }
2341                     }
2342                 }//gray
2343             }
2344         }
2345 skip_idct:
2346         if(!readable){
2347             s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2348             s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2349             s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2350         }
2351     }
2352 }
2353
2354 void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64])
2355 {
2356 #if !CONFIG_SMALL
2357     if(s->out_format == FMT_MPEG1) {
2358         mpv_decode_mb_internal(s, block, 1);
2359     } else
2360 #endif
2361         mpv_decode_mb_internal(s, block, 0);
2362 }
2363
2364 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
2365 {
2366     ff_draw_horiz_band(s->avctx, s->current_picture.f,
2367                        s->last_picture.f, y, h, s->picture_structure,
2368                        s->first_field, s->low_delay);
2369 }
2370
2371 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2372     const int linesize   = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
2373     const int uvlinesize = s->current_picture.f->linesize[1];
2374     const int mb_size= 4;
2375
2376     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2377     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2378     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2379     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2380     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2381     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;
2382     //block_index is not used by mpeg2, so it is not affected by chroma_format
2383
2384     s->dest[0] = s->current_picture.f->data[0] + ((s->mb_x - 1) <<  mb_size);
2385     s->dest[1] = s->current_picture.f->data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2386     s->dest[2] = s->current_picture.f->data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2387
2388     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2389     {
2390         if(s->picture_structure==PICT_FRAME){
2391         s->dest[0] += s->mb_y *   linesize << mb_size;
2392         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2393         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2394         }else{
2395             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2396             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2397             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2398             assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2399         }
2400     }
2401 }
2402
2403 /**
2404  * Permute an 8x8 block.
2405  * @param block the block which will be permuted according to the given permutation vector
2406  * @param permutation the permutation vector
2407  * @param last the last non zero coefficient in scantable order, used to speed the permutation up
2408  * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
2409  *                  (inverse) permutated to scantable order!
2410  */
2411 void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
2412 {
2413     int i;
2414     int16_t temp[64];
2415
2416     if(last<=0) return;
2417     //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
2418
2419     for(i=0; i<=last; i++){
2420         const int j= scantable[i];
2421         temp[j]= block[j];
2422         block[j]=0;
2423     }
2424
2425     for(i=0; i<=last; i++){
2426         const int j= scantable[i];
2427         const int perm_j= permutation[j];
2428         block[perm_j]= temp[j];
2429     }
2430 }
2431
2432 void ff_mpeg_flush(AVCodecContext *avctx){
2433     int i;
2434     MpegEncContext *s = avctx->priv_data;
2435
2436     if(s==NULL || s->picture==NULL)
2437         return;
2438
2439     for (i = 0; i < MAX_PICTURE_COUNT; i++)
2440         ff_mpeg_unref_picture(s, &s->picture[i]);
2441     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2442
2443     ff_mpeg_unref_picture(s, &s->current_picture);
2444     ff_mpeg_unref_picture(s, &s->last_picture);
2445     ff_mpeg_unref_picture(s, &s->next_picture);
2446
2447     s->mb_x= s->mb_y= 0;
2448
2449     s->parse_context.state= -1;
2450     s->parse_context.frame_start_found= 0;
2451     s->parse_context.overread= 0;
2452     s->parse_context.overread_index= 0;
2453     s->parse_context.index= 0;
2454     s->parse_context.last_index= 0;
2455     s->bitstream_buffer_size=0;
2456     s->pp_time=0;
2457 }
2458
2459 /**
2460  * set qscale and update qscale dependent variables.
2461  */
2462 void ff_set_qscale(MpegEncContext * s, int qscale)
2463 {
2464     if (qscale < 1)
2465         qscale = 1;
2466     else if (qscale > 31)
2467         qscale = 31;
2468
2469     s->qscale = qscale;
2470     s->chroma_qscale= s->chroma_qscale_table[qscale];
2471
2472     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2473     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2474 }
2475
2476 void ff_mpv_report_decode_progress(MpegEncContext *s)
2477 {
2478     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
2479         ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
2480 }