pixdesc: add av_pix_fmt_get_chroma_sub_sample
[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         av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
871                                          &s->chroma_x_shift,
872                                          &s->chroma_y_shift);
873
874         /* convert fourcc to upper case */
875         s->codec_tag          = avpriv_toupper4(s->avctx->codec_tag);
876
877         s->stream_codec_tag   = avpriv_toupper4(s->avctx->stream_codec_tag);
878
879         s->avctx->coded_frame = &s->current_picture.f;
880
881         if (s->encoding) {
882             if (s->msmpeg4_version) {
883                 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
884                                   2 * 2 * (MAX_LEVEL + 1) *
885                                   (MAX_RUN + 1) * 2 * sizeof(int), fail);
886             }
887             FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
888
889             FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix,
890                               64 * 32   * sizeof(int), fail);
891             FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix,
892                               64 * 32   * sizeof(int), fail);
893             FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16,
894                               64 * 32 * 2 * sizeof(uint16_t), fail);
895             FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16,
896                               64 * 32 * 2 * sizeof(uint16_t), fail);
897             FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
898                               MAX_PICTURE_COUNT * sizeof(Picture *), fail);
899             FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture,
900                               MAX_PICTURE_COUNT * sizeof(Picture *), fail);
901
902             if (s->avctx->noise_reduction) {
903                 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset,
904                                   2 * 64 * sizeof(uint16_t), fail);
905             }
906         }
907     }
908
909     s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
910     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
911                       s->picture_count * sizeof(Picture), fail);
912     for (i = 0; i < s->picture_count; i++) {
913         avcodec_get_frame_defaults(&s->picture[i].f);
914     }
915
916     if (s->width && s->height) {
917         if (init_context_frame(s))
918             goto fail;
919
920         s->parse_context.state = -1;
921     }
922
923     s->context_initialized = 1;
924     s->thread_context[0]   = s;
925
926     if (s->width && s->height) {
927         if (nb_slices > 1) {
928             for (i = 1; i < nb_slices; i++) {
929                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
930                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
931             }
932
933             for (i = 0; i < nb_slices; i++) {
934                 if (init_duplicate_context(s->thread_context[i], s) < 0)
935                     goto fail;
936                     s->thread_context[i]->start_mb_y =
937                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
938                     s->thread_context[i]->end_mb_y   =
939                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
940             }
941         } else {
942             if (init_duplicate_context(s, s) < 0)
943                 goto fail;
944             s->start_mb_y = 0;
945             s->end_mb_y   = s->mb_height;
946         }
947         s->slice_context_count = nb_slices;
948     }
949
950     return 0;
951  fail:
952     ff_MPV_common_end(s);
953     return -1;
954 }
955
956 /**
957  * Frees and resets MpegEncContext fields depending on the resolution.
958  * Is used during resolution changes to avoid a full reinitialization of the
959  * codec.
960  */
961 static int free_context_frame(MpegEncContext *s)
962 {
963     int i, j, k;
964
965     av_freep(&s->mb_type);
966     av_freep(&s->p_mv_table_base);
967     av_freep(&s->b_forw_mv_table_base);
968     av_freep(&s->b_back_mv_table_base);
969     av_freep(&s->b_bidir_forw_mv_table_base);
970     av_freep(&s->b_bidir_back_mv_table_base);
971     av_freep(&s->b_direct_mv_table_base);
972     s->p_mv_table            = NULL;
973     s->b_forw_mv_table       = NULL;
974     s->b_back_mv_table       = NULL;
975     s->b_bidir_forw_mv_table = NULL;
976     s->b_bidir_back_mv_table = NULL;
977     s->b_direct_mv_table     = NULL;
978     for (i = 0; i < 2; i++) {
979         for (j = 0; j < 2; j++) {
980             for (k = 0; k < 2; k++) {
981                 av_freep(&s->b_field_mv_table_base[i][j][k]);
982                 s->b_field_mv_table[i][j][k] = NULL;
983             }
984             av_freep(&s->b_field_select_table[i][j]);
985             av_freep(&s->p_field_mv_table_base[i][j]);
986             s->p_field_mv_table[i][j] = NULL;
987         }
988         av_freep(&s->p_field_select_table[i]);
989     }
990
991     av_freep(&s->dc_val_base);
992     av_freep(&s->coded_block_base);
993     av_freep(&s->mbintra_table);
994     av_freep(&s->cbp_table);
995     av_freep(&s->pred_dir_table);
996
997     av_freep(&s->mbskip_table);
998
999     av_freep(&s->error_status_table);
1000     av_freep(&s->er_temp_buffer);
1001     av_freep(&s->mb_index2xy);
1002     av_freep(&s->lambda_table);
1003     av_freep(&s->cplx_tab);
1004     av_freep(&s->bits_tab);
1005
1006     s->linesize = s->uvlinesize = 0;
1007
1008     for (i = 0; i < 3; i++)
1009         av_freep(&s->visualization_buffer[i]);
1010
1011     if (!(s->avctx->active_thread_type & FF_THREAD_FRAME))
1012         avcodec_default_free_buffers(s->avctx);
1013
1014     return 0;
1015 }
1016
1017 int ff_MPV_common_frame_size_change(MpegEncContext *s)
1018 {
1019     int i, err = 0;
1020
1021     if (s->slice_context_count > 1) {
1022         for (i = 0; i < s->slice_context_count; i++) {
1023             free_duplicate_context(s->thread_context[i]);
1024         }
1025         for (i = 1; i < s->slice_context_count; i++) {
1026             av_freep(&s->thread_context[i]);
1027         }
1028     } else
1029         free_duplicate_context(s);
1030
1031     free_context_frame(s);
1032
1033     if (s->picture)
1034         for (i = 0; i < s->picture_count; i++) {
1035                 s->picture[i].needs_realloc = 1;
1036         }
1037
1038     s->last_picture_ptr         =
1039     s->next_picture_ptr         =
1040     s->current_picture_ptr      = NULL;
1041
1042     // init
1043     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1044         s->mb_height = (s->height + 31) / 32 * 2;
1045     else if (s->codec_id != AV_CODEC_ID_H264)
1046         s->mb_height = (s->height + 15) / 16;
1047
1048     if ((s->width || s->height) &&
1049         av_image_check_size(s->width, s->height, 0, s->avctx))
1050         return AVERROR_INVALIDDATA;
1051
1052     if ((err = init_context_frame(s)))
1053         goto fail;
1054
1055     s->thread_context[0]   = s;
1056
1057     if (s->width && s->height) {
1058         int nb_slices = s->slice_context_count;
1059         if (nb_slices > 1) {
1060             for (i = 1; i < nb_slices; i++) {
1061                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1062                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1063             }
1064
1065             for (i = 0; i < nb_slices; i++) {
1066                 if (init_duplicate_context(s->thread_context[i], s) < 0)
1067                     goto fail;
1068                     s->thread_context[i]->start_mb_y =
1069                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1070                     s->thread_context[i]->end_mb_y   =
1071                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1072             }
1073         } else {
1074             if (init_duplicate_context(s, s) < 0)
1075                 goto fail;
1076             s->start_mb_y = 0;
1077             s->end_mb_y   = s->mb_height;
1078         }
1079         s->slice_context_count = nb_slices;
1080     }
1081
1082     return 0;
1083  fail:
1084     ff_MPV_common_end(s);
1085     return err;
1086 }
1087
1088 /* init common structure for both encoder and decoder */
1089 void ff_MPV_common_end(MpegEncContext *s)
1090 {
1091     int i;
1092
1093     if (s->slice_context_count > 1) {
1094         for (i = 0; i < s->slice_context_count; i++) {
1095             free_duplicate_context(s->thread_context[i]);
1096         }
1097         for (i = 1; i < s->slice_context_count; i++) {
1098             av_freep(&s->thread_context[i]);
1099         }
1100         s->slice_context_count = 1;
1101     } else free_duplicate_context(s);
1102
1103     av_freep(&s->parse_context.buffer);
1104     s->parse_context.buffer_size = 0;
1105
1106     av_freep(&s->bitstream_buffer);
1107     s->allocated_bitstream_buffer_size = 0;
1108
1109     av_freep(&s->avctx->stats_out);
1110     av_freep(&s->ac_stats);
1111
1112     av_freep(&s->q_intra_matrix);
1113     av_freep(&s->q_inter_matrix);
1114     av_freep(&s->q_intra_matrix16);
1115     av_freep(&s->q_inter_matrix16);
1116     av_freep(&s->input_picture);
1117     av_freep(&s->reordered_input_picture);
1118     av_freep(&s->dct_offset);
1119
1120     if (s->picture && !s->avctx->internal->is_copy) {
1121         for (i = 0; i < s->picture_count; i++) {
1122             free_picture(s, &s->picture[i]);
1123         }
1124     }
1125     av_freep(&s->picture);
1126
1127     free_context_frame(s);
1128
1129     s->context_initialized      = 0;
1130     s->last_picture_ptr         =
1131     s->next_picture_ptr         =
1132     s->current_picture_ptr      = NULL;
1133     s->linesize = s->uvlinesize = 0;
1134 }
1135
1136 void ff_init_rl(RLTable *rl,
1137                 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1138 {
1139     int8_t  max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1140     uint8_t index_run[MAX_RUN + 1];
1141     int last, run, level, start, end, i;
1142
1143     /* If table is static, we can quit if rl->max_level[0] is not NULL */
1144     if (static_store && rl->max_level[0])
1145         return;
1146
1147     /* compute max_level[], max_run[] and index_run[] */
1148     for (last = 0; last < 2; last++) {
1149         if (last == 0) {
1150             start = 0;
1151             end = rl->last;
1152         } else {
1153             start = rl->last;
1154             end = rl->n;
1155         }
1156
1157         memset(max_level, 0, MAX_RUN + 1);
1158         memset(max_run, 0, MAX_LEVEL + 1);
1159         memset(index_run, rl->n, MAX_RUN + 1);
1160         for (i = start; i < end; i++) {
1161             run   = rl->table_run[i];
1162             level = rl->table_level[i];
1163             if (index_run[run] == rl->n)
1164                 index_run[run] = i;
1165             if (level > max_level[run])
1166                 max_level[run] = level;
1167             if (run > max_run[level])
1168                 max_run[level] = run;
1169         }
1170         if (static_store)
1171             rl->max_level[last] = static_store[last];
1172         else
1173             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1174         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1175         if (static_store)
1176             rl->max_run[last]   = static_store[last] + MAX_RUN + 1;
1177         else
1178             rl->max_run[last]   = av_malloc(MAX_LEVEL + 1);
1179         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1180         if (static_store)
1181             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1182         else
1183             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1184         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1185     }
1186 }
1187
1188 void ff_init_vlc_rl(RLTable *rl)
1189 {
1190     int i, q;
1191
1192     for (q = 0; q < 32; q++) {
1193         int qmul = q * 2;
1194         int qadd = (q - 1) | 1;
1195
1196         if (q == 0) {
1197             qmul = 1;
1198             qadd = 0;
1199         }
1200         for (i = 0; i < rl->vlc.table_size; i++) {
1201             int code = rl->vlc.table[i][0];
1202             int len  = rl->vlc.table[i][1];
1203             int level, run;
1204
1205             if (len == 0) { // illegal code
1206                 run   = 66;
1207                 level = MAX_LEVEL;
1208             } else if (len < 0) { // more bits needed
1209                 run   = 0;
1210                 level = code;
1211             } else {
1212                 if (code == rl->n) { // esc
1213                     run   = 66;
1214                     level =  0;
1215                 } else {
1216                     run   = rl->table_run[code] + 1;
1217                     level = rl->table_level[code] * qmul + qadd;
1218                     if (code >= rl->last) run += 192;
1219                 }
1220             }
1221             rl->rl_vlc[q][i].len   = len;
1222             rl->rl_vlc[q][i].level = level;
1223             rl->rl_vlc[q][i].run   = run;
1224         }
1225     }
1226 }
1227
1228 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1229 {
1230     int i;
1231
1232     /* release non reference frames */
1233     for (i = 0; i < s->picture_count; i++) {
1234         if (s->picture[i].f.data[0] && !s->picture[i].f.reference &&
1235             (!s->picture[i].owner2 || s->picture[i].owner2 == s) &&
1236             (remove_current || &s->picture[i] !=  s->current_picture_ptr)
1237             /* && s->picture[i].type!= FF_BUFFER_TYPE_SHARED */) {
1238             free_frame_buffer(s, &s->picture[i]);
1239         }
1240     }
1241 }
1242
1243 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1244 {
1245     if (pic->f.data[0] == NULL)
1246         return 1;
1247     if (pic->needs_realloc)
1248         if (!pic->owner2 || pic->owner2 == s)
1249             return 1;
1250     return 0;
1251 }
1252
1253 static int find_unused_picture(MpegEncContext *s, int shared)
1254 {
1255     int i;
1256
1257     if (shared) {
1258         for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1259             if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
1260                 return i;
1261         }
1262     } else {
1263         for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1264             if (pic_is_unused(s, &s->picture[i]) && s->picture[i].f.type != 0)
1265                 return i; // FIXME
1266         }
1267         for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1268             if (pic_is_unused(s, &s->picture[i]))
1269                 return i;
1270         }
1271     }
1272
1273     return AVERROR_INVALIDDATA;
1274 }
1275
1276 int ff_find_unused_picture(MpegEncContext *s, int shared)
1277 {
1278     int ret = find_unused_picture(s, shared);
1279
1280     if (ret >= 0 && ret < s->picture_range_end) {
1281         if (s->picture[ret].needs_realloc) {
1282             s->picture[ret].needs_realloc = 0;
1283             free_picture(s, &s->picture[ret]);
1284             avcodec_get_frame_defaults(&s->picture[ret].f);
1285         }
1286     }
1287     return ret;
1288 }
1289
1290 static void update_noise_reduction(MpegEncContext *s)
1291 {
1292     int intra, i;
1293
1294     for (intra = 0; intra < 2; intra++) {
1295         if (s->dct_count[intra] > (1 << 16)) {
1296             for (i = 0; i < 64; i++) {
1297                 s->dct_error_sum[intra][i] >>= 1;
1298             }
1299             s->dct_count[intra] >>= 1;
1300         }
1301
1302         for (i = 0; i < 64; i++) {
1303             s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1304                                        s->dct_count[intra] +
1305                                        s->dct_error_sum[intra][i] / 2) /
1306                                       (s->dct_error_sum[intra][i] + 1);
1307         }
1308     }
1309 }
1310
1311 /**
1312  * generic function for encode/decode called after coding/decoding
1313  * the header and before a frame is coded/decoded.
1314  */
1315 int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1316 {
1317     int i;
1318     Picture *pic;
1319     s->mb_skipped = 0;
1320
1321     /* mark & release old frames */
1322     if (s->out_format != FMT_H264 || s->codec_id == AV_CODEC_ID_SVQ3) {
1323         if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1324             s->last_picture_ptr != s->next_picture_ptr &&
1325             s->last_picture_ptr->f.data[0]) {
1326             if (s->last_picture_ptr->owner2 == s)
1327                 free_frame_buffer(s, s->last_picture_ptr);
1328         }
1329
1330         /* release forgotten pictures */
1331         /* if (mpeg124/h263) */
1332         if (!s->encoding) {
1333             for (i = 0; i < s->picture_count; i++) {
1334                 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] &&
1335                     &s->picture[i] != s->last_picture_ptr &&
1336                     &s->picture[i] != s->next_picture_ptr &&
1337                     s->picture[i].f.reference && !s->picture[i].needs_realloc) {
1338                     if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1339                         av_log(avctx, AV_LOG_ERROR,
1340                                "releasing zombie picture\n");
1341                     free_frame_buffer(s, &s->picture[i]);
1342                 }
1343             }
1344         }
1345     }
1346
1347     if (!s->encoding) {
1348         ff_release_unused_pictures(s, 1);
1349
1350         if (s->current_picture_ptr &&
1351             s->current_picture_ptr->f.data[0] == NULL) {
1352             // we already have a unused image
1353             // (maybe it was set before reading the header)
1354             pic = s->current_picture_ptr;
1355         } else {
1356             i   = ff_find_unused_picture(s, 0);
1357             if (i < 0) {
1358                 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1359                 return i;
1360             }
1361             pic = &s->picture[i];
1362         }
1363
1364         pic->f.reference = 0;
1365         if (!s->dropable) {
1366             if (s->codec_id == AV_CODEC_ID_H264)
1367                 pic->f.reference = s->picture_structure;
1368             else if (s->pict_type != AV_PICTURE_TYPE_B)
1369                 pic->f.reference = 3;
1370         }
1371
1372         pic->f.coded_picture_number = s->coded_picture_number++;
1373
1374         if (ff_alloc_picture(s, pic, 0) < 0)
1375             return -1;
1376
1377         s->current_picture_ptr = pic;
1378         // FIXME use only the vars from current_pic
1379         s->current_picture_ptr->f.top_field_first = s->top_field_first;
1380         if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1381             s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1382             if (s->picture_structure != PICT_FRAME)
1383                 s->current_picture_ptr->f.top_field_first =
1384                     (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1385         }
1386         s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1387                                                      !s->progressive_sequence;
1388         s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
1389     }
1390
1391     s->current_picture_ptr->f.pict_type = s->pict_type;
1392     // if (s->flags && CODEC_FLAG_QSCALE)
1393     //     s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1394     s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1395
1396     ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1397
1398     if (s->pict_type != AV_PICTURE_TYPE_B) {
1399         s->last_picture_ptr = s->next_picture_ptr;
1400         if (!s->dropable)
1401             s->next_picture_ptr = s->current_picture_ptr;
1402     }
1403     av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1404             s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1405             s->last_picture_ptr    ? s->last_picture_ptr->f.data[0]    : NULL,
1406             s->next_picture_ptr    ? s->next_picture_ptr->f.data[0]    : NULL,
1407             s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1408             s->pict_type, s->dropable);
1409
1410     if (s->codec_id != AV_CODEC_ID_H264) {
1411         if ((s->last_picture_ptr == NULL ||
1412              s->last_picture_ptr->f.data[0] == NULL) &&
1413             (s->pict_type != AV_PICTURE_TYPE_I ||
1414              s->picture_structure != PICT_FRAME)) {
1415             if (s->pict_type != AV_PICTURE_TYPE_I)
1416                 av_log(avctx, AV_LOG_ERROR,
1417                        "warning: first frame is no keyframe\n");
1418             else if (s->picture_structure != PICT_FRAME)
1419                 av_log(avctx, AV_LOG_INFO,
1420                        "allocate dummy last picture for field based first keyframe\n");
1421
1422             /* Allocate a dummy frame */
1423             i = ff_find_unused_picture(s, 0);
1424             if (i < 0) {
1425                 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1426                 return i;
1427             }
1428             s->last_picture_ptr = &s->picture[i];
1429             if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1430                 s->last_picture_ptr = NULL;
1431                 return -1;
1432             }
1433             ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 0);
1434             ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 1);
1435             s->last_picture_ptr->f.reference = 3;
1436         }
1437         if ((s->next_picture_ptr == NULL ||
1438              s->next_picture_ptr->f.data[0] == NULL) &&
1439             s->pict_type == AV_PICTURE_TYPE_B) {
1440             /* Allocate a dummy frame */
1441             i = ff_find_unused_picture(s, 0);
1442             if (i < 0) {
1443                 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1444                 return i;
1445             }
1446             s->next_picture_ptr = &s->picture[i];
1447             if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1448                 s->next_picture_ptr = NULL;
1449                 return -1;
1450             }
1451             ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 0);
1452             ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 1);
1453             s->next_picture_ptr->f.reference = 3;
1454         }
1455     }
1456
1457     if (s->last_picture_ptr)
1458         ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1459     if (s->next_picture_ptr)
1460         ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1461
1462     if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME) &&
1463         (s->out_format != FMT_H264 || s->codec_id == AV_CODEC_ID_SVQ3)) {
1464         if (s->next_picture_ptr)
1465             s->next_picture_ptr->owner2 = s;
1466         if (s->last_picture_ptr)
1467             s->last_picture_ptr->owner2 = s;
1468     }
1469
1470     assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1471                                                  s->last_picture_ptr->f.data[0]));
1472
1473     if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1474         int i;
1475         for (i = 0; i < 4; i++) {
1476             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1477                 s->current_picture.f.data[i] +=
1478                     s->current_picture.f.linesize[i];
1479             }
1480             s->current_picture.f.linesize[i] *= 2;
1481             s->last_picture.f.linesize[i]    *= 2;
1482             s->next_picture.f.linesize[i]    *= 2;
1483         }
1484     }
1485
1486     s->err_recognition = avctx->err_recognition;
1487
1488     /* set dequantizer, we can't do it during init as
1489      * it might change for mpeg4 and we can't do it in the header
1490      * decode as init is not called for mpeg4 there yet */
1491     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1492         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1493         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1494     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1495         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1496         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1497     } else {
1498         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1499         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1500     }
1501
1502     if (s->dct_error_sum) {
1503         assert(s->avctx->noise_reduction && s->encoding);
1504         update_noise_reduction(s);
1505     }
1506
1507     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1508         return ff_xvmc_field_start(s, avctx);
1509
1510     return 0;
1511 }
1512
1513 /* generic function for encode/decode called after a
1514  * frame has been coded/decoded. */
1515 void ff_MPV_frame_end(MpegEncContext *s)
1516 {
1517     int i;
1518     /* redraw edges for the frame if decoding didn't complete */
1519     // just to make sure that all data is rendered.
1520     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1521         ff_xvmc_field_end(s);
1522    } else if ((s->error_count || s->encoding) &&
1523               !s->avctx->hwaccel &&
1524               !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1525               s->unrestricted_mv &&
1526               s->current_picture.f.reference &&
1527               !s->intra_only &&
1528               !(s->flags & CODEC_FLAG_EMU_EDGE)) {
1529        const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1530        int hshift = desc->log2_chroma_w;
1531        int vshift = desc->log2_chroma_h;
1532        s->dsp.draw_edges(s->current_picture.f.data[0], s->linesize,
1533                          s->h_edge_pos, s->v_edge_pos,
1534                          EDGE_WIDTH, EDGE_WIDTH,
1535                          EDGE_TOP | EDGE_BOTTOM);
1536        s->dsp.draw_edges(s->current_picture.f.data[1], s->uvlinesize,
1537                          s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1538                          EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1539                          EDGE_TOP | EDGE_BOTTOM);
1540        s->dsp.draw_edges(s->current_picture.f.data[2], s->uvlinesize,
1541                          s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1542                          EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1543                          EDGE_TOP | EDGE_BOTTOM);
1544     }
1545
1546     emms_c();
1547
1548     s->last_pict_type                 = s->pict_type;
1549     s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1550     if (s->pict_type!= AV_PICTURE_TYPE_B) {
1551         s->last_non_b_pict_type = s->pict_type;
1552     }
1553 #if 0
1554     /* copy back current_picture variables */
1555     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1556         if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1557             s->picture[i] = s->current_picture;
1558             break;
1559         }
1560     }
1561     assert(i < MAX_PICTURE_COUNT);
1562 #endif
1563
1564     if (s->encoding) {
1565         /* release non-reference frames */
1566         for (i = 0; i < s->picture_count; i++) {
1567             if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1568                 /* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1569                 free_frame_buffer(s, &s->picture[i]);
1570             }
1571         }
1572     }
1573     // clear copies, to avoid confusion
1574 #if 0
1575     memset(&s->last_picture,    0, sizeof(Picture));
1576     memset(&s->next_picture,    0, sizeof(Picture));
1577     memset(&s->current_picture, 0, sizeof(Picture));
1578 #endif
1579     s->avctx->coded_frame = &s->current_picture_ptr->f;
1580
1581     if (s->codec_id != AV_CODEC_ID_H264 && s->current_picture.f.reference) {
1582         ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
1583     }
1584 }
1585
1586 /**
1587  * Draw a line from (ex, ey) -> (sx, sy).
1588  * @param w width of the image
1589  * @param h height of the image
1590  * @param stride stride/linesize of the image
1591  * @param color color of the arrow
1592  */
1593 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1594                       int w, int h, int stride, int color)
1595 {
1596     int x, y, fr, f;
1597
1598     sx = av_clip(sx, 0, w - 1);
1599     sy = av_clip(sy, 0, h - 1);
1600     ex = av_clip(ex, 0, w - 1);
1601     ey = av_clip(ey, 0, h - 1);
1602
1603     buf[sy * stride + sx] += color;
1604
1605     if (FFABS(ex - sx) > FFABS(ey - sy)) {
1606         if (sx > ex) {
1607             FFSWAP(int, sx, ex);
1608             FFSWAP(int, sy, ey);
1609         }
1610         buf += sx + sy * stride;
1611         ex  -= sx;
1612         f    = ((ey - sy) << 16) / ex;
1613         for (x = 0; x = ex; x++) {
1614             y  = (x * f) >> 16;
1615             fr = (x * f) & 0xFFFF;
1616             buf[y * stride + x]       += (color * (0x10000 - fr)) >> 16;
1617             buf[(y + 1) * stride + x] += (color *            fr ) >> 16;
1618         }
1619     } else {
1620         if (sy > ey) {
1621             FFSWAP(int, sx, ex);
1622             FFSWAP(int, sy, ey);
1623         }
1624         buf += sx + sy * stride;
1625         ey  -= sy;
1626         if (ey)
1627             f  = ((ex - sx) << 16) / ey;
1628         else
1629             f = 0;
1630         for (y = 0; y = ey; y++) {
1631             x  = (y * f) >> 16;
1632             fr = (y * f) & 0xFFFF;
1633             buf[y * stride + x]     += (color * (0x10000 - fr)) >> 16;
1634             buf[y * stride + x + 1] += (color *            fr ) >> 16;
1635         }
1636     }
1637 }
1638
1639 /**
1640  * Draw an arrow from (ex, ey) -> (sx, sy).
1641  * @param w width of the image
1642  * @param h height of the image
1643  * @param stride stride/linesize of the image
1644  * @param color color of the arrow
1645  */
1646 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1647                        int ey, int w, int h, int stride, int color)
1648 {
1649     int dx,dy;
1650
1651     sx = av_clip(sx, -100, w + 100);
1652     sy = av_clip(sy, -100, h + 100);
1653     ex = av_clip(ex, -100, w + 100);
1654     ey = av_clip(ey, -100, h + 100);
1655
1656     dx = ex - sx;
1657     dy = ey - sy;
1658
1659     if (dx * dx + dy * dy > 3 * 3) {
1660         int rx =  dx + dy;
1661         int ry = -dx + dy;
1662         int length = ff_sqrt((rx * rx + ry * ry) << 8);
1663
1664         // FIXME subpixel accuracy
1665         rx = ROUNDED_DIV(rx * 3 << 4, length);
1666         ry = ROUNDED_DIV(ry * 3 << 4, length);
1667
1668         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1669         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1670     }
1671     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1672 }
1673
1674 /**
1675  * Print debugging info for the given picture.
1676  */
1677 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1678 {
1679     if (s->avctx->hwaccel || !pict || !pict->mb_type)
1680         return;
1681
1682     if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1683         int x,y;
1684
1685         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1686         switch (pict->pict_type) {
1687         case AV_PICTURE_TYPE_I:
1688             av_log(s->avctx,AV_LOG_DEBUG,"I\n");
1689             break;
1690         case AV_PICTURE_TYPE_P:
1691             av_log(s->avctx,AV_LOG_DEBUG,"P\n");
1692             break;
1693         case AV_PICTURE_TYPE_B:
1694             av_log(s->avctx,AV_LOG_DEBUG,"B\n");
1695             break;
1696         case AV_PICTURE_TYPE_S:
1697             av_log(s->avctx,AV_LOG_DEBUG,"S\n");
1698             break;
1699         case AV_PICTURE_TYPE_SI:
1700             av_log(s->avctx,AV_LOG_DEBUG,"SI\n");
1701             break;
1702         case AV_PICTURE_TYPE_SP:
1703             av_log(s->avctx,AV_LOG_DEBUG,"SP\n");
1704             break;
1705         }
1706         for (y = 0; y < s->mb_height; y++) {
1707             for (x = 0; x < s->mb_width; x++) {
1708                 if (s->avctx->debug & FF_DEBUG_SKIP) {
1709                     int count = s->mbskip_table[x + y * s->mb_stride];
1710                     if (count > 9)
1711                         count = 9;
1712                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1713                 }
1714                 if (s->avctx->debug & FF_DEBUG_QP) {
1715                     av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1716                            pict->qscale_table[x + y * s->mb_stride]);
1717                 }
1718                 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1719                     int mb_type = pict->mb_type[x + y * s->mb_stride];
1720                     // Type & MV direction
1721                     if (IS_PCM(mb_type))
1722                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1723                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1724                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1725                     else if (IS_INTRA4x4(mb_type))
1726                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1727                     else if (IS_INTRA16x16(mb_type))
1728                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1729                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1730                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1731                     else if (IS_DIRECT(mb_type))
1732                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1733                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1734                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1735                     else if (IS_GMC(mb_type))
1736                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1737                     else if (IS_SKIP(mb_type))
1738                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1739                     else if (!USES_LIST(mb_type, 1))
1740                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1741                     else if (!USES_LIST(mb_type, 0))
1742                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1743                     else {
1744                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1745                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1746                     }
1747
1748                     // segmentation
1749                     if (IS_8X8(mb_type))
1750                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1751                     else if (IS_16X8(mb_type))
1752                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1753                     else if (IS_8X16(mb_type))
1754                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1755                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1756                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1757                     else
1758                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1759
1760
1761                     if (IS_INTERLACED(mb_type))
1762                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1763                     else
1764                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1765                 }
1766             }
1767             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1768         }
1769     }
1770
1771     if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1772         (s->avctx->debug_mv)) {
1773         const int shift = 1 + s->quarter_sample;
1774         int mb_y;
1775         uint8_t *ptr;
1776         int i;
1777         int h_chroma_shift, v_chroma_shift, block_height;
1778         const int width          = s->avctx->width;
1779         const int height         = s->avctx->height;
1780         const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1781         const int mv_stride      = (s->mb_width << mv_sample_log2) +
1782                                    (s->codec_id == AV_CODEC_ID_H264 ? 0 : 1);
1783         s->low_delay = 0; // needed to see the vectors without trashing the buffers
1784
1785         av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1786                                          &h_chroma_shift, &v_chroma_shift);
1787         for (i = 0; i < 3; i++) {
1788             memcpy(s->visualization_buffer[i], pict->data[i],
1789                    (i == 0) ? pict->linesize[i] * height:
1790                               pict->linesize[i] * height >> v_chroma_shift);
1791             pict->data[i] = s->visualization_buffer[i];
1792         }
1793         pict->type   = FF_BUFFER_TYPE_COPY;
1794         ptr          = pict->data[0];
1795         block_height = 16 >> v_chroma_shift;
1796
1797         for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1798             int mb_x;
1799             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1800                 const int mb_index = mb_x + mb_y * s->mb_stride;
1801                 if ((s->avctx->debug_mv) && pict->motion_val) {
1802                     int type;
1803                     for (type = 0; type < 3; type++) {
1804                         int direction = 0;
1805                         switch (type) {
1806                         case 0:
1807                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1808                                 (pict->pict_type!= AV_PICTURE_TYPE_P))
1809                                 continue;
1810                             direction = 0;
1811                             break;
1812                         case 1:
1813                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1814                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
1815                                 continue;
1816                             direction = 0;
1817                             break;
1818                         case 2:
1819                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1820                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
1821                                 continue;
1822                             direction = 1;
1823                             break;
1824                         }
1825                         if (!USES_LIST(pict->mb_type[mb_index], direction))
1826                             continue;
1827
1828                         if (IS_8X8(pict->mb_type[mb_index])) {
1829                             int i;
1830                             for (i = 0; i < 4; i++) {
1831                                 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1832                                 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1833                                 int xy = (mb_x * 2 + (i & 1) +
1834                                           (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1835                                 int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1836                                 int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1837                                 draw_arrow(ptr, sx, sy, mx, my, width,
1838                                            height, s->linesize, 100);
1839                             }
1840                         } else if (IS_16X8(pict->mb_type[mb_index])) {
1841                             int i;
1842                             for (i = 0; i < 2; i++) {
1843                                 int sx = mb_x * 16 + 8;
1844                                 int sy = mb_y * 16 + 4 + 8 * i;
1845                                 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1846                                 int mx = (pict->motion_val[direction][xy][0] >> shift);
1847                                 int my = (pict->motion_val[direction][xy][1] >> shift);
1848
1849                                 if (IS_INTERLACED(pict->mb_type[mb_index]))
1850                                     my *= 2;
1851
1852                             draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1853                                        height, s->linesize, 100);
1854                             }
1855                         } else if (IS_8X16(pict->mb_type[mb_index])) {
1856                             int i;
1857                             for (i = 0; i < 2; i++) {
1858                                 int sx = mb_x * 16 + 4 + 8 * i;
1859                                 int sy = mb_y * 16 + 8;
1860                                 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1861                                 int mx = pict->motion_val[direction][xy][0] >> shift;
1862                                 int my = pict->motion_val[direction][xy][1] >> shift;
1863
1864                                 if (IS_INTERLACED(pict->mb_type[mb_index]))
1865                                     my *= 2;
1866
1867                                 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1868                                            height, s->linesize, 100);
1869                             }
1870                         } else {
1871                               int sx = mb_x * 16 + 8;
1872                               int sy = mb_y * 16 + 8;
1873                               int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
1874                               int mx = pict->motion_val[direction][xy][0] >> shift + sx;
1875                               int my = pict->motion_val[direction][xy][1] >> shift + sy;
1876                               draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1877                         }
1878                     }
1879                 }
1880                 if ((s->avctx->debug & FF_DEBUG_VIS_QP) && pict->motion_val) {
1881                     uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1882                                  0x0101010101010101ULL;
1883                     int y;
1884                     for (y = 0; y < block_height; y++) {
1885                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
1886                                       (block_height * mb_y + y) *
1887                                       pict->linesize[1]) = c;
1888                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
1889                                       (block_height * mb_y + y) *
1890                                       pict->linesize[2]) = c;
1891                     }
1892                 }
1893                 if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
1894                     pict->motion_val) {
1895                     int mb_type = pict->mb_type[mb_index];
1896                     uint64_t u,v;
1897                     int y;
1898 #define COLOR(theta, r) \
1899     u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1900     v = (int)(128 + r * sin(theta * 3.141592 / 180));
1901
1902
1903                     u = v = 128;
1904                     if (IS_PCM(mb_type)) {
1905                         COLOR(120, 48)
1906                     } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
1907                                IS_INTRA16x16(mb_type)) {
1908                         COLOR(30, 48)
1909                     } else if (IS_INTRA4x4(mb_type)) {
1910                         COLOR(90, 48)
1911                     } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
1912                         // COLOR(120, 48)
1913                     } else if (IS_DIRECT(mb_type)) {
1914                         COLOR(150, 48)
1915                     } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
1916                         COLOR(170, 48)
1917                     } else if (IS_GMC(mb_type)) {
1918                         COLOR(190, 48)
1919                     } else if (IS_SKIP(mb_type)) {
1920                         // COLOR(180, 48)
1921                     } else if (!USES_LIST(mb_type, 1)) {
1922                         COLOR(240, 48)
1923                     } else if (!USES_LIST(mb_type, 0)) {
1924                         COLOR(0, 48)
1925                     } else {
1926                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1927                         COLOR(300,48)
1928                     }
1929
1930                     u *= 0x0101010101010101ULL;
1931                     v *= 0x0101010101010101ULL;
1932                     for (y = 0; y < block_height; y++) {
1933                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
1934                                       (block_height * mb_y + y) * pict->linesize[1]) = u;
1935                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
1936                                       (block_height * mb_y + y) * pict->linesize[2]) = v;
1937                     }
1938
1939                     // segmentation
1940                     if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
1941                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
1942                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1943                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
1944                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1945                     }
1946                     if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
1947                         for (y = 0; y < 16; y++)
1948                             pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1949                                           pict->linesize[0]] ^= 0x80;
1950                     }
1951                     if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1952                         int dm = 1 << (mv_sample_log2 - 2);
1953                         for (i = 0; i < 4; i++) {
1954                             int sx = mb_x * 16 + 8 * (i & 1);
1955                             int sy = mb_y * 16 + 8 * (i >> 1);
1956                             int xy = (mb_x * 2 + (i & 1) +
1957                                      (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1958                             // FIXME bidir
1959                             int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
1960                             if (mv[0] != mv[dm] ||
1961                                 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1962                                 for (y = 0; y < 8; y++)
1963                                     pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
1964                             if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1965                                 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
1966                                               pict->linesize[0]) ^= 0x8080808080808080ULL;
1967                         }
1968                     }
1969
1970                     if (IS_INTERLACED(mb_type) &&
1971                         s->codec_id == AV_CODEC_ID_H264) {
1972                         // hmm
1973                     }
1974                 }
1975                 s->mbskip_table[mb_index] = 0;
1976             }
1977         }
1978     }
1979 }
1980
1981 /**
1982  * find the lowest MB row referenced in the MVs
1983  */
1984 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
1985 {
1986     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1987     int my, off, i, mvs;
1988
1989     if (s->picture_structure != PICT_FRAME || s->mcsel)
1990         goto unhandled;
1991
1992     switch (s->mv_type) {
1993         case MV_TYPE_16X16:
1994             mvs = 1;
1995             break;
1996         case MV_TYPE_16X8:
1997             mvs = 2;
1998             break;
1999         case MV_TYPE_8X8:
2000             mvs = 4;
2001             break;
2002         default:
2003             goto unhandled;
2004     }
2005
2006     for (i = 0; i < mvs; i++) {
2007         my = s->mv[dir][i][1]<<qpel_shift;
2008         my_max = FFMAX(my_max, my);
2009         my_min = FFMIN(my_min, my);
2010     }
2011
2012     off = (FFMAX(-my_min, my_max) + 63) >> 6;
2013
2014     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2015 unhandled:
2016     return s->mb_height-1;
2017 }
2018
2019 /* put block[] to dest[] */
2020 static inline void put_dct(MpegEncContext *s,
2021                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2022 {
2023     s->dct_unquantize_intra(s, block, i, qscale);
2024     s->dsp.idct_put (dest, line_size, block);
2025 }
2026
2027 /* add block[] to dest[] */
2028 static inline void add_dct(MpegEncContext *s,
2029                            DCTELEM *block, int i, uint8_t *dest, int line_size)
2030 {
2031     if (s->block_last_index[i] >= 0) {
2032         s->dsp.idct_add (dest, line_size, block);
2033     }
2034 }
2035
2036 static inline void add_dequant_dct(MpegEncContext *s,
2037                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2038 {
2039     if (s->block_last_index[i] >= 0) {
2040         s->dct_unquantize_inter(s, block, i, qscale);
2041
2042         s->dsp.idct_add (dest, line_size, block);
2043     }
2044 }
2045
2046 /**
2047  * Clean dc, ac, coded_block for the current non-intra MB.
2048  */
2049 void ff_clean_intra_table_entries(MpegEncContext *s)
2050 {
2051     int wrap = s->b8_stride;
2052     int xy = s->block_index[0];
2053
2054     s->dc_val[0][xy           ] =
2055     s->dc_val[0][xy + 1       ] =
2056     s->dc_val[0][xy     + wrap] =
2057     s->dc_val[0][xy + 1 + wrap] = 1024;
2058     /* ac pred */
2059     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2060     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2061     if (s->msmpeg4_version>=3) {
2062         s->coded_block[xy           ] =
2063         s->coded_block[xy + 1       ] =
2064         s->coded_block[xy     + wrap] =
2065         s->coded_block[xy + 1 + wrap] = 0;
2066     }
2067     /* chroma */
2068     wrap = s->mb_stride;
2069     xy = s->mb_x + s->mb_y * wrap;
2070     s->dc_val[1][xy] =
2071     s->dc_val[2][xy] = 1024;
2072     /* ac pred */
2073     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2074     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2075
2076     s->mbintra_table[xy]= 0;
2077 }
2078
2079 /* generic function called after a macroblock has been parsed by the
2080    decoder or after it has been encoded by the encoder.
2081
2082    Important variables used:
2083    s->mb_intra : true if intra macroblock
2084    s->mv_dir   : motion vector direction
2085    s->mv_type  : motion vector type
2086    s->mv       : motion vector
2087    s->interlaced_dct : true if interlaced dct used (mpeg2)
2088  */
2089 static av_always_inline
2090 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2091                             int is_mpeg12)
2092 {
2093     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2094     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2095         ff_xvmc_decode_mb(s);//xvmc uses pblocks
2096         return;
2097     }
2098
2099     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2100        /* save DCT coefficients */
2101        int i,j;
2102        DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2103        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2104        for(i=0; i<6; i++){
2105            for(j=0; j<64; j++){
2106                *dct++ = block[i][s->dsp.idct_permutation[j]];
2107                av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2108            }
2109            av_log(s->avctx, AV_LOG_DEBUG, "\n");
2110        }
2111     }
2112
2113     s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2114
2115     /* update DC predictors for P macroblocks */
2116     if (!s->mb_intra) {
2117         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2118             if(s->mbintra_table[mb_xy])
2119                 ff_clean_intra_table_entries(s);
2120         } else {
2121             s->last_dc[0] =
2122             s->last_dc[1] =
2123             s->last_dc[2] = 128 << s->intra_dc_precision;
2124         }
2125     }
2126     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2127         s->mbintra_table[mb_xy]=1;
2128
2129     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
2130         uint8_t *dest_y, *dest_cb, *dest_cr;
2131         int dct_linesize, dct_offset;
2132         op_pixels_func (*op_pix)[4];
2133         qpel_mc_func (*op_qpix)[16];
2134         const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2135         const int uvlinesize = s->current_picture.f.linesize[1];
2136         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band;
2137         const int block_size = 8;
2138
2139         /* avoid copy if macroblock skipped in last frame too */
2140         /* skip only during decoding as we might trash the buffers during encoding a bit */
2141         if(!s->encoding){
2142             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2143
2144             if (s->mb_skipped) {
2145                 s->mb_skipped= 0;
2146                 assert(s->pict_type!=AV_PICTURE_TYPE_I);
2147                 *mbskip_ptr = 1;
2148             } else if(!s->current_picture.f.reference) {
2149                 *mbskip_ptr = 1;
2150             } else{
2151                 *mbskip_ptr = 0; /* not skipped */
2152             }
2153         }
2154
2155         dct_linesize = linesize << s->interlaced_dct;
2156         dct_offset   = s->interlaced_dct ? linesize : linesize * block_size;
2157
2158         if(readable){
2159             dest_y=  s->dest[0];
2160             dest_cb= s->dest[1];
2161             dest_cr= s->dest[2];
2162         }else{
2163             dest_y = s->b_scratchpad;
2164             dest_cb= s->b_scratchpad+16*linesize;
2165             dest_cr= s->b_scratchpad+32*linesize;
2166         }
2167
2168         if (!s->mb_intra) {
2169             /* motion handling */
2170             /* decoding or more than one mb_type (MC was already done otherwise) */
2171             if(!s->encoding){
2172
2173                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2174                     if (s->mv_dir & MV_DIR_FORWARD) {
2175                         ff_thread_await_progress(&s->last_picture_ptr->f,
2176                                                  ff_MPV_lowest_referenced_row(s, 0),
2177                                                  0);
2178                     }
2179                     if (s->mv_dir & MV_DIR_BACKWARD) {
2180                         ff_thread_await_progress(&s->next_picture_ptr->f,
2181                                                  ff_MPV_lowest_referenced_row(s, 1),
2182                                                  0);
2183                     }
2184                 }
2185
2186                 op_qpix= s->me.qpel_put;
2187                 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2188                     op_pix = s->dsp.put_pixels_tab;
2189                 }else{
2190                     op_pix = s->dsp.put_no_rnd_pixels_tab;
2191                 }
2192                 if (s->mv_dir & MV_DIR_FORWARD) {
2193                     ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2194                     op_pix = s->dsp.avg_pixels_tab;
2195                     op_qpix= s->me.qpel_avg;
2196                 }
2197                 if (s->mv_dir & MV_DIR_BACKWARD) {
2198                     ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2199                 }
2200             }
2201
2202             /* skip dequant / idct if we are really late ;) */
2203             if(s->avctx->skip_idct){
2204                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2205                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2206                    || s->avctx->skip_idct >= AVDISCARD_ALL)
2207                     goto skip_idct;
2208             }
2209
2210             /* add dct residue */
2211             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2212                                 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2213                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2214                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2215                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2216                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2217
2218                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2219                     if (s->chroma_y_shift){
2220                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2221                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2222                     }else{
2223                         dct_linesize >>= 1;
2224                         dct_offset >>=1;
2225                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2226                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2227                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2228                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2229                     }
2230                 }
2231             } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2232                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2233                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2234                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2235                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2236
2237                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2238                     if(s->chroma_y_shift){//Chroma420
2239                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
2240                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
2241                     }else{
2242                         //chroma422
2243                         dct_linesize = uvlinesize << s->interlaced_dct;
2244                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize * 8;
2245
2246                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
2247                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
2248                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2249                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2250                         if(!s->chroma_x_shift){//Chroma444
2251                             add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2252                             add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2253                             add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2254                             add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2255                         }
2256                     }
2257                 }//fi gray
2258             }
2259             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2260                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2261             }
2262         } else {
2263             /* dct only in intra block */
2264             if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2265                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2266                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2267                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2268                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2269
2270                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2271                     if(s->chroma_y_shift){
2272                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2273                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2274                     }else{
2275                         dct_offset >>=1;
2276                         dct_linesize >>=1;
2277                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2278                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2279                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2280                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2281                     }
2282                 }
2283             }else{
2284                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2285                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2286                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2287                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2288
2289                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2290                     if(s->chroma_y_shift){
2291                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2292                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2293                     }else{
2294
2295                         dct_linesize = uvlinesize << s->interlaced_dct;
2296                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize * 8;
2297
2298                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2299                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2300                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2301                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2302                         if(!s->chroma_x_shift){//Chroma444
2303                             s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
2304                             s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
2305                             s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2306                             s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2307                         }
2308                     }
2309                 }//gray
2310             }
2311         }
2312 skip_idct:
2313         if(!readable){
2314             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2315             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2316             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2317         }
2318     }
2319 }
2320
2321 void ff_MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2322 #if !CONFIG_SMALL
2323     if(s->out_format == FMT_MPEG1) {
2324         MPV_decode_mb_internal(s, block, 1);
2325     } else
2326 #endif
2327         MPV_decode_mb_internal(s, block, 0);
2328 }
2329
2330 /**
2331  * @param h is the normal height, this will be reduced automatically if needed for the last row
2332  */
2333 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2334     const int field_pic= s->picture_structure != PICT_FRAME;
2335     if(field_pic){
2336         h <<= 1;
2337         y <<= 1;
2338     }
2339
2340     if (!s->avctx->hwaccel
2341        && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2342        && s->unrestricted_mv
2343        && s->current_picture.f.reference
2344        && !s->intra_only
2345        && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2346         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
2347         int sides = 0, edge_h;
2348         int hshift = desc->log2_chroma_w;
2349         int vshift = desc->log2_chroma_h;
2350         if (y==0) sides |= EDGE_TOP;
2351         if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2352
2353         edge_h= FFMIN(h, s->v_edge_pos - y);
2354
2355         s->dsp.draw_edges(s->current_picture_ptr->f.data[0] +  y         *s->linesize,
2356                           s->linesize,           s->h_edge_pos,         edge_h,
2357                           EDGE_WIDTH,            EDGE_WIDTH,            sides);
2358         s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2359                           s->uvlinesize,         s->h_edge_pos>>hshift, edge_h>>vshift,
2360                           EDGE_WIDTH>>hshift,    EDGE_WIDTH>>vshift,    sides);
2361         s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2362                           s->uvlinesize,         s->h_edge_pos>>hshift, edge_h>>vshift,
2363                           EDGE_WIDTH>>hshift,    EDGE_WIDTH>>vshift,    sides);
2364     }
2365
2366     h= FFMIN(h, s->avctx->height - y);
2367
2368     if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2369
2370     if (s->avctx->draw_horiz_band) {
2371         AVFrame *src;
2372         int offset[AV_NUM_DATA_POINTERS];
2373         int i;
2374
2375         if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2376             src = &s->current_picture_ptr->f;
2377         else if(s->last_picture_ptr)
2378             src = &s->last_picture_ptr->f;
2379         else
2380             return;
2381
2382         if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2383             for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2384                 offset[i] = 0;
2385         }else{
2386             offset[0]= y * s->linesize;
2387             offset[1]=
2388             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2389             for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2390                 offset[i] = 0;
2391         }
2392
2393         emms_c();
2394
2395         s->avctx->draw_horiz_band(s->avctx, src, offset,
2396                                   y, s->picture_structure, h);
2397     }
2398 }
2399
2400 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2401     const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2402     const int uvlinesize = s->current_picture.f.linesize[1];
2403     const int mb_size= 4;
2404
2405     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2406     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2407     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2408     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2409     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2410     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;
2411     //block_index is not used by mpeg2, so it is not affected by chroma_format
2412
2413     s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) <<  mb_size);
2414     s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2415     s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2416
2417     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2418     {
2419         if(s->picture_structure==PICT_FRAME){
2420         s->dest[0] += s->mb_y *   linesize << mb_size;
2421         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2422         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2423         }else{
2424             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2425             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2426             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2427             assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2428         }
2429     }
2430 }
2431
2432 void ff_mpeg_flush(AVCodecContext *avctx){
2433     int i;
2434     MpegEncContext *s = avctx->priv_data;
2435
2436     if(s==NULL || s->picture==NULL)
2437         return;
2438
2439     for(i=0; i<s->picture_count; i++){
2440        if (s->picture[i].f.data[0] &&
2441            (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2442             s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2443         free_frame_buffer(s, &s->picture[i]);
2444     }
2445     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2446
2447     s->mb_x= s->mb_y= 0;
2448
2449     s->parse_context.state= -1;
2450     s->parse_context.frame_start_found= 0;
2451     s->parse_context.overread= 0;
2452     s->parse_context.overread_index= 0;
2453     s->parse_context.index= 0;
2454     s->parse_context.last_index= 0;
2455     s->bitstream_buffer_size=0;
2456     s->pp_time=0;
2457 }
2458
2459 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2460                                    DCTELEM *block, int n, int qscale)
2461 {
2462     int i, level, nCoeffs;
2463     const uint16_t *quant_matrix;
2464
2465     nCoeffs= s->block_last_index[n];
2466
2467     if (n < 4)
2468         block[0] = block[0] * s->y_dc_scale;
2469     else
2470         block[0] = block[0] * s->c_dc_scale;
2471     /* XXX: only mpeg1 */
2472     quant_matrix = s->intra_matrix;
2473     for(i=1;i<=nCoeffs;i++) {
2474         int j= s->intra_scantable.permutated[i];
2475         level = block[j];
2476         if (level) {
2477             if (level < 0) {
2478                 level = -level;
2479                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2480                 level = (level - 1) | 1;
2481                 level = -level;
2482             } else {
2483                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2484                 level = (level - 1) | 1;
2485             }
2486             block[j] = level;
2487         }
2488     }
2489 }
2490
2491 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2492                                    DCTELEM *block, int n, int qscale)
2493 {
2494     int i, level, nCoeffs;
2495     const uint16_t *quant_matrix;
2496
2497     nCoeffs= s->block_last_index[n];
2498
2499     quant_matrix = s->inter_matrix;
2500     for(i=0; i<=nCoeffs; i++) {
2501         int j= s->intra_scantable.permutated[i];
2502         level = block[j];
2503         if (level) {
2504             if (level < 0) {
2505                 level = -level;
2506                 level = (((level << 1) + 1) * qscale *
2507                          ((int) (quant_matrix[j]))) >> 4;
2508                 level = (level - 1) | 1;
2509                 level = -level;
2510             } else {
2511                 level = (((level << 1) + 1) * qscale *
2512                          ((int) (quant_matrix[j]))) >> 4;
2513                 level = (level - 1) | 1;
2514             }
2515             block[j] = level;
2516         }
2517     }
2518 }
2519
2520 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2521                                    DCTELEM *block, int n, int qscale)
2522 {
2523     int i, level, nCoeffs;
2524     const uint16_t *quant_matrix;
2525
2526     if(s->alternate_scan) nCoeffs= 63;
2527     else nCoeffs= s->block_last_index[n];
2528
2529     if (n < 4)
2530         block[0] = block[0] * s->y_dc_scale;
2531     else
2532         block[0] = block[0] * s->c_dc_scale;
2533     quant_matrix = s->intra_matrix;
2534     for(i=1;i<=nCoeffs;i++) {
2535         int j= s->intra_scantable.permutated[i];
2536         level = block[j];
2537         if (level) {
2538             if (level < 0) {
2539                 level = -level;
2540                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2541                 level = -level;
2542             } else {
2543                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2544             }
2545             block[j] = level;
2546         }
2547     }
2548 }
2549
2550 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2551                                    DCTELEM *block, int n, int qscale)
2552 {
2553     int i, level, nCoeffs;
2554     const uint16_t *quant_matrix;
2555     int sum=-1;
2556
2557     if(s->alternate_scan) nCoeffs= 63;
2558     else nCoeffs= s->block_last_index[n];
2559
2560     if (n < 4)
2561         block[0] = block[0] * s->y_dc_scale;
2562     else
2563         block[0] = block[0] * s->c_dc_scale;
2564     quant_matrix = s->intra_matrix;
2565     for(i=1;i<=nCoeffs;i++) {
2566         int j= s->intra_scantable.permutated[i];
2567         level = block[j];
2568         if (level) {
2569             if (level < 0) {
2570                 level = -level;
2571                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2572                 level = -level;
2573             } else {
2574                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2575             }
2576             block[j] = level;
2577             sum+=level;
2578         }
2579     }
2580     block[63]^=sum&1;
2581 }
2582
2583 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2584                                    DCTELEM *block, int n, int qscale)
2585 {
2586     int i, level, nCoeffs;
2587     const uint16_t *quant_matrix;
2588     int sum=-1;
2589
2590     if(s->alternate_scan) nCoeffs= 63;
2591     else nCoeffs= s->block_last_index[n];
2592
2593     quant_matrix = s->inter_matrix;
2594     for(i=0; i<=nCoeffs; i++) {
2595         int j= s->intra_scantable.permutated[i];
2596         level = block[j];
2597         if (level) {
2598             if (level < 0) {
2599                 level = -level;
2600                 level = (((level << 1) + 1) * qscale *
2601                          ((int) (quant_matrix[j]))) >> 4;
2602                 level = -level;
2603             } else {
2604                 level = (((level << 1) + 1) * qscale *
2605                          ((int) (quant_matrix[j]))) >> 4;
2606             }
2607             block[j] = level;
2608             sum+=level;
2609         }
2610     }
2611     block[63]^=sum&1;
2612 }
2613
2614 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2615                                   DCTELEM *block, int n, int qscale)
2616 {
2617     int i, level, qmul, qadd;
2618     int nCoeffs;
2619
2620     assert(s->block_last_index[n]>=0);
2621
2622     qmul = qscale << 1;
2623
2624     if (!s->h263_aic) {
2625         if (n < 4)
2626             block[0] = block[0] * s->y_dc_scale;
2627         else
2628             block[0] = block[0] * s->c_dc_scale;
2629         qadd = (qscale - 1) | 1;
2630     }else{
2631         qadd = 0;
2632     }
2633     if(s->ac_pred)
2634         nCoeffs=63;
2635     else
2636         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2637
2638     for(i=1; i<=nCoeffs; i++) {
2639         level = block[i];
2640         if (level) {
2641             if (level < 0) {
2642                 level = level * qmul - qadd;
2643             } else {
2644                 level = level * qmul + qadd;
2645             }
2646             block[i] = level;
2647         }
2648     }
2649 }
2650
2651 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2652                                   DCTELEM *block, int n, int qscale)
2653 {
2654     int i, level, qmul, qadd;
2655     int nCoeffs;
2656
2657     assert(s->block_last_index[n]>=0);
2658
2659     qadd = (qscale - 1) | 1;
2660     qmul = qscale << 1;
2661
2662     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2663
2664     for(i=0; i<=nCoeffs; i++) {
2665         level = block[i];
2666         if (level) {
2667             if (level < 0) {
2668                 level = level * qmul - qadd;
2669             } else {
2670                 level = level * qmul + qadd;
2671             }
2672             block[i] = level;
2673         }
2674     }
2675 }
2676
2677 /**
2678  * set qscale and update qscale dependent variables.
2679  */
2680 void ff_set_qscale(MpegEncContext * s, int qscale)
2681 {
2682     if (qscale < 1)
2683         qscale = 1;
2684     else if (qscale > 31)
2685         qscale = 31;
2686
2687     s->qscale = qscale;
2688     s->chroma_qscale= s->chroma_qscale_table[qscale];
2689
2690     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2691     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2692 }
2693
2694 void ff_MPV_report_decode_progress(MpegEncContext *s)
2695 {
2696     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
2697         ff_thread_report_progress(&s->current_picture_ptr->f, s->mb_y, 0);
2698 }