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