mpegvideo: replace assert about interlaced EC with debug av_log()
[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 int 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     return 0;
1407 }
1408
1409 int ff_mpv_common_frame_size_change(MpegEncContext *s)
1410 {
1411     int i, err = 0;
1412
1413     if (s->slice_context_count > 1) {
1414         for (i = 0; i < s->slice_context_count; i++) {
1415             free_duplicate_context(s->thread_context[i]);
1416         }
1417         for (i = 1; i < s->slice_context_count; i++) {
1418             av_freep(&s->thread_context[i]);
1419         }
1420     } else
1421         free_duplicate_context(s);
1422
1423     if ((err = free_context_frame(s)) < 0)
1424         return err;
1425
1426     if (s->picture)
1427         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1428                 s->picture[i].needs_realloc = 1;
1429         }
1430
1431     s->last_picture_ptr         =
1432     s->next_picture_ptr         =
1433     s->current_picture_ptr      = NULL;
1434
1435     // init
1436     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1437         s->mb_height = (s->height + 31) / 32 * 2;
1438     else
1439         s->mb_height = (s->height + 15) / 16;
1440
1441     if ((s->width || s->height) &&
1442         av_image_check_size(s->width, s->height, 0, s->avctx))
1443         return AVERROR_INVALIDDATA;
1444
1445     if ((err = init_context_frame(s)))
1446         goto fail;
1447
1448     s->thread_context[0]   = s;
1449
1450     if (s->width && s->height) {
1451         int nb_slices = s->slice_context_count;
1452         if (nb_slices > 1) {
1453             for (i = 1; i < nb_slices; i++) {
1454                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1455                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1456             }
1457
1458             for (i = 0; i < nb_slices; i++) {
1459                 if (init_duplicate_context(s->thread_context[i]) < 0)
1460                     goto fail;
1461                     s->thread_context[i]->start_mb_y =
1462                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1463                     s->thread_context[i]->end_mb_y   =
1464                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1465             }
1466         } else {
1467             if (init_duplicate_context(s) < 0)
1468                 goto fail;
1469             s->start_mb_y = 0;
1470             s->end_mb_y   = s->mb_height;
1471         }
1472         s->slice_context_count = nb_slices;
1473     }
1474
1475     return 0;
1476  fail:
1477     ff_mpv_common_end(s);
1478     return err;
1479 }
1480
1481 /* init common structure for both encoder and decoder */
1482 void ff_mpv_common_end(MpegEncContext *s)
1483 {
1484     int i;
1485
1486     if (s->slice_context_count > 1) {
1487         for (i = 0; i < s->slice_context_count; i++) {
1488             free_duplicate_context(s->thread_context[i]);
1489         }
1490         for (i = 1; i < s->slice_context_count; i++) {
1491             av_freep(&s->thread_context[i]);
1492         }
1493         s->slice_context_count = 1;
1494     } else free_duplicate_context(s);
1495
1496     av_freep(&s->parse_context.buffer);
1497     s->parse_context.buffer_size = 0;
1498
1499     av_freep(&s->bitstream_buffer);
1500     s->allocated_bitstream_buffer_size = 0;
1501
1502     if (s->picture) {
1503         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1504             ff_free_picture_tables(&s->picture[i]);
1505             ff_mpeg_unref_picture(s, &s->picture[i]);
1506             av_frame_free(&s->picture[i].f);
1507         }
1508     }
1509     av_freep(&s->picture);
1510     ff_free_picture_tables(&s->last_picture);
1511     ff_mpeg_unref_picture(s, &s->last_picture);
1512     av_frame_free(&s->last_picture.f);
1513     ff_free_picture_tables(&s->current_picture);
1514     ff_mpeg_unref_picture(s, &s->current_picture);
1515     av_frame_free(&s->current_picture.f);
1516     ff_free_picture_tables(&s->next_picture);
1517     ff_mpeg_unref_picture(s, &s->next_picture);
1518     av_frame_free(&s->next_picture.f);
1519     ff_free_picture_tables(&s->new_picture);
1520     ff_mpeg_unref_picture(s, &s->new_picture);
1521     av_frame_free(&s->new_picture.f);
1522
1523     free_context_frame(s);
1524
1525     s->context_initialized      = 0;
1526     s->last_picture_ptr         =
1527     s->next_picture_ptr         =
1528     s->current_picture_ptr      = NULL;
1529     s->linesize = s->uvlinesize = 0;
1530 }
1531
1532 av_cold void ff_init_rl(RLTable *rl,
1533                         uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1534 {
1535     int8_t  max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1536     uint8_t index_run[MAX_RUN + 1];
1537     int last, run, level, start, end, i;
1538
1539     /* If table is static, we can quit if rl->max_level[0] is not NULL */
1540     if (static_store && rl->max_level[0])
1541         return;
1542
1543     /* compute max_level[], max_run[] and index_run[] */
1544     for (last = 0; last < 2; last++) {
1545         if (last == 0) {
1546             start = 0;
1547             end = rl->last;
1548         } else {
1549             start = rl->last;
1550             end = rl->n;
1551         }
1552
1553         memset(max_level, 0, MAX_RUN + 1);
1554         memset(max_run, 0, MAX_LEVEL + 1);
1555         memset(index_run, rl->n, MAX_RUN + 1);
1556         for (i = start; i < end; i++) {
1557             run   = rl->table_run[i];
1558             level = rl->table_level[i];
1559             if (index_run[run] == rl->n)
1560                 index_run[run] = i;
1561             if (level > max_level[run])
1562                 max_level[run] = level;
1563             if (run > max_run[level])
1564                 max_run[level] = run;
1565         }
1566         if (static_store)
1567             rl->max_level[last] = static_store[last];
1568         else
1569             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1570         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1571         if (static_store)
1572             rl->max_run[last]   = static_store[last] + MAX_RUN + 1;
1573         else
1574             rl->max_run[last]   = av_malloc(MAX_LEVEL + 1);
1575         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1576         if (static_store)
1577             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1578         else
1579             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1580         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1581     }
1582 }
1583
1584 av_cold void ff_init_vlc_rl(RLTable *rl)
1585 {
1586     int i, q;
1587
1588     for (q = 0; q < 32; q++) {
1589         int qmul = q * 2;
1590         int qadd = (q - 1) | 1;
1591
1592         if (q == 0) {
1593             qmul = 1;
1594             qadd = 0;
1595         }
1596         for (i = 0; i < rl->vlc.table_size; i++) {
1597             int code = rl->vlc.table[i][0];
1598             int len  = rl->vlc.table[i][1];
1599             int level, run;
1600
1601             if (len == 0) { // illegal code
1602                 run   = 66;
1603                 level = MAX_LEVEL;
1604             } else if (len < 0) { // more bits needed
1605                 run   = 0;
1606                 level = code;
1607             } else {
1608                 if (code == rl->n) { // esc
1609                     run   = 66;
1610                     level =  0;
1611                 } else {
1612                     run   = rl->table_run[code] + 1;
1613                     level = rl->table_level[code] * qmul + qadd;
1614                     if (code >= rl->last) run += 192;
1615                 }
1616             }
1617             rl->rl_vlc[q][i].len   = len;
1618             rl->rl_vlc[q][i].level = level;
1619             rl->rl_vlc[q][i].run   = run;
1620         }
1621     }
1622 }
1623
1624 static void release_unused_pictures(MpegEncContext *s)
1625 {
1626     int i;
1627
1628     /* release non reference frames */
1629     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1630         if (!s->picture[i].reference)
1631             ff_mpeg_unref_picture(s, &s->picture[i]);
1632     }
1633 }
1634
1635 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1636 {
1637     if (!pic->f->buf[0])
1638         return 1;
1639     if (pic->needs_realloc && !(pic->reference & DELAYED_PIC_REF))
1640         return 1;
1641     return 0;
1642 }
1643
1644 static int find_unused_picture(MpegEncContext *s, int shared)
1645 {
1646     int i;
1647
1648     if (shared) {
1649         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1650             if (!s->picture[i].f->buf[0])
1651                 return i;
1652         }
1653     } else {
1654         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1655             if (pic_is_unused(s, &s->picture[i]))
1656                 return i;
1657         }
1658     }
1659
1660     return AVERROR_INVALIDDATA;
1661 }
1662
1663 int ff_find_unused_picture(MpegEncContext *s, int shared)
1664 {
1665     int ret = find_unused_picture(s, shared);
1666
1667     if (ret >= 0 && ret < MAX_PICTURE_COUNT) {
1668         if (s->picture[ret].needs_realloc) {
1669             s->picture[ret].needs_realloc = 0;
1670             ff_free_picture_tables(&s->picture[ret]);
1671             ff_mpeg_unref_picture(s, &s->picture[ret]);
1672         }
1673     }
1674     return ret;
1675 }
1676
1677 /**
1678  * generic function called after decoding
1679  * the header and before a frame is decoded.
1680  */
1681 int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1682 {
1683     int i, ret;
1684     Picture *pic;
1685     s->mb_skipped = 0;
1686
1687     /* mark & release old frames */
1688     if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1689         s->last_picture_ptr != s->next_picture_ptr &&
1690         s->last_picture_ptr->f->buf[0]) {
1691         ff_mpeg_unref_picture(s, s->last_picture_ptr);
1692     }
1693
1694     /* release forgotten pictures */
1695     /* if (mpeg124/h263) */
1696     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1697         if (&s->picture[i] != s->last_picture_ptr &&
1698             &s->picture[i] != s->next_picture_ptr &&
1699             s->picture[i].reference && !s->picture[i].needs_realloc) {
1700             if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1701                 av_log(avctx, AV_LOG_ERROR,
1702                        "releasing zombie picture\n");
1703             ff_mpeg_unref_picture(s, &s->picture[i]);
1704         }
1705     }
1706
1707     ff_mpeg_unref_picture(s, &s->current_picture);
1708
1709     release_unused_pictures(s);
1710
1711     if (s->current_picture_ptr && !s->current_picture_ptr->f->buf[0]) {
1712         // we already have a unused image
1713         // (maybe it was set before reading the header)
1714         pic = s->current_picture_ptr;
1715     } else {
1716         i   = ff_find_unused_picture(s, 0);
1717         if (i < 0) {
1718             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1719             return i;
1720         }
1721         pic = &s->picture[i];
1722     }
1723
1724     pic->reference = 0;
1725     if (!s->droppable) {
1726         if (s->pict_type != AV_PICTURE_TYPE_B)
1727             pic->reference = 3;
1728     }
1729
1730     pic->f->coded_picture_number = s->coded_picture_number++;
1731
1732     if (ff_alloc_picture(s, pic, 0) < 0)
1733         return -1;
1734
1735     s->current_picture_ptr = pic;
1736     // FIXME use only the vars from current_pic
1737     s->current_picture_ptr->f->top_field_first = s->top_field_first;
1738     if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1739         s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1740         if (s->picture_structure != PICT_FRAME)
1741             s->current_picture_ptr->f->top_field_first =
1742                 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1743     }
1744     s->current_picture_ptr->f->interlaced_frame = !s->progressive_frame &&
1745                                                  !s->progressive_sequence;
1746     s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
1747
1748     s->current_picture_ptr->f->pict_type = s->pict_type;
1749     // if (s->flags && CODEC_FLAG_QSCALE)
1750     //     s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1751     s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1752
1753     if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1754                                    s->current_picture_ptr)) < 0)
1755         return ret;
1756
1757     if (s->pict_type != AV_PICTURE_TYPE_B) {
1758         s->last_picture_ptr = s->next_picture_ptr;
1759         if (!s->droppable)
1760             s->next_picture_ptr = s->current_picture_ptr;
1761     }
1762     av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1763             s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1764             s->last_picture_ptr    ? s->last_picture_ptr->f->data[0]    : NULL,
1765             s->next_picture_ptr    ? s->next_picture_ptr->f->data[0]    : NULL,
1766             s->current_picture_ptr ? s->current_picture_ptr->f->data[0] : NULL,
1767             s->pict_type, s->droppable);
1768
1769     if ((!s->last_picture_ptr || !s->last_picture_ptr->f->buf[0]) &&
1770         (s->pict_type != AV_PICTURE_TYPE_I ||
1771          s->picture_structure != PICT_FRAME)) {
1772         int h_chroma_shift, v_chroma_shift;
1773         av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1774                                          &h_chroma_shift, &v_chroma_shift);
1775         if (s->pict_type != AV_PICTURE_TYPE_I)
1776             av_log(avctx, AV_LOG_ERROR,
1777                    "warning: first frame is no keyframe\n");
1778         else if (s->picture_structure != PICT_FRAME)
1779             av_log(avctx, AV_LOG_INFO,
1780                    "allocate dummy last picture for field based first keyframe\n");
1781
1782         /* Allocate a dummy frame */
1783         i = ff_find_unused_picture(s, 0);
1784         if (i < 0) {
1785             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1786             return i;
1787         }
1788         s->last_picture_ptr = &s->picture[i];
1789
1790         s->last_picture_ptr->reference   = 3;
1791         s->last_picture_ptr->f->pict_type = AV_PICTURE_TYPE_I;
1792
1793         if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1794             s->last_picture_ptr = NULL;
1795             return -1;
1796         }
1797
1798         memset(s->last_picture_ptr->f->data[0], 0,
1799                avctx->height * s->last_picture_ptr->f->linesize[0]);
1800         memset(s->last_picture_ptr->f->data[1], 0x80,
1801                (avctx->height >> v_chroma_shift) *
1802                s->last_picture_ptr->f->linesize[1]);
1803         memset(s->last_picture_ptr->f->data[2], 0x80,
1804                (avctx->height >> v_chroma_shift) *
1805                s->last_picture_ptr->f->linesize[2]);
1806
1807         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1808         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1809     }
1810     if ((!s->next_picture_ptr || !s->next_picture_ptr->f->buf[0]) &&
1811         s->pict_type == AV_PICTURE_TYPE_B) {
1812         /* Allocate a dummy frame */
1813         i = ff_find_unused_picture(s, 0);
1814         if (i < 0) {
1815             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1816             return i;
1817         }
1818         s->next_picture_ptr = &s->picture[i];
1819
1820         s->next_picture_ptr->reference   = 3;
1821         s->next_picture_ptr->f->pict_type = AV_PICTURE_TYPE_I;
1822
1823         if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1824             s->next_picture_ptr = NULL;
1825             return -1;
1826         }
1827         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1828         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1829     }
1830
1831     if (s->last_picture_ptr) {
1832         ff_mpeg_unref_picture(s, &s->last_picture);
1833         if (s->last_picture_ptr->f->buf[0] &&
1834             (ret = ff_mpeg_ref_picture(s, &s->last_picture,
1835                                        s->last_picture_ptr)) < 0)
1836             return ret;
1837     }
1838     if (s->next_picture_ptr) {
1839         ff_mpeg_unref_picture(s, &s->next_picture);
1840         if (s->next_picture_ptr->f->buf[0] &&
1841             (ret = ff_mpeg_ref_picture(s, &s->next_picture,
1842                                        s->next_picture_ptr)) < 0)
1843             return ret;
1844     }
1845
1846     if (s->pict_type != AV_PICTURE_TYPE_I &&
1847         !(s->last_picture_ptr && s->last_picture_ptr->f->buf[0])) {
1848         av_log(s, AV_LOG_ERROR,
1849                "Non-reference picture received and no reference available\n");
1850         return AVERROR_INVALIDDATA;
1851     }
1852
1853     if (s->picture_structure!= PICT_FRAME) {
1854         int i;
1855         for (i = 0; i < 4; i++) {
1856             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1857                 s->current_picture.f->data[i] +=
1858                     s->current_picture.f->linesize[i];
1859             }
1860             s->current_picture.f->linesize[i] *= 2;
1861             s->last_picture.f->linesize[i]    *= 2;
1862             s->next_picture.f->linesize[i]    *= 2;
1863         }
1864     }
1865
1866     s->err_recognition = avctx->err_recognition;
1867
1868     /* set dequantizer, we can't do it during init as
1869      * it might change for mpeg4 and we can't do it in the header
1870      * decode as init is not called for mpeg4 there yet */
1871     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1872         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1873         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1874     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1875         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1876         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1877     } else {
1878         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1879         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1880     }
1881
1882 #if FF_API_XVMC
1883 FF_DISABLE_DEPRECATION_WARNINGS
1884     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1885         return ff_xvmc_field_start(s, avctx);
1886 FF_ENABLE_DEPRECATION_WARNINGS
1887 #endif /* FF_API_XVMC */
1888
1889     return 0;
1890 }
1891
1892 /* called after a frame has been decoded. */
1893 void ff_mpv_frame_end(MpegEncContext *s)
1894 {
1895 #if FF_API_XVMC
1896 FF_DISABLE_DEPRECATION_WARNINGS
1897     /* redraw edges for the frame if decoding didn't complete */
1898     // just to make sure that all data is rendered.
1899     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1900         ff_xvmc_field_end(s);
1901     } else
1902 FF_ENABLE_DEPRECATION_WARNINGS
1903 #endif /* FF_API_XVMC */
1904
1905     emms_c();
1906
1907     if (s->current_picture.reference)
1908         ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1909 }
1910
1911 /**
1912  * Print debugging info for the given picture.
1913  */
1914 void ff_print_debug_info(MpegEncContext *s, Picture *p)
1915 {
1916     AVFrame *pict;
1917     if (s->avctx->hwaccel || !p || !p->mb_type)
1918         return;
1919     pict = p->f;
1920
1921     if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1922         int x,y;
1923
1924         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1925         switch (pict->pict_type) {
1926         case AV_PICTURE_TYPE_I:
1927             av_log(s->avctx,AV_LOG_DEBUG,"I\n");
1928             break;
1929         case AV_PICTURE_TYPE_P:
1930             av_log(s->avctx,AV_LOG_DEBUG,"P\n");
1931             break;
1932         case AV_PICTURE_TYPE_B:
1933             av_log(s->avctx,AV_LOG_DEBUG,"B\n");
1934             break;
1935         case AV_PICTURE_TYPE_S:
1936             av_log(s->avctx,AV_LOG_DEBUG,"S\n");
1937             break;
1938         case AV_PICTURE_TYPE_SI:
1939             av_log(s->avctx,AV_LOG_DEBUG,"SI\n");
1940             break;
1941         case AV_PICTURE_TYPE_SP:
1942             av_log(s->avctx,AV_LOG_DEBUG,"SP\n");
1943             break;
1944         }
1945         for (y = 0; y < s->mb_height; y++) {
1946             for (x = 0; x < s->mb_width; x++) {
1947                 if (s->avctx->debug & FF_DEBUG_SKIP) {
1948                     int count = s->mbskip_table[x + y * s->mb_stride];
1949                     if (count > 9)
1950                         count = 9;
1951                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1952                 }
1953                 if (s->avctx->debug & FF_DEBUG_QP) {
1954                     av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1955                            p->qscale_table[x + y * s->mb_stride]);
1956                 }
1957                 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1958                     int mb_type = p->mb_type[x + y * s->mb_stride];
1959                     // Type & MV direction
1960                     if (IS_PCM(mb_type))
1961                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1962                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1963                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1964                     else if (IS_INTRA4x4(mb_type))
1965                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1966                     else if (IS_INTRA16x16(mb_type))
1967                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1968                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1969                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1970                     else if (IS_DIRECT(mb_type))
1971                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1972                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1973                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1974                     else if (IS_GMC(mb_type))
1975                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1976                     else if (IS_SKIP(mb_type))
1977                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1978                     else if (!USES_LIST(mb_type, 1))
1979                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1980                     else if (!USES_LIST(mb_type, 0))
1981                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1982                     else {
1983                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1984                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1985                     }
1986
1987                     // segmentation
1988                     if (IS_8X8(mb_type))
1989                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1990                     else if (IS_16X8(mb_type))
1991                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1992                     else if (IS_8X16(mb_type))
1993                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1994                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1995                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1996                     else
1997                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1998
1999
2000                     if (IS_INTERLACED(mb_type))
2001                         av_log(s->avctx, AV_LOG_DEBUG, "=");
2002                     else
2003                         av_log(s->avctx, AV_LOG_DEBUG, " ");
2004                 }
2005             }
2006             av_log(s->avctx, AV_LOG_DEBUG, "\n");
2007         }
2008     }
2009 }
2010
2011 /**
2012  * find the lowest MB row referenced in the MVs
2013  */
2014 int ff_mpv_lowest_referenced_row(MpegEncContext *s, int dir)
2015 {
2016     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2017     int my, off, i, mvs;
2018
2019     if (s->picture_structure != PICT_FRAME || s->mcsel)
2020         goto unhandled;
2021
2022     switch (s->mv_type) {
2023         case MV_TYPE_16X16:
2024             mvs = 1;
2025             break;
2026         case MV_TYPE_16X8:
2027             mvs = 2;
2028             break;
2029         case MV_TYPE_8X8:
2030             mvs = 4;
2031             break;
2032         default:
2033             goto unhandled;
2034     }
2035
2036     for (i = 0; i < mvs; i++) {
2037         my = s->mv[dir][i][1]<<qpel_shift;
2038         my_max = FFMAX(my_max, my);
2039         my_min = FFMIN(my_min, my);
2040     }
2041
2042     off = (FFMAX(-my_min, my_max) + 63) >> 6;
2043
2044     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2045 unhandled:
2046     return s->mb_height-1;
2047 }
2048
2049 /* put block[] to dest[] */
2050 static inline void put_dct(MpegEncContext *s,
2051                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2052 {
2053     s->dct_unquantize_intra(s, block, i, qscale);
2054     s->idsp.idct_put(dest, line_size, block);
2055 }
2056
2057 /* add block[] to dest[] */
2058 static inline void add_dct(MpegEncContext *s,
2059                            int16_t *block, int i, uint8_t *dest, int line_size)
2060 {
2061     if (s->block_last_index[i] >= 0) {
2062         s->idsp.idct_add(dest, line_size, block);
2063     }
2064 }
2065
2066 static inline void add_dequant_dct(MpegEncContext *s,
2067                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2068 {
2069     if (s->block_last_index[i] >= 0) {
2070         s->dct_unquantize_inter(s, block, i, qscale);
2071
2072         s->idsp.idct_add(dest, line_size, block);
2073     }
2074 }
2075
2076 /**
2077  * Clean dc, ac, coded_block for the current non-intra MB.
2078  */
2079 void ff_clean_intra_table_entries(MpegEncContext *s)
2080 {
2081     int wrap = s->b8_stride;
2082     int xy = s->block_index[0];
2083
2084     s->dc_val[0][xy           ] =
2085     s->dc_val[0][xy + 1       ] =
2086     s->dc_val[0][xy     + wrap] =
2087     s->dc_val[0][xy + 1 + wrap] = 1024;
2088     /* ac pred */
2089     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2090     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2091     if (s->msmpeg4_version>=3) {
2092         s->coded_block[xy           ] =
2093         s->coded_block[xy + 1       ] =
2094         s->coded_block[xy     + wrap] =
2095         s->coded_block[xy + 1 + wrap] = 0;
2096     }
2097     /* chroma */
2098     wrap = s->mb_stride;
2099     xy = s->mb_x + s->mb_y * wrap;
2100     s->dc_val[1][xy] =
2101     s->dc_val[2][xy] = 1024;
2102     /* ac pred */
2103     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2104     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2105
2106     s->mbintra_table[xy]= 0;
2107 }
2108
2109 /* generic function called after a macroblock has been parsed by the
2110    decoder or after it has been encoded by the encoder.
2111
2112    Important variables used:
2113    s->mb_intra : true if intra macroblock
2114    s->mv_dir   : motion vector direction
2115    s->mv_type  : motion vector type
2116    s->mv       : motion vector
2117    s->interlaced_dct : true if interlaced dct used (mpeg2)
2118  */
2119 static av_always_inline
2120 void mpv_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
2121                             int is_mpeg12)
2122 {
2123     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2124
2125 #if FF_API_XVMC
2126 FF_DISABLE_DEPRECATION_WARNINGS
2127     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2128         ff_xvmc_decode_mb(s);//xvmc uses pblocks
2129         return;
2130     }
2131 FF_ENABLE_DEPRECATION_WARNINGS
2132 #endif /* FF_API_XVMC */
2133
2134     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2135        /* print DCT coefficients */
2136        int i,j;
2137        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2138        for(i=0; i<6; i++){
2139            for(j=0; j<64; j++){
2140                av_log(s->avctx, AV_LOG_DEBUG, "%5d",
2141                       block[i][s->idsp.idct_permutation[j]]);
2142            }
2143            av_log(s->avctx, AV_LOG_DEBUG, "\n");
2144        }
2145     }
2146
2147     s->current_picture.qscale_table[mb_xy] = s->qscale;
2148
2149     /* update DC predictors for P macroblocks */
2150     if (!s->mb_intra) {
2151         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2152             if(s->mbintra_table[mb_xy])
2153                 ff_clean_intra_table_entries(s);
2154         } else {
2155             s->last_dc[0] =
2156             s->last_dc[1] =
2157             s->last_dc[2] = 128 << s->intra_dc_precision;
2158         }
2159     }
2160     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2161         s->mbintra_table[mb_xy]=1;
2162
2163     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==AV_PICTURE_TYPE_B) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
2164         uint8_t *dest_y, *dest_cb, *dest_cr;
2165         int dct_linesize, dct_offset;
2166         op_pixels_func (*op_pix)[4];
2167         qpel_mc_func (*op_qpix)[16];
2168         const int linesize   = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
2169         const int uvlinesize = s->current_picture.f->linesize[1];
2170         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band;
2171         const int block_size = 8;
2172
2173         /* avoid copy if macroblock skipped in last frame too */
2174         /* skip only during decoding as we might trash the buffers during encoding a bit */
2175         if(!s->encoding){
2176             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2177
2178             if (s->mb_skipped) {
2179                 s->mb_skipped= 0;
2180                 assert(s->pict_type!=AV_PICTURE_TYPE_I);
2181                 *mbskip_ptr = 1;
2182             } else if(!s->current_picture.reference) {
2183                 *mbskip_ptr = 1;
2184             } else{
2185                 *mbskip_ptr = 0; /* not skipped */
2186             }
2187         }
2188
2189         dct_linesize = linesize << s->interlaced_dct;
2190         dct_offset   = s->interlaced_dct ? linesize : linesize * block_size;
2191
2192         if(readable){
2193             dest_y=  s->dest[0];
2194             dest_cb= s->dest[1];
2195             dest_cr= s->dest[2];
2196         }else{
2197             dest_y = s->b_scratchpad;
2198             dest_cb= s->b_scratchpad+16*linesize;
2199             dest_cr= s->b_scratchpad+32*linesize;
2200         }
2201
2202         if (!s->mb_intra) {
2203             /* motion handling */
2204             /* decoding or more than one mb_type (MC was already done otherwise) */
2205             if(!s->encoding){
2206
2207                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2208                     if (s->mv_dir & MV_DIR_FORWARD) {
2209                         ff_thread_await_progress(&s->last_picture_ptr->tf,
2210                                                  ff_mpv_lowest_referenced_row(s, 0),
2211                                                  0);
2212                     }
2213                     if (s->mv_dir & MV_DIR_BACKWARD) {
2214                         ff_thread_await_progress(&s->next_picture_ptr->tf,
2215                                                  ff_mpv_lowest_referenced_row(s, 1),
2216                                                  0);
2217                     }
2218                 }
2219
2220                 op_qpix= s->me.qpel_put;
2221                 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2222                     op_pix = s->hdsp.put_pixels_tab;
2223                 }else{
2224                     op_pix = s->hdsp.put_no_rnd_pixels_tab;
2225                 }
2226                 if (s->mv_dir & MV_DIR_FORWARD) {
2227                     ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
2228                     op_pix = s->hdsp.avg_pixels_tab;
2229                     op_qpix= s->me.qpel_avg;
2230                 }
2231                 if (s->mv_dir & MV_DIR_BACKWARD) {
2232                     ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
2233                 }
2234             }
2235
2236             /* skip dequant / idct if we are really late ;) */
2237             if(s->avctx->skip_idct){
2238                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2239                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2240                    || s->avctx->skip_idct >= AVDISCARD_ALL)
2241                     goto skip_idct;
2242             }
2243
2244             /* add dct residue */
2245             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2246                                 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2247                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2248                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2249                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2250                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2251
2252                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2253                     if (s->chroma_y_shift){
2254                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2255                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2256                     }else{
2257                         dct_linesize >>= 1;
2258                         dct_offset >>=1;
2259                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2260                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2261                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2262                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2263                     }
2264                 }
2265             } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2266                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2267                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2268                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2269                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2270
2271                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2272                     if(s->chroma_y_shift){//Chroma420
2273                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
2274                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
2275                     }else{
2276                         //chroma422
2277                         dct_linesize = uvlinesize << s->interlaced_dct;
2278                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize * 8;
2279
2280                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
2281                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
2282                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2283                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2284                         if(!s->chroma_x_shift){//Chroma444
2285                             add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2286                             add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2287                             add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2288                             add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2289                         }
2290                     }
2291                 }//fi gray
2292             }
2293             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2294                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2295             }
2296         } else {
2297             /* dct only in intra block */
2298             if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2299                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2300                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2301                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2302                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2303
2304                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2305                     if(s->chroma_y_shift){
2306                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2307                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2308                     }else{
2309                         dct_offset >>=1;
2310                         dct_linesize >>=1;
2311                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2312                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2313                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2314                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2315                     }
2316                 }
2317             }else{
2318                 s->idsp.idct_put(dest_y,                           dct_linesize, block[0]);
2319                 s->idsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2320                 s->idsp.idct_put(dest_y + dct_offset,              dct_linesize, block[2]);
2321                 s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2322
2323                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2324                     if(s->chroma_y_shift){
2325                         s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
2326                         s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
2327                     }else{
2328
2329                         dct_linesize = uvlinesize << s->interlaced_dct;
2330                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize * 8;
2331
2332                         s->idsp.idct_put(dest_cb,              dct_linesize, block[4]);
2333                         s->idsp.idct_put(dest_cr,              dct_linesize, block[5]);
2334                         s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2335                         s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2336                         if(!s->chroma_x_shift){//Chroma444
2337                             s->idsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
2338                             s->idsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
2339                             s->idsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2340                             s->idsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2341                         }
2342                     }
2343                 }//gray
2344             }
2345         }
2346 skip_idct:
2347         if(!readable){
2348             s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2349             s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2350             s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2351         }
2352     }
2353 }
2354
2355 void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64])
2356 {
2357 #if !CONFIG_SMALL
2358     if(s->out_format == FMT_MPEG1) {
2359         mpv_decode_mb_internal(s, block, 1);
2360     } else
2361 #endif
2362         mpv_decode_mb_internal(s, block, 0);
2363 }
2364
2365 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
2366 {
2367     ff_draw_horiz_band(s->avctx, s->current_picture.f,
2368                        s->last_picture.f, y, h, s->picture_structure,
2369                        s->first_field, s->low_delay);
2370 }
2371
2372 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2373     const int linesize   = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
2374     const int uvlinesize = s->current_picture.f->linesize[1];
2375     const int mb_size= 4;
2376
2377     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2378     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2379     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2380     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2381     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2382     s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2383     //block_index is not used by mpeg2, so it is not affected by chroma_format
2384
2385     s->dest[0] = s->current_picture.f->data[0] + ((s->mb_x - 1) <<  mb_size);
2386     s->dest[1] = s->current_picture.f->data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2387     s->dest[2] = s->current_picture.f->data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2388
2389     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2390     {
2391         if(s->picture_structure==PICT_FRAME){
2392         s->dest[0] += s->mb_y *   linesize << mb_size;
2393         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2394         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2395         }else{
2396             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2397             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2398             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2399             assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2400         }
2401     }
2402 }
2403
2404 /**
2405  * Permute an 8x8 block.
2406  * @param block the block which will be permuted according to the given permutation vector
2407  * @param permutation the permutation vector
2408  * @param last the last non zero coefficient in scantable order, used to speed the permutation up
2409  * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
2410  *                  (inverse) permutated to scantable order!
2411  */
2412 void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
2413 {
2414     int i;
2415     int16_t temp[64];
2416
2417     if(last<=0) return;
2418     //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
2419
2420     for(i=0; i<=last; i++){
2421         const int j= scantable[i];
2422         temp[j]= block[j];
2423         block[j]=0;
2424     }
2425
2426     for(i=0; i<=last; i++){
2427         const int j= scantable[i];
2428         const int perm_j= permutation[j];
2429         block[perm_j]= temp[j];
2430     }
2431 }
2432
2433 void ff_mpeg_flush(AVCodecContext *avctx){
2434     int i;
2435     MpegEncContext *s = avctx->priv_data;
2436
2437     if (!s || !s->picture)
2438         return;
2439
2440     for (i = 0; i < MAX_PICTURE_COUNT; i++)
2441         ff_mpeg_unref_picture(s, &s->picture[i]);
2442     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2443
2444     ff_mpeg_unref_picture(s, &s->current_picture);
2445     ff_mpeg_unref_picture(s, &s->last_picture);
2446     ff_mpeg_unref_picture(s, &s->next_picture);
2447
2448     s->mb_x= s->mb_y= 0;
2449
2450     s->parse_context.state= -1;
2451     s->parse_context.frame_start_found= 0;
2452     s->parse_context.overread= 0;
2453     s->parse_context.overread_index= 0;
2454     s->parse_context.index= 0;
2455     s->parse_context.last_index= 0;
2456     s->bitstream_buffer_size=0;
2457     s->pp_time=0;
2458 }
2459
2460 /**
2461  * set qscale and update qscale dependent variables.
2462  */
2463 void ff_set_qscale(MpegEncContext * s, int qscale)
2464 {
2465     if (qscale < 1)
2466         qscale = 1;
2467     else if (qscale > 31)
2468         qscale = 31;
2469
2470     s->qscale = qscale;
2471     s->chroma_qscale= s->chroma_qscale_table[qscale];
2472
2473     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2474     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2475 }
2476
2477 void ff_mpv_report_decode_progress(MpegEncContext *s)
2478 {
2479     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
2480         ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
2481 }