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