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