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