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