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