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