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