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