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