4faf85f2068c93f701d7cd1089d7f9bdee29594d
[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->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, int use_static)
726 {
727 int i, q;
728
729 /* Return if static table is already initialized */
730 if(use_static && rl->rl_vlc[0])
731 return;
732
733 init_vlc(&rl->vlc, 9, rl->n + 1,
734 &rl->table_vlc[0][1], 4, 2,
735 &rl->table_vlc[0][0], 4, 2, use_static);
736
737
738 for(q=0; q<32; q++){
739 int qmul= q*2;
740 int qadd= (q-1)|1;
741
742 if(q==0){
743 qmul=1;
744 qadd=0;
745 }
746 if(use_static)
747 rl->rl_vlc[q]= av_mallocz_static(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
748 else
749 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
750 for(i=0; i<rl->vlc.table_size; i++){
751 int code= rl->vlc.table[i][0];
752 int len = rl->vlc.table[i][1];
753 int level, run;
754
755 if(len==0){ // illegal code
756 run= 66;
757 level= MAX_LEVEL;
758 }else if(len<0){ //more bits needed
759 run= 0;
760 level= code;
761 }else{
762 if(code==rl->n){ //esc
763 run= 66;
764 level= 0;
765 }else{
766 run= rl->table_run [code] + 1;
767 level= rl->table_level[code] * qmul + qadd;
768 if(code >= rl->last) run+=192;
769 }
770 }
771 rl->rl_vlc[q][i].len= len;
772 rl->rl_vlc[q][i].level= level;
773 rl->rl_vlc[q][i].run= run;
774 }
775 }
776 }
777
778 int ff_find_unused_picture(MpegEncContext *s, int shared){
779 int i;
780
781 if(shared){
782 for(i=0; i<MAX_PICTURE_COUNT; i++){
783 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
784 }
785 }else{
786 for(i=0; i<MAX_PICTURE_COUNT; i++){
787 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
788 }
789 for(i=0; i<MAX_PICTURE_COUNT; i++){
790 if(s->picture[i].data[0]==NULL) return i;
791 }
792 }
793
794 av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
795 /* We could return -1, but the codec would crash trying to draw into a
796 * non-existing frame anyway. This is safer than waiting for a random crash.
797 * Also the return of this is never useful, an encoder must only allocate
798 * as much as allowed in the specification. This has no relationship to how
799 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
800 * enough for such valid streams).
801 * Plus, a decoder has to check stream validity and remove frames if too
802 * many reference frames are around. Waiting for "OOM" is not correct at
803 * all. Similarly, missing reference frames have to be replaced by
804 * interpolated/MC frames, anything else is a bug in the codec ...
805 */
806 abort();
807 return -1;
808 }
809
810 static void update_noise_reduction(MpegEncContext *s){
811 int intra, i;
812
813 for(intra=0; intra<2; intra++){
814 if(s->dct_count[intra] > (1<<16)){
815 for(i=0; i<64; i++){
816 s->dct_error_sum[intra][i] >>=1;
817 }
818 s->dct_count[intra] >>= 1;
819 }
820
821 for(i=0; i<64; i++){
822 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);
823 }
824 }
825 }
826
827 /**
828 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
829 */
830 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
831 {
832 int i;
833 AVFrame *pic;
834 s->mb_skipped = 0;
835
836 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
837
838 /* mark&release old frames */
839 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]) {
840 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
841 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
842
843 /* release forgotten pictures */
844 /* if(mpeg124/h263) */
845 if(!s->encoding){
846 for(i=0; i<MAX_PICTURE_COUNT; i++){
847 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
848 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
849 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
850 }
851 }
852 }
853 }
854 }
855 alloc:
856 if(!s->encoding){
857 /* release non reference frames */
858 for(i=0; i<MAX_PICTURE_COUNT; i++){
859 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
860 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
861 }
862 }
863
864 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
865 pic= (AVFrame*)s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
866 else{
867 i= ff_find_unused_picture(s, 0);
868 pic= (AVFrame*)&s->picture[i];
869 }
870
871 pic->reference= 0;
872 if (!s->dropable){
873 if (s->codec_id == CODEC_ID_H264)
874 pic->reference = s->picture_structure;
875 else if (s->pict_type != FF_B_TYPE)
876 pic->reference = 3;
877 }
878
879 pic->coded_picture_number= s->coded_picture_number++;
880
881 if( alloc_picture(s, (Picture*)pic, 0) < 0)
882 return -1;
883
884 s->current_picture_ptr= (Picture*)pic;
885 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
886 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
887 }
888
889 s->current_picture_ptr->pict_type= s->pict_type;
890 // if(s->flags && CODEC_FLAG_QSCALE)
891 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
892 s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
893
894 copy_picture(&s->current_picture, s->current_picture_ptr);
895
896 if (s->pict_type != FF_B_TYPE) {
897 s->last_picture_ptr= s->next_picture_ptr;
898 if(!s->dropable)
899 s->next_picture_ptr= s->current_picture_ptr;
900 }
901 /* 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,
902 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
903 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
904 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
905 s->pict_type, s->dropable);*/
906
907 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
908 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
909
910 if(s->pict_type != FF_I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable){
911 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
912 assert(s->pict_type != FF_B_TYPE); //these should have been dropped if we don't have a reference
913 goto alloc;
914 }
915
916 assert(s->pict_type == FF_I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
917
918 if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
919 int i;
920 for(i=0; i<4; i++){
921 if(s->picture_structure == PICT_BOTTOM_FIELD){
922 s->current_picture.data[i] += s->current_picture.linesize[i];
923 }
924 s->current_picture.linesize[i] *= 2;
925 s->last_picture.linesize[i] *=2;
926 s->next_picture.linesize[i] *=2;
927 }
928 }
929
930 s->hurry_up= s->avctx->hurry_up;
931 s->error_resilience= avctx->error_resilience;
932
933 /* set dequantizer, we can't do it during init as it might change for mpeg4
934 and we can't do it in the header decode as init is not called for mpeg4 there yet */
935 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
936 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
937 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
938 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
939 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
940 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
941 }else{
942 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
943 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
944 }
945
946 if(s->dct_error_sum){
947 assert(s->avctx->noise_reduction && s->encoding);
948
949 update_noise_reduction(s);
950 }
951
952 #ifdef HAVE_XVMC
953 if(s->avctx->xvmc_acceleration)
954 return XVMC_field_start(s, avctx);
955 #endif
956 return 0;
957 }
958
959 /* generic function for encode/decode called after a frame has been coded/decoded */
960 void MPV_frame_end(MpegEncContext *s)
961 {
962 int i;
963 /* draw edge for correct motion prediction if outside */
964 #ifdef HAVE_XVMC
965 //just to make sure that all data is rendered.
966 if(s->avctx->xvmc_acceleration){
967 XVMC_field_end(s);
968 }else
969 #endif
970 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
971 s->dsp.draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
972 s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
973 s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
974 }
975 emms_c();
976
977 s->last_pict_type = s->pict_type;
978 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
979 if(s->pict_type!=FF_B_TYPE){
980 s->last_non_b_pict_type= s->pict_type;
981 }
982 #if 0
983 /* copy back current_picture variables */
984 for(i=0; i<MAX_PICTURE_COUNT; i++){
985 if(s->picture[i].data[0] == s->current_picture.data[0]){
986 s->picture[i]= s->current_picture;
987 break;
988 }
989 }
990 assert(i<MAX_PICTURE_COUNT);
991 #endif
992
993 if(s->encoding){
994 /* release non-reference frames */
995 for(i=0; i<MAX_PICTURE_COUNT; i++){
996 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
997 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
998 }
999 }
1000 }
1001 // clear copies, to avoid confusion
1002 #if 0
1003 memset(&s->last_picture, 0, sizeof(Picture));
1004 memset(&s->next_picture, 0, sizeof(Picture));
1005 memset(&s->current_picture, 0, sizeof(Picture));
1006 #endif
1007 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1008 }
1009
1010 /**
1011 * draws an line from (ex, ey) -> (sx, sy).
1012 * @param w width of the image
1013 * @param h height of the image
1014 * @param stride stride/linesize of the image
1015 * @param color color of the arrow
1016 */
1017 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1018 int x, y, fr, f;
1019
1020 sx= av_clip(sx, 0, w-1);
1021 sy= av_clip(sy, 0, h-1);
1022 ex= av_clip(ex, 0, w-1);
1023 ey= av_clip(ey, 0, h-1);
1024
1025 buf[sy*stride + sx]+= color;
1026
1027 if(FFABS(ex - sx) > FFABS(ey - sy)){
1028 if(sx > ex){
1029 FFSWAP(int, sx, ex);
1030 FFSWAP(int, sy, ey);
1031 }
1032 buf+= sx + sy*stride;
1033 ex-= sx;
1034 f= ((ey-sy)<<16)/ex;
1035 for(x= 0; x <= ex; x++){
1036 y = (x*f)>>16;
1037 fr= (x*f)&0xFFFF;
1038 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1039 buf[(y+1)*stride + x]+= (color* fr )>>16;
1040 }
1041 }else{
1042 if(sy > ey){
1043 FFSWAP(int, sx, ex);
1044 FFSWAP(int, sy, ey);
1045 }
1046 buf+= sx + sy*stride;
1047 ey-= sy;
1048 if(ey) f= ((ex-sx)<<16)/ey;
1049 else f= 0;
1050 for(y= 0; y <= ey; y++){
1051 x = (y*f)>>16;
1052 fr= (y*f)&0xFFFF;
1053 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1054 buf[y*stride + x+1]+= (color* fr )>>16;
1055 }
1056 }
1057 }
1058
1059 /**
1060 * draws an arrow from (ex, ey) -> (sx, sy).
1061 * @param w width of the image
1062 * @param h height of the image
1063 * @param stride stride/linesize of the image
1064 * @param color color of the arrow
1065 */
1066 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1067 int dx,dy;
1068
1069 sx= av_clip(sx, -100, w+100);
1070 sy= av_clip(sy, -100, h+100);
1071 ex= av_clip(ex, -100, w+100);
1072 ey= av_clip(ey, -100, h+100);
1073
1074 dx= ex - sx;
1075 dy= ey - sy;
1076
1077 if(dx*dx + dy*dy > 3*3){
1078 int rx= dx + dy;
1079 int ry= -dx + dy;
1080 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1081
1082 //FIXME subpixel accuracy
1083 rx= ROUNDED_DIV(rx*3<<4, length);
1084 ry= ROUNDED_DIV(ry*3<<4, length);
1085
1086 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1087 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1088 }
1089 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1090 }
1091
1092 /**
1093 * prints debuging info for the given picture.
1094 */
1095 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1096
1097 if(!pict || !pict->mb_type) return;
1098
1099 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1100 int x,y;
1101
1102 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1103 switch (pict->pict_type) {
1104 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1105 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1106 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1107 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1108 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1109 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1110 }
1111 for(y=0; y<s->mb_height; y++){
1112 for(x=0; x<s->mb_width; x++){
1113 if(s->avctx->debug&FF_DEBUG_SKIP){
1114 int count= s->mbskip_table[x + y*s->mb_stride];
1115 if(count>9) count=9;
1116 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1117 }
1118 if(s->avctx->debug&FF_DEBUG_QP){
1119 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1120 }
1121 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1122 int mb_type= pict->mb_type[x + y*s->mb_stride];
1123 //Type & MV direction
1124 if(IS_PCM(mb_type))
1125 av_log(s->avctx, AV_LOG_DEBUG, "P");
1126 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1127 av_log(s->avctx, AV_LOG_DEBUG, "A");
1128 else if(IS_INTRA4x4(mb_type))
1129 av_log(s->avctx, AV_LOG_DEBUG, "i");
1130 else if(IS_INTRA16x16(mb_type))
1131 av_log(s->avctx, AV_LOG_DEBUG, "I");
1132 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1133 av_log(s->avctx, AV_LOG_DEBUG, "d");
1134 else if(IS_DIRECT(mb_type))
1135 av_log(s->avctx, AV_LOG_DEBUG, "D");
1136 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1137 av_log(s->avctx, AV_LOG_DEBUG, "g");
1138 else if(IS_GMC(mb_type))
1139 av_log(s->avctx, AV_LOG_DEBUG, "G");
1140 else if(IS_SKIP(mb_type))
1141 av_log(s->avctx, AV_LOG_DEBUG, "S");
1142 else if(!USES_LIST(mb_type, 1))
1143 av_log(s->avctx, AV_LOG_DEBUG, ">");
1144 else if(!USES_LIST(mb_type, 0))
1145 av_log(s->avctx, AV_LOG_DEBUG, "<");
1146 else{
1147 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1148 av_log(s->avctx, AV_LOG_DEBUG, "X");
1149 }
1150
1151 //segmentation
1152 if(IS_8X8(mb_type))
1153 av_log(s->avctx, AV_LOG_DEBUG, "+");
1154 else if(IS_16X8(mb_type))
1155 av_log(s->avctx, AV_LOG_DEBUG, "-");
1156 else if(IS_8X16(mb_type))
1157 av_log(s->avctx, AV_LOG_DEBUG, "|");
1158 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1159 av_log(s->avctx, AV_LOG_DEBUG, " ");
1160 else
1161 av_log(s->avctx, AV_LOG_DEBUG, "?");
1162
1163
1164 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1165 av_log(s->avctx, AV_LOG_DEBUG, "=");
1166 else
1167 av_log(s->avctx, AV_LOG_DEBUG, " ");
1168 }
1169 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1170 }
1171 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1172 }
1173 }
1174
1175 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1176 const int shift= 1 + s->quarter_sample;
1177 int mb_y;
1178 uint8_t *ptr;
1179 int i;
1180 int h_chroma_shift, v_chroma_shift;
1181 const int width = s->avctx->width;
1182 const int height= s->avctx->height;
1183 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1184 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1185 s->low_delay=0; //needed to see the vectors without trashing the buffers
1186
1187 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1188 for(i=0; i<3; i++){
1189 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1190 pict->data[i]= s->visualization_buffer[i];
1191 }
1192 pict->type= FF_BUFFER_TYPE_COPY;
1193 ptr= pict->data[0];
1194
1195 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1196 int mb_x;
1197 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1198 const int mb_index= mb_x + mb_y*s->mb_stride;
1199 if((s->avctx->debug_mv) && pict->motion_val){
1200 int type;
1201 for(type=0; type<3; type++){
1202 int direction = 0;
1203 switch (type) {
1204 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1205 continue;
1206 direction = 0;
1207 break;
1208 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1209 continue;
1210 direction = 0;
1211 break;
1212 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1213 continue;
1214 direction = 1;
1215 break;
1216 }
1217 if(!USES_LIST(pict->mb_type[mb_index], direction))
1218 continue;
1219
1220 if(IS_8X8(pict->mb_type[mb_index])){
1221 int i;
1222 for(i=0; i<4; i++){
1223 int sx= mb_x*16 + 4 + 8*(i&1);
1224 int sy= mb_y*16 + 4 + 8*(i>>1);
1225 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1226 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1227 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1228 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1229 }
1230 }else if(IS_16X8(pict->mb_type[mb_index])){
1231 int i;
1232 for(i=0; i<2; i++){
1233 int sx=mb_x*16 + 8;
1234 int sy=mb_y*16 + 4 + 8*i;
1235 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1236 int mx=(pict->motion_val[direction][xy][0]>>shift);
1237 int my=(pict->motion_val[direction][xy][1]>>shift);
1238
1239 if(IS_INTERLACED(pict->mb_type[mb_index]))
1240 my*=2;
1241
1242 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1243 }
1244 }else if(IS_8X16(pict->mb_type[mb_index])){
1245 int i;
1246 for(i=0; i<2; i++){
1247 int sx=mb_x*16 + 4 + 8*i;
1248 int sy=mb_y*16 + 8;
1249 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1250 int mx=(pict->motion_val[direction][xy][0]>>shift);
1251 int my=(pict->motion_val[direction][xy][1]>>shift);
1252
1253 if(IS_INTERLACED(pict->mb_type[mb_index]))
1254 my*=2;
1255
1256 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1257 }
1258 }else{
1259 int sx= mb_x*16 + 8;
1260 int sy= mb_y*16 + 8;
1261 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1262 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1263 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1264 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1265 }
1266 }
1267 }
1268 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1269 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1270 int y;
1271 for(y=0; y<8; y++){
1272 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1273 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1274 }
1275 }
1276 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1277 int mb_type= pict->mb_type[mb_index];
1278 uint64_t u,v;
1279 int y;
1280 #define COLOR(theta, r)\
1281 u= (int)(128 + r*cos(theta*3.141592/180));\
1282 v= (int)(128 + r*sin(theta*3.141592/180));
1283
1284
1285 u=v=128;
1286 if(IS_PCM(mb_type)){
1287 COLOR(120,48)
1288 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1289 COLOR(30,48)
1290 }else if(IS_INTRA4x4(mb_type)){
1291 COLOR(90,48)
1292 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1293 // COLOR(120,48)
1294 }else if(IS_DIRECT(mb_type)){
1295 COLOR(150,48)
1296 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1297 COLOR(170,48)
1298 }else if(IS_GMC(mb_type)){
1299 COLOR(190,48)
1300 }else if(IS_SKIP(mb_type)){
1301 // COLOR(180,48)
1302 }else if(!USES_LIST(mb_type, 1)){
1303 COLOR(240,48)
1304 }else if(!USES_LIST(mb_type, 0)){
1305 COLOR(0,48)
1306 }else{
1307 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1308 COLOR(300,48)
1309 }
1310
1311 u*= 0x0101010101010101ULL;
1312 v*= 0x0101010101010101ULL;
1313 for(y=0; y<8; y++){
1314 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1315 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1316 }
1317
1318 //segmentation
1319 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1320 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1321 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1322 }
1323 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1324 for(y=0; y<16; y++)
1325 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1326 }
1327 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1328 int dm= 1 << (mv_sample_log2-2);
1329 for(i=0; i<4; i++){
1330 int sx= mb_x*16 + 8*(i&1);
1331 int sy= mb_y*16 + 8*(i>>1);
1332 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1333 //FIXME bidir
1334 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1335 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1336 for(y=0; y<8; y++)
1337 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1338 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1339 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1340 }
1341 }
1342
1343 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1344 // hmm
1345 }
1346 }
1347 s->mbskip_table[mb_index]=0;
1348 }
1349 }
1350 }
1351 }
1352
1353 static inline int hpel_motion_lowres(MpegEncContext *s,
1354 uint8_t *dest, uint8_t *src,
1355 int field_based, int field_select,
1356 int src_x, int src_y,
1357 int width, int height, int stride,
1358 int h_edge_pos, int v_edge_pos,
1359 int w, int h, h264_chroma_mc_func *pix_op,
1360 int motion_x, int motion_y)
1361 {
1362 const int lowres= s->avctx->lowres;
1363 const int s_mask= (2<<lowres)-1;
1364 int emu=0;
1365 int sx, sy;
1366
1367 if(s->quarter_sample){
1368 motion_x/=2;
1369 motion_y/=2;
1370 }
1371
1372 sx= motion_x & s_mask;
1373 sy= motion_y & s_mask;
1374 src_x += motion_x >> (lowres+1);
1375 src_y += motion_y >> (lowres+1);
1376
1377 src += src_y * stride + src_x;
1378
1379 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1380 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1381 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1382 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1383 src= s->edge_emu_buffer;
1384 emu=1;
1385 }
1386
1387 sx <<= 2 - lowres;
1388 sy <<= 2 - lowres;
1389 if(field_select)
1390 src += s->linesize;
1391 pix_op[lowres](dest, src, stride, h, sx, sy);
1392 return emu;
1393 }
1394
1395 /* apply one mpeg motion vector to the three components */
1396 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1397 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1398 int field_based, int bottom_field, int field_select,
1399 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1400 int motion_x, int motion_y, int h)
1401 {
1402 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1403 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1404 const int lowres= s->avctx->lowres;
1405 const int block_s= 8>>lowres;
1406 const int s_mask= (2<<lowres)-1;
1407 const int h_edge_pos = s->h_edge_pos >> lowres;
1408 const int v_edge_pos = s->v_edge_pos >> lowres;
1409 linesize = s->current_picture.linesize[0] << field_based;
1410 uvlinesize = s->current_picture.linesize[1] << field_based;
1411
1412 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
1413 motion_x/=2;
1414 motion_y/=2;
1415 }
1416
1417 if(field_based){
1418 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1419 }
1420
1421 sx= motion_x & s_mask;
1422 sy= motion_y & s_mask;
1423 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1424 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1425
1426 if (s->out_format == FMT_H263) {
1427 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1428 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1429 uvsrc_x = src_x>>1;
1430 uvsrc_y = src_y>>1;
1431 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1432 mx = motion_x / 4;
1433 my = motion_y / 4;
1434 uvsx = (2*mx) & s_mask;
1435 uvsy = (2*my) & s_mask;
1436 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1437 uvsrc_y = s->mb_y*block_s + (my >> lowres);
1438 } else {
1439 mx = motion_x / 2;
1440 my = motion_y / 2;
1441 uvsx = mx & s_mask;
1442 uvsy = my & s_mask;
1443 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1444 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1445 }
1446
1447 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1448 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1449 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1450
1451 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1452 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1453 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1454 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1455 ptr_y = s->edge_emu_buffer;
1456 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1457 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1458 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1459 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1460 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1461 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1462 ptr_cb= uvbuf;
1463 ptr_cr= uvbuf+16;
1464 }
1465 }
1466
1467 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1468 dest_y += s->linesize;
1469 dest_cb+= s->uvlinesize;
1470 dest_cr+= s->uvlinesize;
1471 }
1472
1473 if(field_select){
1474 ptr_y += s->linesize;
1475 ptr_cb+= s->uvlinesize;
1476 ptr_cr+= s->uvlinesize;
1477 }
1478
1479 sx <<= 2 - lowres;
1480 sy <<= 2 - lowres;
1481 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1482
1483 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1484 uvsx <<= 2 - lowres;
1485 uvsy <<= 2 - lowres;
1486 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1487 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1488 }
1489 //FIXME h261 lowres loop filter
1490 }
1491
1492 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1493 uint8_t *dest_cb, uint8_t *dest_cr,
1494 uint8_t **ref_picture,
1495 h264_chroma_mc_func *pix_op,
1496 int mx, int my){
1497 const int lowres= s->avctx->lowres;
1498 const int block_s= 8>>lowres;
1499 const int s_mask= (2<<lowres)-1;
1500 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1501 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1502 int emu=0, src_x, src_y, offset, sx, sy;
1503 uint8_t *ptr;
1504
1505 if(s->quarter_sample){
1506 mx/=2;
1507 my/=2;
1508 }
1509
1510 /* In case of 8X8, we construct a single chroma motion vector
1511 with a special rounding */
1512 mx= ff_h263_round_chroma(mx);
1513 my= ff_h263_round_chroma(my);
1514
1515 sx= mx & s_mask;
1516 sy= my & s_mask;
1517 src_x = s->mb_x*block_s + (mx >> (lowres+1));
1518 src_y = s->mb_y*block_s + (my >> (lowres+1));
1519
1520 offset = src_y * s->uvlinesize + src_x;
1521 ptr = ref_picture[1] + offset;
1522 if(s->flags&CODEC_FLAG_EMU_EDGE){
1523 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1524 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1525 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1526 ptr= s->edge_emu_buffer;
1527 emu=1;
1528 }
1529 }
1530 sx <<= 2 - lowres;
1531 sy <<= 2 - lowres;
1532 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1533
1534 ptr = ref_picture[2] + offset;
1535 if(emu){
1536 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1537 ptr= s->edge_emu_buffer;
1538 }
1539 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1540 }
1541
1542 /**
1543 * motion compensation of a single macroblock
1544 * @param s context
1545 * @param dest_y luma destination pointer
1546 * @param dest_cb chroma cb/u destination pointer
1547 * @param dest_cr chroma cr/v destination pointer
1548 * @param dir direction (0->forward, 1->backward)
1549 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1550 * @param pic_op halfpel motion compensation function (average or put normally)
1551 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1552 */
1553 static inline void MPV_motion_lowres(MpegEncContext *s,
1554 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1555 int dir, uint8_t **ref_picture,
1556 h264_chroma_mc_func *pix_op)
1557 {
1558 int mx, my;
1559 int mb_x, mb_y, i;
1560 const int lowres= s->avctx->lowres;
1561 const int block_s= 8>>lowres;
1562
1563 mb_x = s->mb_x;
1564 mb_y = s->mb_y;
1565
1566 switch(s->mv_type) {
1567 case MV_TYPE_16X16:
1568 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1569 0, 0, 0,
1570 ref_picture, pix_op,
1571 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1572 break;
1573 case MV_TYPE_8X8:
1574 mx = 0;
1575 my = 0;
1576 for(i=0;i<4;i++) {
1577 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1578 ref_picture[0], 0, 0,
1579 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1580 s->width, s->height, s->linesize,
1581 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1582 block_s, block_s, pix_op,
1583 s->mv[dir][i][0], s->mv[dir][i][1]);
1584
1585 mx += s->mv[dir][i][0];
1586 my += s->mv[dir][i][1];
1587 }
1588
1589 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1590 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1591 break;
1592 case MV_TYPE_FIELD:
1593 if (s->picture_structure == PICT_FRAME) {
1594 /* top field */
1595 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1596 1, 0, s->field_select[dir][0],
1597 ref_picture, pix_op,
1598 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1599 /* bottom field */
1600 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1601 1, 1, s->field_select[dir][1],
1602 ref_picture, pix_op,
1603 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1604 } else {
1605 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1606 ref_picture= s->current_picture_ptr->data;
1607 }
1608
1609 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1610 0, 0, s->field_select[dir][0],
1611 ref_picture, pix_op,
1612 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1613 }
1614 break;
1615 case MV_TYPE_16X8:
1616 for(i=0; i<2; i++){
1617 uint8_t ** ref2picture;
1618
1619 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1620 ref2picture= ref_picture;
1621 }else{
1622 ref2picture= s->current_picture_ptr->data;
1623 }
1624
1625 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1626 0, 0, s->field_select[dir][i],
1627 ref2picture, pix_op,
1628 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1629
1630 dest_y += 2*block_s*s->linesize;
1631 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1632 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1633 }
1634 break;
1635 case MV_TYPE_DMV:
1636 if(s->picture_structure == PICT_FRAME){
1637 for(i=0; i<2; i++){
1638 int j;
1639 for(j=0; j<2; j++){
1640 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1641 1, j, j^i,
1642 ref_picture, pix_op,
1643 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1644 }
1645 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1646 }
1647 }else{
1648 for(i=0; i<2; i++){
1649 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1650 0, 0, s->picture_structure != i+1,
1651 ref_picture, pix_op,
1652 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1653
1654 // after put we make avg of the same block
1655 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1656
1657 //opposite parity is always in the same frame if this is second field
1658 if(!s->first_field){
1659 ref_picture = s->current_picture_ptr->data;
1660 }
1661 }
1662 }
1663 break;
1664 default: assert(0);
1665 }
1666 }
1667
1668 /* put block[] to dest[] */
1669 static inline void put_dct(MpegEncContext *s,
1670 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1671 {
1672 s->dct_unquantize_intra(s, block, i, qscale);
1673 s->dsp.idct_put (dest, line_size, block);
1674 }
1675
1676 /* add block[] to dest[] */
1677 static inline void add_dct(MpegEncContext *s,
1678 DCTELEM *block, int i, uint8_t *dest, int line_size)
1679 {
1680 if (s->block_last_index[i] >= 0) {
1681 s->dsp.idct_add (dest, line_size, block);
1682 }
1683 }
1684
1685 static inline void add_dequant_dct(MpegEncContext *s,
1686 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1687 {
1688 if (s->block_last_index[i] >= 0) {
1689 s->dct_unquantize_inter(s, block, i, qscale);
1690
1691 s->dsp.idct_add (dest, line_size, block);
1692 }
1693 }
1694
1695 /**
1696 * cleans dc, ac, coded_block for the current non intra MB
1697 */
1698 void ff_clean_intra_table_entries(MpegEncContext *s)
1699 {
1700 int wrap = s->b8_stride;
1701 int xy = s->block_index[0];
1702
1703 s->dc_val[0][xy ] =
1704 s->dc_val[0][xy + 1 ] =
1705 s->dc_val[0][xy + wrap] =
1706 s->dc_val[0][xy + 1 + wrap] = 1024;
1707 /* ac pred */
1708 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1709 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1710 if (s->msmpeg4_version>=3) {
1711 s->coded_block[xy ] =
1712 s->coded_block[xy + 1 ] =
1713 s->coded_block[xy + wrap] =
1714 s->coded_block[xy + 1 + wrap] = 0;
1715 }
1716 /* chroma */
1717 wrap = s->mb_stride;
1718 xy = s->mb_x + s->mb_y * wrap;
1719 s->dc_val[1][xy] =
1720 s->dc_val[2][xy] = 1024;
1721 /* ac pred */
1722 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1723 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1724
1725 s->mbintra_table[xy]= 0;
1726 }
1727
1728 /* generic function called after a macroblock has been parsed by the
1729 decoder or after it has been encoded by the encoder.
1730
1731 Important variables used:
1732 s->mb_intra : true if intra macroblock
1733 s->mv_dir : motion vector direction
1734 s->mv_type : motion vector type
1735 s->mv : motion vector
1736 s->interlaced_dct : true if interlaced dct used (mpeg2)
1737 */
1738 static av_always_inline
1739 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1740 int lowres_flag, int is_mpeg12)
1741 {
1742 int mb_x, mb_y;
1743 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1744 #ifdef HAVE_XVMC
1745 if(s->avctx->xvmc_acceleration){
1746 XVMC_decode_mb(s);//xvmc uses pblocks
1747 return;
1748 }
1749 #endif
1750
1751 mb_x = s->mb_x;
1752 mb_y = s->mb_y;
1753
1754 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1755 /* save DCT coefficients */
1756 int i,j;
1757 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1758 for(i=0; i<6; i++)
1759 for(j=0; j<64; j++)
1760 *dct++ = block[i][s->dsp.idct_permutation[j]];
1761 }
1762
1763 s->current_picture.qscale_table[mb_xy]= s->qscale;
1764
1765 /* update DC predictors for P macroblocks */
1766 if (!s->mb_intra) {
1767 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1768 if(s->mbintra_table[mb_xy])
1769 ff_clean_intra_table_entries(s);
1770 } else {
1771 s->last_dc[0] =
1772 s->last_dc[1] =
1773 s->last_dc[2] = 128 << s->intra_dc_precision;
1774 }
1775 }
1776 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1777 s->mbintra_table[mb_xy]=1;
1778
1779 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
1780 uint8_t *dest_y, *dest_cb, *dest_cr;
1781 int dct_linesize, dct_offset;
1782 op_pixels_func (*op_pix)[4];
1783 qpel_mc_func (*op_qpix)[16];
1784 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1785 const int uvlinesize= s->current_picture.linesize[1];
1786 const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1787 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1788
1789 /* avoid copy if macroblock skipped in last frame too */
1790 /* skip only during decoding as we might trash the buffers during encoding a bit */
1791 if(!s->encoding){
1792 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1793 const int age= s->current_picture.age;
1794
1795 assert(age);
1796
1797 if (s->mb_skipped) {
1798 s->mb_skipped= 0;
1799 assert(s->pict_type!=FF_I_TYPE);
1800
1801 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1802 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1803
1804 /* if previous was skipped too, then nothing to do ! */
1805 if (*mbskip_ptr >= age && s->current_picture.reference){
1806 return;
1807 }
1808 } else if(!s->current_picture.reference){
1809 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1810 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1811 } else{
1812 *mbskip_ptr = 0; /* not skipped */
1813 }
1814 }
1815
1816 dct_linesize = linesize << s->interlaced_dct;
1817 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1818
1819 if(readable){
1820 dest_y= s->dest[0];
1821 dest_cb= s->dest[1];
1822 dest_cr= s->dest[2];
1823 }else{
1824 dest_y = s->b_scratchpad;
1825 dest_cb= s->b_scratchpad+16*linesize;
1826 dest_cr= s->b_scratchpad+32*linesize;
1827 }
1828
1829 if (!s->mb_intra) {
1830 /* motion handling */
1831 /* decoding or more than one mb_type (MC was already done otherwise) */
1832 if(!s->encoding){
1833 if(lowres_flag){
1834 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1835
1836 if (s->mv_dir & MV_DIR_FORWARD) {
1837 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1838 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1839 }
1840 if (s->mv_dir & MV_DIR_BACKWARD) {
1841 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1842 }
1843 }else{
1844 op_qpix= s->me.qpel_put;
1845 if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1846 op_pix = s->dsp.put_pixels_tab;
1847 }else{
1848 op_pix = s->dsp.put_no_rnd_pixels_tab;
1849 }
1850 if (s->mv_dir & MV_DIR_FORWARD) {
1851 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1852 op_pix = s->dsp.avg_pixels_tab;
1853 op_qpix= s->me.qpel_avg;
1854 }
1855 if (s->mv_dir & MV_DIR_BACKWARD) {
1856 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1857 }
1858 }
1859 }
1860
1861 /* skip dequant / idct if we are really late ;) */
1862 if(s->hurry_up>1) goto skip_idct;
1863 if(s->avctx->skip_idct){
1864 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1865 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1866 || s->avctx->skip_idct >= AVDISCARD_ALL)
1867 goto skip_idct;
1868 }
1869
1870 /* add dct residue */
1871 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1872 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1873 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1874 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1875 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1876 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1877
1878 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1879 if (s->chroma_y_shift){
1880 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1881 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1882 }else{
1883 dct_linesize >>= 1;
1884 dct_offset >>=1;
1885 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1886 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1887 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1888 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1889 }
1890 }
1891 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
1892 add_dct(s, block[0], 0, dest_y , dct_linesize);
1893 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
1894 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
1895 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1896
1897 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1898 if(s->chroma_y_shift){//Chroma420
1899 add_dct(s, block[4], 4, dest_cb, uvlinesize);
1900 add_dct(s, block[5], 5, dest_cr, uvlinesize);
1901 }else{
1902 //chroma422
1903 dct_linesize = uvlinesize << s->interlaced_dct;
1904 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1905
1906 add_dct(s, block[4], 4, dest_cb, dct_linesize);
1907 add_dct(s, block[5], 5, dest_cr, dct_linesize);
1908 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1909 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1910 if(!s->chroma_x_shift){//Chroma444
1911 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1912 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1913 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1914 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1915 }
1916 }
1917 }//fi gray
1918 }
1919 else if (ENABLE_WMV2) {
1920 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1921 }
1922 } else {
1923 /* dct only in intra block */
1924 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1925 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1926 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1927 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1928 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1929
1930 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1931 if(s->chroma_y_shift){
1932 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1933 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1934 }else{
1935 dct_offset >>=1;
1936 dct_linesize >>=1;
1937 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1938 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1939 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1940 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1941 }
1942 }
1943 }else{
1944 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
1945 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
1946 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
1947 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1948
1949 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1950 if(s->chroma_y_shift){
1951 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
1952 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
1953 }else{
1954
1955 dct_linesize = uvlinesize << s->interlaced_dct;
1956 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1957
1958 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
1959 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
1960 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
1961 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
1962 if(!s->chroma_x_shift){//Chroma444
1963 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
1964 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
1965 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
1966 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
1967 }
1968 }
1969 }//gray
1970 }
1971 }
1972 skip_idct:
1973 if(!readable){
1974 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
1975 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
1976 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
1977 }
1978 }
1979 }
1980
1981 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
1982 #ifndef CONFIG_SMALL
1983 if(s->out_format == FMT_MPEG1) {
1984 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
1985 else MPV_decode_mb_internal(s, block, 0, 1);
1986 } else
1987 #endif
1988 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
1989 else MPV_decode_mb_internal(s, block, 0, 0);
1990 }
1991
1992 /**
1993 *
1994 * @param h is the normal height, this will be reduced automatically if needed for the last row
1995 */
1996 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
1997 if (s->avctx->draw_horiz_band) {
1998 AVFrame *src;
1999 int offset[4];
2000
2001 if(s->picture_structure != PICT_FRAME){
2002 h <<= 1;
2003 y <<= 1;
2004 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2005 }
2006
2007 h= FFMIN(h, s->avctx->height - y);
2008
2009 if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2010 src= (AVFrame*)s->current_picture_ptr;
2011 else if(s->last_picture_ptr)
2012 src= (AVFrame*)s->last_picture_ptr;
2013 else
2014 return;
2015
2016 if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2017 offset[0]=
2018 offset[1]=
2019 offset[2]=
2020 offset[3]= 0;
2021 }else{
2022 offset[0]= y * s->linesize;
2023 offset[1]=
2024 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2025 offset[3]= 0;
2026 }
2027
2028 emms_c();
2029
2030 s->avctx->draw_horiz_band(s->avctx, src, offset,
2031 y, s->picture_structure, h);
2032 }
2033 }
2034
2035 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2036 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2037 const int uvlinesize= s->current_picture.linesize[1];
2038 const int mb_size= 4 - s->avctx->lowres;
2039
2040 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2041 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2042 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2043 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2044 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2045 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;
2046 //block_index is not used by mpeg2, so it is not affected by chroma_format
2047
2048 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2049 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2050 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2051
2052 if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2053 {
2054 s->dest[0] += s->mb_y * linesize << mb_size;
2055 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2056 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2057 }
2058 }
2059
2060 void ff_mpeg_flush(AVCodecContext *avctx){
2061 int i;
2062 MpegEncContext *s = avctx->priv_data;
2063
2064 if(s==NULL || s->picture==NULL)
2065 return;
2066
2067 for(i=0; i<MAX_PICTURE_COUNT; i++){
2068 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2069 || s->picture[i].type == FF_BUFFER_TYPE_USER))
2070 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2071 }
2072 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2073
2074 s->mb_x= s->mb_y= 0;
2075
2076 s->parse_context.state= -1;
2077 s->parse_context.frame_start_found= 0;
2078 s->parse_context.overread= 0;
2079 s->parse_context.overread_index= 0;
2080 s->parse_context.index= 0;
2081 s->parse_context.last_index= 0;
2082 s->bitstream_buffer_size=0;
2083 s->pp_time=0;
2084 }
2085
2086 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2087 DCTELEM *block, int n, int qscale)
2088 {
2089 int i, level, nCoeffs;
2090 const uint16_t *quant_matrix;
2091
2092 nCoeffs= s->block_last_index[n];
2093
2094 if (n < 4)
2095 block[0] = block[0] * s->y_dc_scale;
2096 else
2097 block[0] = block[0] * s->c_dc_scale;
2098 /* XXX: only mpeg1 */
2099 quant_matrix = s->intra_matrix;
2100 for(i=1;i<=nCoeffs;i++) {
2101 int j= s->intra_scantable.permutated[i];
2102 level = block[j];
2103 if (level) {
2104 if (level < 0) {
2105 level = -level;
2106 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2107 level = (level - 1) | 1;
2108 level = -level;
2109 } else {
2110 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2111 level = (level - 1) | 1;
2112 }
2113 block[j] = level;
2114 }
2115 }
2116 }
2117
2118 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2119 DCTELEM *block, int n, int qscale)
2120 {
2121 int i, level, nCoeffs;
2122 const uint16_t *quant_matrix;
2123
2124 nCoeffs= s->block_last_index[n];
2125
2126 quant_matrix = s->inter_matrix;
2127 for(i=0; i<=nCoeffs; i++) {
2128 int j= s->intra_scantable.permutated[i];
2129 level = block[j];
2130 if (level) {
2131 if (level < 0) {
2132 level = -level;
2133 level = (((level << 1) + 1) * qscale *
2134 ((int) (quant_matrix[j]))) >> 4;
2135 level = (level - 1) | 1;
2136 level = -level;
2137 } else {
2138 level = (((level << 1) + 1) * qscale *
2139 ((int) (quant_matrix[j]))) >> 4;
2140 level = (level - 1) | 1;
2141 }
2142 block[j] = level;
2143 }
2144 }
2145 }
2146
2147 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2148 DCTELEM *block, int n, int qscale)
2149 {
2150 int i, level, nCoeffs;
2151 const uint16_t *quant_matrix;
2152
2153 if(s->alternate_scan) nCoeffs= 63;
2154 else nCoeffs= s->block_last_index[n];
2155
2156 if (n < 4)
2157 block[0] = block[0] * s->y_dc_scale;
2158 else
2159 block[0] = block[0] * s->c_dc_scale;
2160 quant_matrix = s->intra_matrix;
2161 for(i=1;i<=nCoeffs;i++) {
2162 int j= s->intra_scantable.permutated[i];
2163 level = block[j];
2164 if (level) {
2165 if (level < 0) {
2166 level = -level;
2167 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2168 level = -level;
2169 } else {
2170 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2171 }
2172 block[j] = level;
2173 }
2174 }
2175 }
2176
2177 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2178 DCTELEM *block, int n, int qscale)
2179 {
2180 int i, level, nCoeffs;
2181 const uint16_t *quant_matrix;
2182 int sum=-1;
2183
2184 if(s->alternate_scan) nCoeffs= 63;
2185 else nCoeffs= s->block_last_index[n];
2186
2187 if (n < 4)
2188 block[0] = block[0] * s->y_dc_scale;
2189 else
2190 block[0] = block[0] * s->c_dc_scale;
2191 quant_matrix = s->intra_matrix;
2192 for(i=1;i<=nCoeffs;i++) {
2193 int j= s->intra_scantable.permutated[i];
2194 level = block[j];
2195 if (level) {
2196 if (level < 0) {
2197 level = -level;
2198 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2199 level = -level;
2200 } else {
2201 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2202 }
2203 block[j] = level;
2204 sum+=level;
2205 }
2206 }
2207 block[63]^=sum&1;
2208 }
2209
2210 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2211 DCTELEM *block, int n, int qscale)
2212 {
2213 int i, level, nCoeffs;
2214 const uint16_t *quant_matrix;
2215 int sum=-1;
2216
2217 if(s->alternate_scan) nCoeffs= 63;
2218 else nCoeffs= s->block_last_index[n];
2219
2220 quant_matrix = s->inter_matrix;
2221 for(i=0; i<=nCoeffs; i++) {
2222 int j= s->intra_scantable.permutated[i];
2223 level = block[j];
2224 if (level) {
2225 if (level < 0) {
2226 level = -level;
2227 level = (((level << 1) + 1) * qscale *
2228 ((int) (quant_matrix[j]))) >> 4;
2229 level = -level;
2230 } else {
2231 level = (((level << 1) + 1) * qscale *
2232 ((int) (quant_matrix[j]))) >> 4;
2233 }
2234 block[j] = level;
2235 sum+=level;
2236 }
2237 }
2238 block[63]^=sum&1;
2239 }
2240
2241 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2242 DCTELEM *block, int n, int qscale)
2243 {
2244 int i, level, qmul, qadd;
2245 int nCoeffs;
2246
2247 assert(s->block_last_index[n]>=0);
2248
2249 qmul = qscale << 1;
2250
2251 if (!s->h263_aic) {
2252 if (n < 4)
2253 block[0] = block[0] * s->y_dc_scale;
2254 else
2255 block[0] = block[0] * s->c_dc_scale;
2256 qadd = (qscale - 1) | 1;
2257 }else{
2258 qadd = 0;
2259 }
2260 if(s->ac_pred)
2261 nCoeffs=63;
2262 else
2263 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2264
2265 for(i=1; i<=nCoeffs; i++) {
2266 level = block[i];
2267 if (level) {
2268 if (level < 0) {
2269 level = level * qmul - qadd;
2270 } else {
2271 level = level * qmul + qadd;
2272 }
2273 block[i] = level;
2274 }
2275 }
2276 }
2277
2278 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2279 DCTELEM *block, int n, int qscale)
2280 {
2281 int i, level, qmul, qadd;
2282 int nCoeffs;
2283
2284 assert(s->block_last_index[n]>=0);
2285
2286 qadd = (qscale - 1) | 1;
2287 qmul = qscale << 1;
2288
2289 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2290
2291 for(i=0; i<=nCoeffs; i++) {
2292 level = block[i];
2293 if (level) {
2294 if (level < 0) {
2295 level = level * qmul - qadd;
2296 } else {
2297 level = level * qmul + qadd;
2298 }
2299 block[i] = level;
2300 }
2301 }
2302 }
2303
2304 /**
2305 * set qscale and update qscale dependent variables.
2306 */
2307 void ff_set_qscale(MpegEncContext * s, int qscale)
2308 {
2309 if (qscale < 1)
2310 qscale = 1;
2311 else if (qscale > 31)
2312 qscale = 31;
2313
2314 s->qscale = qscale;
2315 s->chroma_qscale= s->chroma_qscale_table[qscale];
2316
2317 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2318 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2319 }