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