Move ff_sqrt() to libavutil/intmath.h
[libav.git] / libavcodec / mpegvideo.c
1 /*
2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5 *
6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7 *
8 * This file is part of FFmpeg.
9 *
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25 /**
26 * @file libavcodec/mpegvideo.c
27 * The simplest mpeg encoder (well, it was the simplest!).
28 */
29
30 #include "libavutil/intmath.h"
31 #include "avcodec.h"
32 #include "dsputil.h"
33 #include "mpegvideo.h"
34 #include "mpegvideo_common.h"
35 #include "mjpegenc.h"
36 #include "msmpeg4.h"
37 #include "faandct.h"
38 #include "xvmc_internal.h"
39 #include <limits.h>
40
41 //#undef NDEBUG
42 //#include <assert.h>
43
44 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
45 DCTELEM *block, int n, int qscale);
46 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
47 DCTELEM *block, int n, int qscale);
48 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
49 DCTELEM *block, int n, int qscale);
50 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
51 DCTELEM *block, int n, int qscale);
52 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
53 DCTELEM *block, int n, int qscale);
54 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
55 DCTELEM *block, int n, int qscale);
56 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
57 DCTELEM *block, int n, int qscale);
58
59
60 /* enable all paranoid tests for rounding, overflows, etc... */
61 //#define PARANOID
62
63 //#define DEBUG
64
65
66 static 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
71 const 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
79 const enum PixelFormat ff_pixfmt_list_420[] = {
80 PIX_FMT_YUV420P,
81 PIX_FMT_NONE
82 };
83
84 const enum PixelFormat ff_hwaccel_pixfmt_list_420[] = {
85 PIX_FMT_DXVA2_VLD,
86 PIX_FMT_VAAPI_VLD,
87 PIX_FMT_YUV420P,
88 PIX_FMT_NONE
89 };
90
91 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
92 int i;
93
94 assert(p<=end);
95 if(p>=end)
96 return end;
97
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 }
104
105 while(p<end){
106 if (p[-1] > 1 ) p+= 3;
107 else if(p[-2] ) p+= 2;
108 else if(p[-3]|(p[-1]-1)) p++;
109 else{
110 p++;
111 break;
112 }
113 }
114
115 p= FFMIN(p, end)-4;
116 *state= AV_RB32(p);
117
118 return p+4;
119 }
120
121 /* init common dct for both encoder and decoder */
122 av_cold int ff_dct_common_init(MpegEncContext *s)
123 {
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;
129 if(s->flags & CODEC_FLAG_BITEXACT)
130 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
131 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
132
133 #if HAVE_MMX
134 MPV_common_init_mmx(s);
135 #elif ARCH_ALPHA
136 MPV_common_init_axp(s);
137 #elif CONFIG_MLIB
138 MPV_common_init_mlib(s);
139 #elif HAVE_MMI
140 MPV_common_init_mmi(s);
141 #elif ARCH_ARM
142 MPV_common_init_arm(s);
143 #elif HAVE_ALTIVEC
144 MPV_common_init_altivec(s);
145 #elif ARCH_BFIN
146 MPV_common_init_bfin(s);
147 #endif
148
149 /* load & permutate scantables
150 note: only wmv uses different ones
151 */
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 }
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);
161
162 return 0;
163 }
164
165 void ff_copy_picture(Picture *dst, Picture *src){
166 *dst = *src;
167 dst->type= FF_BUFFER_TYPE_COPY;
168 }
169
170 /**
171 * Releases a frame buffer
172 */
173 static void free_frame_buffer(MpegEncContext *s, Picture *pic)
174 {
175 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
176 av_freep(&pic->hwaccel_picture_private);
177 }
178
179 /**
180 * Allocates a frame buffer
181 */
182 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
183 {
184 int r;
185
186 if (s->avctx->hwaccel) {
187 assert(!pic->hwaccel_picture_private);
188 if (s->avctx->hwaccel->priv_data_size) {
189 pic->hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
190 if (!pic->hwaccel_picture_private) {
191 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
192 return -1;
193 }
194 }
195 }
196
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]);
201 av_freep(&pic->hwaccel_picture_private);
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 /**
221 * allocates a Picture
222 * The pixels are allocated/set by calling get_buffer() if shared=0
223 */
224 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared){
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
226 const int mb_array_size= s->mb_stride*s->mb_height;
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;
229 int i;
230 int r= -1;
231
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{
237 assert(!pic->data[0]);
238
239 if (alloc_frame_buffer(s, pic) < 0)
240 return -1;
241
242 s->linesize = pic->linesize[0];
243 s->uvlinesize= pic->linesize[1];
244 }
245
246 if(pic->qscale_table==NULL){
247 if (s->encoding) {
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)
251 }
252
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)
256 pic->mb_type= pic->mb_type_base + 2*s->mb_stride+1;
257 if(s->out_format == FMT_H264){
258 for(i=0; i<2; i++){
259 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t), fail)
260 pic->motion_val[i]= pic->motion_val_base[i]+4;
261 FF_ALLOCZ_OR_GOTO(s->avctx, pic->ref_index[i], 4*mb_array_size * sizeof(uint8_t), fail)
262 }
263 pic->motion_subsample_log2= 2;
264 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
265 for(i=0; i<2; i++){
266 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t), fail)
267 pic->motion_val[i]= pic->motion_val_base[i]+4;
268 FF_ALLOCZ_OR_GOTO(s->avctx, pic->ref_index[i], b8_array_size * sizeof(uint8_t), fail)
269 }
270 pic->motion_subsample_log2= 3;
271 }
272 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
273 FF_ALLOCZ_OR_GOTO(s->avctx, pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6, fail)
274 }
275 pic->qstride= s->mb_stride;
276 FF_ALLOCZ_OR_GOTO(s->avctx, pic->pan_scan , 1 * sizeof(AVPanScan), fail)
277 }
278
279 /* It might be nicer if the application would keep track of these
280 * but it would require an API change. */
281 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
282 s->prev_pict_types[0]= s->dropable ? FF_B_TYPE : s->pict_type;
283 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == FF_B_TYPE)
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.
285
286 return 0;
287 fail: //for the FF_ALLOCZ_OR_GOTO macro
288 if(r>=0)
289 free_frame_buffer(s, pic);
290 return -1;
291 }
292
293 /**
294 * deallocates a picture
295 */
296 static void free_picture(MpegEncContext *s, Picture *pic){
297 int i;
298
299 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
300 free_frame_buffer(s, pic);
301 }
302
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);
308 av_freep(&pic->mb_type_base);
309 av_freep(&pic->dct_coeff);
310 av_freep(&pic->pan_scan);
311 pic->mb_type= NULL;
312 for(i=0; i<2; i++){
313 av_freep(&pic->motion_val_base[i]);
314 av_freep(&pic->ref_index[i]);
315 }
316
317 if(pic->type == FF_BUFFER_TYPE_SHARED){
318 for(i=0; i<4; i++){
319 pic->base[i]=
320 pic->data[i]= NULL;
321 }
322 pic->type= 0;
323 }
324 }
325
326 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
327 int i;
328
329 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
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
331 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
332
333 //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
334 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t), fail)
335 s->me.temp= s->me.scratchpad;
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) {
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)
342 if(s->avctx->noise_reduction){
343 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum, 2 * 64 * sizeof(int), fail)
344 }
345 }
346 FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64*12*2 * sizeof(DCTELEM), fail)
347 s->block= s->blocks[0];
348
349 for(i=0;i<12;i++){
350 s->pblocks[i] = &s->block[i];
351 }
352 return 0;
353 fail:
354 return -1; //free() through MPV_common_end()
355 }
356
357 static 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);
362 s->me.temp=
363 s->rd_scratchpad=
364 s->b_scratchpad=
365 s->obmc_scratchpad= NULL;
366
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
374 static 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);
379 COPY(me.temp);
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);
392 COPY(dct_count[0]);
393 COPY(dct_count[1]);
394 #undef COPY
395 }
396
397 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
398 MpegEncContext bak;
399 int i;
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);
405 for(i=0;i<12;i++){
406 dst->pblocks[i] = &dst->block[i];
407 }
408 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
409 }
410
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 */
415 void MPV_common_defaults(MpegEncContext *s){
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;
428
429 s->f_code = 1;
430 s->b_code = 1;
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 */
437 void MPV_decode_defaults(MpegEncContext *s){
438 MPV_common_defaults(s);
439 }
440
441 /**
442 * init common structure for both encoder and decoder.
443 * this assumes that some variables like width/height are already set
444 */
445 av_cold int MPV_common_init(MpegEncContext *s)
446 {
447 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
448
449 if(s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
450 s->mb_height = (s->height + 31) / 32 * 2;
451 else
452 s->mb_height = (s->height + 15) / 16;
453
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
459 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
460 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
461 return -1;
462 }
463
464 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
465 return -1;
466
467 dsputil_init(&s->dsp, s->avctx);
468 ff_dct_common_init(s);
469
470 s->flags= s->avctx->flags;
471 s->flags2= s->avctx->flags2;
472
473 s->mb_width = (s->width + 15) / 16;
474 s->mb_stride = s->mb_width + 1;
475 s->b8_stride = s->mb_width*2 + 1;
476 s->b4_stride = s->mb_width*4 + 1;
477 mb_array_size= s->mb_height * s->mb_stride;
478 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
479
480 /* set chroma shifts */
481 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
482 &(s->chroma_y_shift) );
483
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;
487
488 s->mb_num = s->mb_width * s->mb_height;
489
490 s->block_wrap[0]=
491 s->block_wrap[1]=
492 s->block_wrap[2]=
493 s->block_wrap[3]= s->b8_stride;
494 s->block_wrap[4]=
495 s->block_wrap[5]= s->mb_stride;
496
497 y_size = s->b8_stride * (2 * s->mb_height + 1);
498 c_size = s->mb_stride * (s->mb_height + 1);
499 yc_size = y_size + 2 * c_size;
500
501 /* convert fourcc to upper case */
502 s->codec_tag= toupper( s->avctx->codec_tag &0xFF)
503 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
504 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
505 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
506
507 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
508 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
509 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
510 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
511
512 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
513
514 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num+1)*sizeof(int), fail) //error ressilience code looks cleaner with this
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?
521
522 if (s->encoding) {
523 /* Allocate MV tables */
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)
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;
536
537 if(s->msmpeg4_version){
538 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
539 }
540 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
541
542 /* Allocate MB type table */
543 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
544
545 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
546
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)
553
554 if(s->avctx->noise_reduction){
555 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
556 }
557 }
558 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, MAX_PICTURE_COUNT * sizeof(Picture), fail)
559 for(i = 0; i < MAX_PICTURE_COUNT; i++) {
560 avcodec_get_frame_defaults((AVFrame *)&s->picture[i]);
561 }
562
563 FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
564
565 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
566 /* interlaced direct mode decoding tables */
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++){
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;
573 }
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;
577 }
578 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
579 }
580 }
581 if (s->out_format == FMT_H263) {
582 /* ac values */
583 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base, yc_size * sizeof(int16_t) * 16, fail);
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;
586 s->ac_val[2] = s->ac_val[1] + c_size;
587
588 /* cbp values */
589 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
590 s->coded_block= s->coded_block_base + s->b8_stride + 1;
591
592 /* cbp, ac_pred, pred_dir */
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)
595 }
596
597 if (s->h263_pred || s->h263_plus || !s->encoding) {
598 /* dc values */
599 //MN: we need these for error resilience of intra-frames
600 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
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;
603 s->dc_val[2] = s->dc_val[1] + c_size;
604 for(i=0;i<yc_size;i++)
605 s->dc_val_base[i] = 1024;
606 }
607
608 /* which mb is a intra block */
609 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
610 memset(s->mbintra_table, 1, mb_array_size);
611
612 /* init macroblock skip table */
613 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size+2, fail);
614 //Note the +1 is for a quicker mpeg4 slice_end detection
615 FF_ALLOCZ_OR_GOTO(s->avctx, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE, fail);
616
617 s->parse_context.state= -1;
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);
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);
622 }
623
624 s->context_initialized = 1;
625
626 s->thread_context[0]= s;
627 threads = s->avctx->thread_count;
628
629 for(i=1; i<threads; i++){
630 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
631 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
632 }
633
634 for(i=0; i<threads; i++){
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
641 return 0;
642 fail:
643 MPV_common_end(s);
644 return -1;
645 }
646
647 /* init common structure for both encoder and decoder */
648 void MPV_common_end(MpegEncContext *s)
649 {
650 int i, j, k;
651
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
659 av_freep(&s->parse_context.buffer);
660 s->parse_context.buffer_size=0;
661
662 av_freep(&s->mb_type);
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;
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 }
687
688 av_freep(&s->dc_val_base);
689 av_freep(&s->ac_val_base);
690 av_freep(&s->coded_block_base);
691 av_freep(&s->mbintra_table);
692 av_freep(&s->cbp_table);
693 av_freep(&s->pred_dir_table);
694
695 av_freep(&s->mbskip_table);
696 av_freep(&s->prev_pict_types);
697 av_freep(&s->bitstream_buffer);
698 s->allocated_bitstream_buffer_size=0;
699
700 av_freep(&s->avctx->stats_out);
701 av_freep(&s->ac_stats);
702 av_freep(&s->error_status_table);
703 av_freep(&s->mb_index2xy);
704 av_freep(&s->lambda_table);
705 av_freep(&s->q_intra_matrix);
706 av_freep(&s->q_inter_matrix);
707 av_freep(&s->q_intra_matrix16);
708 av_freep(&s->q_inter_matrix16);
709 av_freep(&s->input_picture);
710 av_freep(&s->reordered_input_picture);
711 av_freep(&s->dct_offset);
712
713 if(s->picture){
714 for(i=0; i<MAX_PICTURE_COUNT; i++){
715 free_picture(s, &s->picture[i]);
716 }
717 }
718 av_freep(&s->picture);
719 s->context_initialized = 0;
720 s->last_picture_ptr=
721 s->next_picture_ptr=
722 s->current_picture_ptr= NULL;
723 s->linesize= s->uvlinesize= 0;
724
725 for(i=0; i<3; i++)
726 av_freep(&s->visualization_buffer[i]);
727
728 avcodec_default_free_buffers(s->avctx);
729 }
730
731 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
732 {
733 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
734 uint8_t index_run[MAX_RUN+1];
735 int last, run, level, start, end, i;
736
737 /* If table is static, we can quit if rl->max_level[0] is not NULL */
738 if(static_store && rl->max_level[0])
739 return;
740
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 }
764 if(static_store)
765 rl->max_level[last] = static_store[last];
766 else
767 rl->max_level[last] = av_malloc(MAX_RUN + 1);
768 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
769 if(static_store)
770 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
771 else
772 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
773 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
774 if(static_store)
775 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
776 else
777 rl->index_run[last] = av_malloc(MAX_RUN + 1);
778 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
779 }
780 }
781
782 void init_vlc_rl(RLTable *rl)
783 {
784 int i, q;
785
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 }
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
822 int ff_find_unused_picture(MpegEncContext *s, int shared){
823 int i;
824
825 if(shared){
826 for(i=0; i<MAX_PICTURE_COUNT; i++){
827 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
828 }
829 }else{
830 for(i=0; i<MAX_PICTURE_COUNT; i++){
831 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
832 }
833 for(i=0; i<MAX_PICTURE_COUNT; i++){
834 if(s->picture[i].data[0]==NULL) return i;
835 }
836 }
837
838 av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
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 */
850 abort();
851 return -1;
852 }
853
854 static 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 }
864
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
871 /**
872 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
873 */
874 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
875 {
876 int i;
877 Picture *pic;
878 s->mb_skipped = 0;
879
880 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
881
882 /* mark&release old frames */
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]) {
884 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
885 free_frame_buffer(s, s->last_picture_ptr);
886
887 /* release forgotten pictures */
888 /* if(mpeg124/h263) */
889 if(!s->encoding){
890 for(i=0; i<MAX_PICTURE_COUNT; i++){
891 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
892 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
893 free_frame_buffer(s, &s->picture[i]);
894 }
895 }
896 }
897 }
898 }
899
900 if(!s->encoding){
901 /* release non reference frames */
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*/){
904 free_frame_buffer(s, &s->picture[i]);
905 }
906 }
907
908 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
909 pic= s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
910 else{
911 i= ff_find_unused_picture(s, 0);
912 pic= &s->picture[i];
913 }
914
915 pic->reference= 0;
916 if (!s->dropable){
917 if (s->codec_id == CODEC_ID_H264)
918 pic->reference = s->picture_structure;
919 else if (s->pict_type != FF_B_TYPE)
920 pic->reference = 3;
921 }
922
923 pic->coded_picture_number= s->coded_picture_number++;
924
925 if(ff_alloc_picture(s, pic, 0) < 0)
926 return -1;
927
928 s->current_picture_ptr= pic;
929 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
930 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
931 }
932
933 s->current_picture_ptr->pict_type= s->pict_type;
934 // if(s->flags && CODEC_FLAG_QSCALE)
935 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
936 s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
937
938 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
939
940 if (s->pict_type != FF_B_TYPE) {
941 s->last_picture_ptr= s->next_picture_ptr;
942 if(!s->dropable)
943 s->next_picture_ptr= s->current_picture_ptr;
944 }
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,
946 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
947 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
948 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
949 s->pict_type, s->dropable);*/
950
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
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);
971
972 assert(s->pict_type == FF_I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
973
974 if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
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];
979 }
980 s->current_picture.linesize[i] *= 2;
981 s->last_picture.linesize[i] *=2;
982 s->next_picture.linesize[i] *=2;
983 }
984 }
985
986 s->hurry_up= s->avctx->hurry_up;
987 s->error_recognition= avctx->error_recognition;
988
989 /* set dequantizer, we can't do it during init as it might change for mpeg4
990 and we can't do it in the header decode as init is not called for mpeg4 there yet */
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;
994 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
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 }
1001
1002 if(s->dct_error_sum){
1003 assert(s->avctx->noise_reduction && s->encoding);
1004
1005 update_noise_reduction(s);
1006 }
1007
1008 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1009 return ff_xvmc_field_start(s, avctx);
1010
1011 return 0;
1012 }
1013
1014 /* generic function for encode/decode called after a frame has been coded/decoded */
1015 void MPV_frame_end(MpegEncContext *s)
1016 {
1017 int i;
1018 /* draw edge for correct motion prediction if outside */
1019 //just to make sure that all data is rendered.
1020 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1021 ff_xvmc_field_end(s);
1022 }else if(!s->avctx->hwaccel
1023 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1024 && s->unrestricted_mv
1025 && s->current_picture.reference
1026 && !s->intra_only
1027 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
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);
1031 }
1032 emms_c();
1033
1034 s->last_pict_type = s->pict_type;
1035 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1036 if(s->pict_type!=FF_B_TYPE){
1037 s->last_non_b_pict_type= s->pict_type;
1038 }
1039 #if 0
1040 /* copy back current_picture variables */
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;
1045 }
1046 }
1047 assert(i<MAX_PICTURE_COUNT);
1048 #endif
1049
1050 if(s->encoding){
1051 /* release non-reference frames */
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*/){
1054 free_frame_buffer(s, &s->picture[i]);
1055 }
1056 }
1057 }
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
1064 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1065 }
1066
1067 /**
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 */
1074 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1075 int x, y, fr, f;
1076
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);
1081
1082 buf[sy*stride + sx]+= color;
1083
1084 if(FFABS(ex - sx) > FFABS(ey - sy)){
1085 if(sx > ex){
1086 FFSWAP(int, sx, ex);
1087 FFSWAP(int, sy, ey);
1088 }
1089 buf+= sx + sy*stride;
1090 ex-= sx;
1091 f= ((ey-sy)<<16)/ex;
1092 for(x= 0; x <= ex; x++){
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;
1097 }
1098 }else{
1099 if(sy > ey){
1100 FFSWAP(int, sx, ex);
1101 FFSWAP(int, sy, ey);
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++){
1108 x = (y*f)>>16;
1109 fr= (y*f)&0xFFFF;
1110 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1111 buf[y*stride + x+1]+= (color* fr )>>16;
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 */
1123 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1124 int dx,dy;
1125
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);
1130
1131 dx= ex - sx;
1132 dy= ey - sy;
1133
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);
1138
1139 //FIXME subpixel accuracy
1140 rx= ROUNDED_DIV(rx*3<<4, length);
1141 ry= ROUNDED_DIV(ry*3<<4, length);
1142
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 /**
1150 * prints debuging info for the given picture.
1151 */
1152 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1153
1154 if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1155
1156 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1157 int x,y;
1158
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;
1166 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1167 }
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;
1173 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1174 }
1175 if(s->avctx->debug&FF_DEBUG_QP){
1176 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1177 }
1178 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1179 int mb_type= pict->mb_type[x + y*s->mb_stride];
1180 //Type & MV direction
1181 if(IS_PCM(mb_type))
1182 av_log(s->avctx, AV_LOG_DEBUG, "P");
1183 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1184 av_log(s->avctx, AV_LOG_DEBUG, "A");
1185 else if(IS_INTRA4x4(mb_type))
1186 av_log(s->avctx, AV_LOG_DEBUG, "i");
1187 else if(IS_INTRA16x16(mb_type))
1188 av_log(s->avctx, AV_LOG_DEBUG, "I");
1189 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1190 av_log(s->avctx, AV_LOG_DEBUG, "d");
1191 else if(IS_DIRECT(mb_type))
1192 av_log(s->avctx, AV_LOG_DEBUG, "D");
1193 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1194 av_log(s->avctx, AV_LOG_DEBUG, "g");
1195 else if(IS_GMC(mb_type))
1196 av_log(s->avctx, AV_LOG_DEBUG, "G");
1197 else if(IS_SKIP(mb_type))
1198 av_log(s->avctx, AV_LOG_DEBUG, "S");
1199 else if(!USES_LIST(mb_type, 1))
1200 av_log(s->avctx, AV_LOG_DEBUG, ">");
1201 else if(!USES_LIST(mb_type, 0))
1202 av_log(s->avctx, AV_LOG_DEBUG, "<");
1203 else{
1204 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1205 av_log(s->avctx, AV_LOG_DEBUG, "X");
1206 }
1207
1208 //segmentation
1209 if(IS_8X8(mb_type))
1210 av_log(s->avctx, AV_LOG_DEBUG, "+");
1211 else if(IS_16X8(mb_type))
1212 av_log(s->avctx, AV_LOG_DEBUG, "-");
1213 else if(IS_8X16(mb_type))
1214 av_log(s->avctx, AV_LOG_DEBUG, "|");
1215 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1216 av_log(s->avctx, AV_LOG_DEBUG, " ");
1217 else
1218 av_log(s->avctx, AV_LOG_DEBUG, "?");
1219
1220
1221 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1222 av_log(s->avctx, AV_LOG_DEBUG, "=");
1223 else
1224 av_log(s->avctx, AV_LOG_DEBUG, " ");
1225 }
1226 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1227 }
1228 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1229 }
1230 }
1231
1232 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1233 const int shift= 1 + s->quarter_sample;
1234 int mb_y;
1235 uint8_t *ptr;
1236 int i;
1237 int h_chroma_shift, v_chroma_shift, block_height;
1238 const int width = s->avctx->width;
1239 const int height= s->avctx->height;
1240 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1241 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1242 s->low_delay=0; //needed to see the vectors without trashing the buffers
1243
1244 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1245 for(i=0; i<3; i++){
1246 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1247 pict->data[i]= s->visualization_buffer[i];
1248 }
1249 pict->type= FF_BUFFER_TYPE_COPY;
1250 ptr= pict->data[0];
1251 block_height = 16>>v_chroma_shift;
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;
1257 if((s->avctx->debug_mv) && pict->motion_val){
1258 int type;
1259 for(type=0; type<3; type++){
1260 int direction = 0;
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 }
1275 if(!USES_LIST(pict->mb_type[mb_index], direction))
1276 continue;
1277
1278 if(IS_8X8(pict->mb_type[mb_index])){
1279 int i;
1280 for(i=0; i<4; i++){
1281 int sx= mb_x*16 + 4 + 8*(i&1);
1282 int sy= mb_y*16 + 4 + 8*(i>>1);
1283 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1284 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1285 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1286 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1287 }
1288 }else if(IS_16X8(pict->mb_type[mb_index])){
1289 int i;
1290 for(i=0; i<2; i++){
1291 int sx=mb_x*16 + 8;
1292 int sy=mb_y*16 + 4 + 8*i;
1293 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1294 int mx=(pict->motion_val[direction][xy][0]>>shift);
1295 int my=(pict->motion_val[direction][xy][1]>>shift);
1296
1297 if(IS_INTERLACED(pict->mb_type[mb_index]))
1298 my*=2;
1299
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;
1307 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1308 int mx=(pict->motion_val[direction][xy][0]>>shift);
1309 int my=(pict->motion_val[direction][xy][1]>>shift);
1310
1311 if(IS_INTERLACED(pict->mb_type[mb_index]))
1312 my*=2;
1313
1314 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1315 }
1316 }else{
1317 int sx= mb_x*16 + 8;
1318 int sy= mb_y*16 + 8;
1319 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1320 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1321 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1322 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1323 }
1324 }
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;
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;
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)\
1339 u= (int)(128 + r*cos(theta*3.141592/180));\
1340 v= (int)(128 + r*sin(theta*3.141592/180));
1341
1342
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;
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;
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 }
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 }
1400
1401 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1402 // hmm
1403 }
1404 }
1405 s->mbskip_table[mb_index]=0;
1406 }
1407 }
1408 }
1409 }
1410
1411 static inline int hpel_motion_lowres(MpegEncContext *s,
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;
1421 const int op_index= FFMIN(lowres, 2);
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);
1435
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
1446 sx= (sx << 2) >> lowres;
1447 sy= (sy << 2) >> lowres;
1448 if(field_select)
1449 src += s->linesize;
1450 pix_op[op_index](dest, src, stride, h, sx, sy);
1451 return emu;
1452 }
1453
1454 /* apply one mpeg motion vector to the three components */
1455 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1456 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1457 int field_based, int bottom_field, int field_select,
1458 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1459 int motion_x, int motion_y, int h, int mb_y)
1460 {
1461 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
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;
1464 const int op_index= FFMIN(lowres, 2);
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;
1469 linesize = s->current_picture.linesize[0] << field_based;
1470 uvlinesize = s->current_picture.linesize[1] << field_based;
1471
1472 if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
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));
1484 src_y =( mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1485
1486 if (s->out_format == FMT_H263) {
1487 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1488 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
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);
1497 uvsrc_y = mb_y*block_s + (my >> lowres);
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));
1504 uvsrc_y =( mb_y*block_s>>field_based) + (my >> (lowres+1));
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;
1516 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1517 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1518 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1519 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1520 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
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
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
1539 sx= (sx << 2) >> lowres;
1540 sy= (sy << 2) >> lowres;
1541 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1542
1543 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
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);
1548 }
1549 //FIXME h261 lowres loop filter
1550 }
1551
1552 static 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;
1558 const int op_index= FFMIN(lowres, 2);
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;
1565
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);
1575
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));
1580
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 }
1590 }
1591 sx= (sx << 2) >> lowres;
1592 sy= (sy << 2) >> lowres;
1593 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1594
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 }
1600 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1601 }
1602
1603 /**
1604 * motion compensation of a single macroblock
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)
1612 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1613 */
1614 static inline void MPV_motion_lowres(MpegEncContext *s,
1615 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1616 int dir, uint8_t **ref_picture,
1617 h264_chroma_mc_func *pix_op)
1618 {
1619 int mx, my;
1620 int mb_x, mb_y, i;
1621 const int lowres= s->avctx->lowres;
1622 const int block_s= 8>>lowres;
1623
1624 mb_x = s->mb_x;
1625 mb_y = s->mb_y;
1626
1627 switch(s->mv_type) {
1628 case MV_TYPE_16X16:
1629 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1630 0, 0, 0,
1631 ref_picture, pix_op,
1632 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
1633 break;
1634 case MV_TYPE_8X8:
1635 mx = 0;
1636 my = 0;
1637 for(i=0;i<4;i++) {
1638 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1639 ref_picture[0], 0, 0,
1640 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1641 s->width, s->height, s->linesize,
1642 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1643 block_s, block_s, pix_op,
1644 s->mv[dir][i][0], s->mv[dir][i][1]);
1645
1646 mx += s->mv[dir][i][0];
1647 my += s->mv[dir][i][1];
1648 }
1649
1650 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1651 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1652 break;
1653 case MV_TYPE_FIELD:
1654 if (s->picture_structure == PICT_FRAME) {
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,
1659 s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
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,
1664 s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
1665 } else {
1666 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1667 ref_picture= s->current_picture_ptr->data;
1668 }
1669
1670 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1671 0, 0, s->field_select[dir][0],
1672 ref_picture, pix_op,
1673 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
1674 }
1675 break;
1676 case MV_TYPE_16X8:
1677 for(i=0; i<2; i++){
1678 uint8_t ** ref2picture;
1679
1680 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1681 ref2picture= ref_picture;
1682 }else{
1683 ref2picture= s->current_picture_ptr->data;
1684 }
1685
1686 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1687 0, 0, s->field_select[dir][i],
1688 ref2picture, pix_op,
1689 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
1690
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;
1694 }
1695 break;
1696 case MV_TYPE_DMV:
1697 if(s->picture_structure == PICT_FRAME){
1698 for(i=0; i<2; i++){
1699 int j;
1700 for(j=0; j<2; j++){
1701 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1702 1, j, j^i,
1703 ref_picture, pix_op,
1704 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
1705 }
1706 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1707 }
1708 }else{
1709 for(i=0; i<2; i++){
1710 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1711 0, 0, s->picture_structure != i+1,
1712 ref_picture, pix_op,
1713 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
1714
1715 // after put we make avg of the same block
1716 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1717
1718 //opposite parity is always in the same frame if this is second field
1719 if(!s->first_field){
1720 ref_picture = s->current_picture_ptr->data;
1721 }
1722 }
1723 }
1724 break;
1725 default: assert(0);
1726 }
1727 }
1728
1729 /* put block[] to dest[] */
1730 static inline void put_dct(MpegEncContext *s,
1731 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1732 {
1733 s->dct_unquantize_intra(s, block, i, qscale);
1734 s->dsp.idct_put (dest, line_size, block);
1735 }
1736
1737 /* add block[] to dest[] */
1738 static 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 }
1745
1746 static inline void add_dequant_dct(MpegEncContext *s,
1747 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1748 {
1749 if (s->block_last_index[i] >= 0) {
1750 s->dct_unquantize_inter(s, block, i, qscale);
1751
1752 s->dsp.idct_add (dest, line_size, block);
1753 }
1754 }
1755
1756 /**
1757 * cleans dc, ac, coded_block for the current non intra MB
1758 */
1759 void ff_clean_intra_table_entries(MpegEncContext *s)
1760 {
1761 int wrap = s->b8_stride;
1762 int xy = s->block_index[0];
1763
1764 s->dc_val[0][xy ] =
1765 s->dc_val[0][xy + 1 ] =
1766 s->dc_val[0][xy + wrap] =
1767 s->dc_val[0][xy + 1 + wrap] = 1024;
1768 /* ac pred */
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));
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 */
1778 wrap = s->mb_stride;
1779 xy = s->mb_x + s->mb_y * wrap;
1780 s->dc_val[1][xy] =
1781 s->dc_val[2][xy] = 1024;
1782 /* ac pred */
1783 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1784 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1785
1786 s->mbintra_table[xy]= 0;
1787 }
1788
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 */
1799 static av_always_inline
1800 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1801 int lowres_flag, int is_mpeg12)
1802 {
1803 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1804 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1805 ff_xvmc_decode_mb(s);//xvmc uses pblocks
1806 return;
1807 }
1808
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
1818 s->current_picture.qscale_table[mb_xy]= s->qscale;
1819
1820 /* update DC predictors for P macroblocks */
1821 if (!s->mb_intra) {
1822 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1823 if(s->mbintra_table[mb_xy])
1824 ff_clean_intra_table_entries(s);
1825 } else {
1826 s->last_dc[0] =
1827 s->last_dc[1] =
1828 s->last_dc[2] = 128 << s->intra_dc_precision;
1829 }
1830 }
1831 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1832 s->mbintra_table[mb_xy]=1;
1833
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
1835 uint8_t *dest_y, *dest_cb, *dest_cr;
1836 int dct_linesize, dct_offset;
1837 op_pixels_func (*op_pix)[4];
1838 qpel_mc_func (*op_qpix)[16];
1839 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1840 const int uvlinesize= s->current_picture.linesize[1];
1841 const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1842 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1843
1844 /* avoid copy if macroblock skipped in last frame too */
1845 /* skip only during decoding as we might trash the buffers during encoding a bit */
1846 if(!s->encoding){
1847 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1848 const int age= s->current_picture.age;
1849
1850 assert(age);
1851
1852 if (s->mb_skipped) {
1853 s->mb_skipped= 0;
1854 assert(s->pict_type!=FF_I_TYPE);
1855
1856 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1857 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1858
1859 /* if previous was skipped too, then nothing to do ! */
1860 if (*mbskip_ptr >= age && s->current_picture.reference){
1861 return;
1862 }
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{
1867 *mbskip_ptr = 0; /* not skipped */
1868 }
1869 }
1870
1871 dct_linesize = linesize << s->interlaced_dct;
1872 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1873
1874 if(readable){
1875 dest_y= s->dest[0];
1876 dest_cb= s->dest[1];
1877 dest_cr= s->dest[2];
1878 }else{
1879 dest_y = s->b_scratchpad;
1880 dest_cb= s->b_scratchpad+16*linesize;
1881 dest_cr= s->b_scratchpad+32*linesize;
1882 }
1883
1884 if (!s->mb_intra) {
1885 /* motion handling */
1886 /* decoding or more than one mb_type (MC was already done otherwise) */
1887 if(!s->encoding){
1888 if(lowres_flag){
1889 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1890
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{
1899 op_qpix= s->me.qpel_put;
1900 if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1901 op_pix = s->dsp.put_pixels_tab;
1902 }else{
1903 op_pix = s->dsp.put_no_rnd_pixels_tab;
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;
1908 op_qpix= s->me.qpel_avg;
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 }
1913 }
1914 }
1915
1916 /* skip dequant / idct if we are really late ;) */
1917 if(s->hurry_up>1) goto skip_idct;
1918 if(s->avctx->skip_idct){
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)
1921 || s->avctx->skip_idct >= AVDISCARD_ALL)
1922 goto skip_idct;
1923 }
1924
1925 /* add dct residue */
1926 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1927 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
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);
1932
1933 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
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 }
1945 }
1946 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
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);
1951
1952 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
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 }
1974 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
1975 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1976 }
1977 } else {
1978 /* dct only in intra block */
1979 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
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);
1984
1985 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
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);
1995 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1996 }
1997 }
1998 }else{
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]);
2003
2004 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
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{
2009
2010 dct_linesize = uvlinesize << s->interlaced_dct;
2011 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2012
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
2025 }
2026 }
2027 skip_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);
2032 }
2033 }
2034 }
2035
2036 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2037 #if !CONFIG_SMALL
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);
2045 }
2046
2047 /**
2048 *
2049 * @param h is the normal height, this will be reduced automatically if needed for the last row
2050 */
2051 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2052 if (s->avctx->draw_horiz_band) {
2053 AVFrame *src;
2054 const int field_pic= s->picture_structure != PICT_FRAME;
2055 int offset[4];
2056
2057 h= FFMIN(h, (s->avctx->height>>field_pic) - y);
2058
2059 if(field_pic && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)){
2060 h <<= 1;
2061 y <<= 1;
2062 if(s->first_field) return;
2063 }
2064
2065 if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
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;
2071
2072 if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2073 offset[0]=
2074 offset[1]=
2075 offset[2]=
2076 offset[3]= 0;
2077 }else{
2078 offset[0]= y * s->linesize;
2079 offset[1]=
2080 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2081 offset[3]= 0;
2082 }
2083
2084 emms_c();
2085
2086 s->avctx->draw_horiz_band(s->avctx, src, offset,
2087 y, s->picture_structure, h);
2088 }
2089 }
2090
2091 void 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;
2095
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
2103
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));
2107
2108 if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2109 {
2110 if(s->picture_structure==PICT_FRAME){
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);
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 }
2120 }
2121 }
2122
2123 void ff_mpeg_flush(AVCodecContext *avctx){
2124 int i;
2125 MpegEncContext *s = avctx->priv_data;
2126
2127 if(s==NULL || s->picture==NULL)
2128 return;
2129
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))
2133 free_frame_buffer(s, &s->picture[i]);
2134 }
2135 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2136
2137 s->mb_x= s->mb_y= 0;
2138 s->closed_gop= 0;
2139
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;
2148 }
2149
2150 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2151 DCTELEM *block, int n, int qscale)
2152 {
2153 int i, level, nCoeffs;
2154 const uint16_t *quant_matrix;
2155
2156 nCoeffs= s->block_last_index[n];
2157
2158 if (n < 4)
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;
2176 }
2177 block[j] = level;
2178 }
2179 }
2180 }
2181
2182 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
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];
2189
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;
2205 }
2206 block[j] = level;
2207 }
2208 }
2209 }
2210
2211 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2212 DCTELEM *block, int n, int qscale)
2213 {
2214 int i, level, nCoeffs;
2215 const uint16_t *quant_matrix;
2216
2217 if(s->alternate_scan) nCoeffs= 63;
2218 else nCoeffs= s->block_last_index[n];
2219
2220 if (n < 4)
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
2241 static 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
2274 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
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];
2283
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
2305 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2306 DCTELEM *block, int n, int qscale)
2307 {
2308 int i, level, qmul, qadd;
2309 int nCoeffs;
2310
2311 assert(s->block_last_index[n]>=0);
2312
2313 qmul = qscale << 1;
2314
2315 if (!s->h263_aic) {
2316 if (n < 4)
2317 block[0] = block[0] * s->y_dc_scale;
2318 else
2319 block[0] = block[0] * s->c_dc_scale;
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;
2336 }
2337 block[i] = level;
2338 }
2339 }
2340 }
2341
2342 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2343 DCTELEM *block, int n, int qscale)
2344 {
2345 int i, level, qmul, qadd;
2346 int nCoeffs;
2347
2348 assert(s->block_last_index[n]>=0);
2349
2350 qadd = (qscale - 1) | 1;
2351 qmul = qscale << 1;
2352
2353 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2354
2355 for(i=0; i<=nCoeffs; i++) {
2356 level = block[i];
2357 if (level) {
2358 if (level < 0) {
2359 level = level * qmul - qadd;
2360 } else {
2361 level = level * qmul + qadd;
2362 }
2363 block[i] = level;
2364 }
2365 }
2366 }
2367
2368 /**
2369 * set qscale and update qscale dependent variables.
2370 */
2371 void 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 }