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