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