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