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>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
25 * The simplest mpeg encoder (well, it was the simplest!).
30 #include "mpegvideo.h"
35 #include "fastmemcpy.h"
41 #ifdef CONFIG_ENCODERS
42 static void encode_picture(MpegEncContext *s, int picture_number);
43 #endif //CONFIG_ENCODERS
44 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
45 DCTELEM *block, int n, int qscale);
46 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
47 DCTELEM *block, int n, int qscale);
48 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
49 DCTELEM *block, int n, int qscale);
50 static void dct_unquantize_mpeg2_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 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
57 #ifdef CONFIG_ENCODERS
58 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
59 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
60 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
61 static int sse_mb(MpegEncContext *s);
62 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
63 #endif //CONFIG_ENCODERS
66 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
67 extern void XVMC_field_end(MpegEncContext *s);
68 extern void XVMC_decode_mb(MpegEncContext *s);
71 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
74 /* enable all paranoid tests for rounding, overflows, etc... */
80 /* for jpeg fast DCT */
83 static const uint16_t aanscales[64] = {
84 /* precomputed values scaled up by 14 bits */
85 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
86 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
87 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
88 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
89 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
90 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
91 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
92 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
95 static const uint8_t h263_chroma_roundtab[16] = {
96 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
97 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
100 static const uint8_t ff_default_chroma_qscale_table[32]={
101 // 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
102 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
105 #ifdef CONFIG_ENCODERS
106 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
107 static uint8_t default_fcode_tab[MAX_MV*2+1];
109 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
111 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
112 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
117 for(qscale=qmin; qscale<=qmax; qscale++){
119 if (dsp->fdct == ff_jpeg_fdct_islow
120 #ifdef FAAN_POSTSCALE
121 || dsp->fdct == ff_faandct
125 const int j= dsp->idct_permutation[i];
126 /* 16 <= qscale * quant_matrix[i] <= 7905 */
127 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
128 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
129 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
131 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
132 (qscale * quant_matrix[j]));
134 } else if (dsp->fdct == fdct_ifast
135 #ifndef FAAN_POSTSCALE
136 || dsp->fdct == ff_faandct
140 const int j= dsp->idct_permutation[i];
141 /* 16 <= qscale * quant_matrix[i] <= 7905 */
142 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
143 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
144 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
146 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
147 (aanscales[i] * qscale * quant_matrix[j]));
151 const int j= dsp->idct_permutation[i];
152 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
153 So 16 <= qscale * quant_matrix[i] <= 7905
154 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
155 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
157 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
158 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
159 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
161 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
162 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
166 for(i=intra; i<64; i++){
168 if (dsp->fdct == fdct_ifast
169 #ifndef FAAN_POSTSCALE
170 || dsp->fdct == ff_faandct
173 max= (8191LL*aanscales[i]) >> 14;
175 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
181 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger then %d, overflows possible\n", QMAT_SHIFT - shift);
185 static inline void update_qscale(MpegEncContext *s){
186 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
187 s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
189 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
191 #endif //CONFIG_ENCODERS
193 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
197 st->scantable= src_scantable;
201 j = src_scantable[i];
202 st->permutated[i] = permutation[j];
211 j = st->permutated[i];
213 st->raster_end[i]= end;
217 #ifdef CONFIG_ENCODERS
218 void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
224 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
229 #endif //CONFIG_ENCODERS
231 /* init common dct for both encoder and decoder */
232 int DCT_common_init(MpegEncContext *s)
234 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
235 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
236 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
237 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
238 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
239 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
241 #ifdef CONFIG_ENCODERS
242 s->dct_quantize= dct_quantize_c;
243 s->denoise_dct= denoise_dct_c;
247 MPV_common_init_mmx(s);
250 MPV_common_init_axp(s);
253 MPV_common_init_mlib(s);
256 MPV_common_init_mmi(s);
259 MPV_common_init_armv4l(s);
262 MPV_common_init_ppc(s);
265 #ifdef CONFIG_ENCODERS
266 s->fast_dct_quantize= s->dct_quantize;
268 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
269 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
272 #endif //CONFIG_ENCODERS
274 /* load & permutate scantables
275 note: only wmv uses differnt ones
277 if(s->alternate_scan){
278 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
279 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
281 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
282 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
284 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
285 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
290 static void copy_picture(Picture *dst, Picture *src){
292 dst->type= FF_BUFFER_TYPE_COPY;
295 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
298 dst->pict_type = src->pict_type;
299 dst->quality = src->quality;
300 dst->coded_picture_number = src->coded_picture_number;
301 dst->display_picture_number = src->display_picture_number;
302 // dst->reference = src->reference;
304 dst->interlaced_frame = src->interlaced_frame;
305 dst->top_field_first = src->top_field_first;
307 if(s->avctx->me_threshold){
308 if(!src->motion_val[0])
309 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
311 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
312 if(!src->ref_index[0])
313 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
314 if(src->motion_subsample_log2 != dst->motion_subsample_log2)
315 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesnt match! (%d!=%d)\n",
316 src->motion_subsample_log2, dst->motion_subsample_log2);
318 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
321 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
322 int height= ((16*s->mb_height)>>src->motion_subsample_log2);
324 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
325 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
327 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
328 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
335 * allocates a Picture
336 * The pixels are allocated/set by calling get_buffer() if shared=0
338 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
339 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
340 const int mb_array_size= s->mb_stride*s->mb_height;
341 const int b8_array_size= s->b8_stride*s->mb_height*2;
342 const int b4_array_size= s->b4_stride*s->mb_height*4;
346 assert(pic->data[0]);
347 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
348 pic->type= FF_BUFFER_TYPE_SHARED;
352 assert(!pic->data[0]);
354 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
356 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
357 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
361 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
362 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
366 if(pic->linesize[1] != pic->linesize[2]){
367 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride missmatch)\n");
371 s->linesize = pic->linesize[0];
372 s->uvlinesize= pic->linesize[1];
375 if(pic->qscale_table==NULL){
377 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
378 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
379 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
382 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
383 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
384 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
385 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
386 if(s->out_format == FMT_H264){
388 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+2) * sizeof(int16_t))
389 pic->motion_val[i]= pic->motion_val_base[i]+2;
390 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
392 pic->motion_subsample_log2= 2;
393 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
395 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+2) * sizeof(int16_t))
396 pic->motion_val[i]= pic->motion_val_base[i]+2;
397 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
399 pic->motion_subsample_log2= 3;
401 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
402 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
404 pic->qstride= s->mb_stride;
405 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
408 //it might be nicer if the application would keep track of these but it would require a API change
409 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
410 s->prev_pict_types[0]= s->pict_type;
411 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
412 pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
415 fail: //for the CHECKED_ALLOCZ macro
420 * deallocates a picture
422 static void free_picture(MpegEncContext *s, Picture *pic){
425 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
426 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
429 av_freep(&pic->mb_var);
430 av_freep(&pic->mc_mb_var);
431 av_freep(&pic->mb_mean);
432 av_freep(&pic->mbskip_table);
433 av_freep(&pic->qscale_table);
434 av_freep(&pic->mb_type_base);
435 av_freep(&pic->dct_coeff);
436 av_freep(&pic->pan_scan);
439 av_freep(&pic->motion_val_base[i]);
440 av_freep(&pic->ref_index[i]);
443 if(pic->type == FF_BUFFER_TYPE_SHARED){
452 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
455 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
456 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
457 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
459 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
460 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
461 s->rd_scratchpad= s->me.scratchpad;
462 s->b_scratchpad= s->me.scratchpad;
463 s->obmc_scratchpad= s->me.scratchpad + 16;
465 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
466 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
467 if(s->avctx->noise_reduction){
468 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
471 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
472 s->block= s->blocks[0];
475 s->pblocks[i] = (short *)(&s->block[i]);
479 return -1; //free() through MPV_common_end()
482 static void free_duplicate_context(MpegEncContext *s){
485 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
486 av_freep(&s->me.scratchpad);
489 s->obmc_scratchpad= NULL;
491 av_freep(&s->dct_error_sum);
492 av_freep(&s->me.map);
493 av_freep(&s->me.score_map);
494 av_freep(&s->blocks);
498 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
499 #define COPY(a) bak->a= src->a
500 COPY(allocated_edge_emu_buffer);
501 COPY(edge_emu_buffer);
505 COPY(obmc_scratchpad);
512 COPY(me.map_generation);
520 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
523 //FIXME copy only needed parts
525 backup_duplicate_context(&bak, dst);
526 memcpy(dst, src, sizeof(MpegEncContext));
527 backup_duplicate_context(dst, &bak);
529 dst->pblocks[i] = (short *)(&dst->block[i]);
531 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
534 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
535 #define COPY(a) dst->a= src->a
537 COPY(current_picture);
543 COPY(picture_in_gop_number);
544 COPY(gop_picture_number);
545 COPY(frame_pred_frame_dct); //FIXME dont set in encode_header
546 COPY(progressive_frame); //FIXME dont set in encode_header
547 COPY(partitioned_frame); //FIXME dont set in encode_header
552 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
553 * the changed fields will not depend upon the prior state of the MpegEncContext.
555 static void MPV_common_defaults(MpegEncContext *s){
557 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
558 s->chroma_qscale_table= ff_default_chroma_qscale_table;
559 s->progressive_frame= 1;
560 s->progressive_sequence= 1;
561 s->picture_structure= PICT_FRAME;
563 s->coded_picture_number = 0;
564 s->picture_number = 0;
565 s->input_picture_number = 0;
567 s->picture_in_gop_number = 0;
574 * sets the given MpegEncContext to defaults for decoding.
575 * the changed fields will not depend upon the prior state of the MpegEncContext.
577 void MPV_decode_defaults(MpegEncContext *s){
578 MPV_common_defaults(s);
582 * sets the given MpegEncContext to defaults for encoding.
583 * the changed fields will not depend upon the prior state of the MpegEncContext.
586 #ifdef CONFIG_ENCODERS
587 static void MPV_encode_defaults(MpegEncContext *s){
590 MPV_common_defaults(s);
596 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
597 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
599 for(i=-16; i<16; i++){
600 default_fcode_tab[i + MAX_MV]= 1;
603 s->me.mv_penalty= default_mv_penalty;
604 s->fcode_tab= default_fcode_tab;
606 #endif //CONFIG_ENCODERS
609 * init common structure for both encoder and decoder.
610 * this assumes that some variables like width/height are already set
612 int MPV_common_init(MpegEncContext *s)
614 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
616 if(s->avctx->thread_count > MAX_THREADS || (16*s->avctx->thread_count > s->height && s->height)){
617 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
621 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
624 dsputil_init(&s->dsp, s->avctx);
627 s->flags= s->avctx->flags;
628 s->flags2= s->avctx->flags2;
630 s->mb_width = (s->width + 15) / 16;
631 s->mb_height = (s->height + 15) / 16;
632 s->mb_stride = s->mb_width + 1;
633 s->b8_stride = s->mb_width*2 + 1;
634 s->b4_stride = s->mb_width*4 + 1;
635 mb_array_size= s->mb_height * s->mb_stride;
636 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
638 /* set chroma shifts */
639 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
640 &(s->chroma_y_shift) );
642 /* set default edge pos, will be overriden in decode_header if needed */
643 s->h_edge_pos= s->mb_width*16;
644 s->v_edge_pos= s->mb_height*16;
646 s->mb_num = s->mb_width * s->mb_height;
651 s->block_wrap[3]= s->b8_stride;
653 s->block_wrap[5]= s->mb_stride;
655 y_size = s->b8_stride * (2 * s->mb_height + 1);
656 c_size = s->mb_stride * (s->mb_height + 1);
657 yc_size = y_size + 2 * c_size;
659 /* convert fourcc to upper case */
660 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
661 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
662 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
663 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
665 s->avctx->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
666 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
667 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
668 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
670 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
672 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
673 for(y=0; y<s->mb_height; y++){
674 for(x=0; x<s->mb_width; x++){
675 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
678 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
681 /* Allocate MV tables */
682 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
683 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
684 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
685 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
686 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
687 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
688 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
689 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
690 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
691 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
692 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
693 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
695 if(s->msmpeg4_version){
696 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
698 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
700 /* Allocate MB type table */
701 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
703 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
705 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
706 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
707 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
708 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
709 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
710 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
712 if(s->avctx->noise_reduction){
713 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
716 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
718 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
720 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
721 /* interlaced direct mode decoding tables */
726 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
727 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
729 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
730 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
731 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
733 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
736 if (s->out_format == FMT_H263) {
738 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
739 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
740 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
741 s->ac_val[2] = s->ac_val[1] + c_size;
744 CHECKED_ALLOCZ(s->coded_block_base, y_size);
745 s->coded_block= s->coded_block_base + s->b8_stride + 1;
747 /* cbp, ac_pred, pred_dir */
748 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
749 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
752 if (s->h263_pred || s->h263_plus || !s->encoding) {
754 //MN: we need these for error resilience of intra-frames
755 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
756 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
757 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
758 s->dc_val[2] = s->dc_val[1] + c_size;
759 for(i=0;i<yc_size;i++)
760 s->dc_val_base[i] = 1024;
763 /* which mb is a intra block */
764 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
765 memset(s->mbintra_table, 1, mb_array_size);
767 /* init macroblock skip table */
768 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
769 //Note the +1 is for a quicker mpeg4 slice_end detection
770 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
772 s->parse_context.state= -1;
773 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
774 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
775 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
776 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
779 s->context_initialized = 1;
781 s->thread_context[0]= s;
782 for(i=1; i<s->avctx->thread_count; i++){
783 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
784 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
787 for(i=0; i<s->avctx->thread_count; i++){
788 if(init_duplicate_context(s->thread_context[i], s) < 0)
790 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
791 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
800 /* init common structure for both encoder and decoder */
801 void MPV_common_end(MpegEncContext *s)
805 for(i=0; i<s->avctx->thread_count; i++){
806 free_duplicate_context(s->thread_context[i]);
808 for(i=1; i<s->avctx->thread_count; i++){
809 av_freep(&s->thread_context[i]);
812 av_freep(&s->parse_context.buffer);
813 s->parse_context.buffer_size=0;
815 av_freep(&s->mb_type);
816 av_freep(&s->p_mv_table_base);
817 av_freep(&s->b_forw_mv_table_base);
818 av_freep(&s->b_back_mv_table_base);
819 av_freep(&s->b_bidir_forw_mv_table_base);
820 av_freep(&s->b_bidir_back_mv_table_base);
821 av_freep(&s->b_direct_mv_table_base);
823 s->b_forw_mv_table= NULL;
824 s->b_back_mv_table= NULL;
825 s->b_bidir_forw_mv_table= NULL;
826 s->b_bidir_back_mv_table= NULL;
827 s->b_direct_mv_table= NULL;
831 av_freep(&s->b_field_mv_table_base[i][j][k]);
832 s->b_field_mv_table[i][j][k]=NULL;
834 av_freep(&s->b_field_select_table[i][j]);
835 av_freep(&s->p_field_mv_table_base[i][j]);
836 s->p_field_mv_table[i][j]=NULL;
838 av_freep(&s->p_field_select_table[i]);
841 av_freep(&s->dc_val_base);
842 av_freep(&s->ac_val_base);
843 av_freep(&s->coded_block_base);
844 av_freep(&s->mbintra_table);
845 av_freep(&s->cbp_table);
846 av_freep(&s->pred_dir_table);
848 av_freep(&s->mbskip_table);
849 av_freep(&s->prev_pict_types);
850 av_freep(&s->bitstream_buffer);
851 s->allocated_bitstream_buffer_size=0;
853 av_freep(&s->avctx->stats_out);
854 av_freep(&s->ac_stats);
855 av_freep(&s->error_status_table);
856 av_freep(&s->mb_index2xy);
857 av_freep(&s->lambda_table);
858 av_freep(&s->q_intra_matrix);
859 av_freep(&s->q_inter_matrix);
860 av_freep(&s->q_intra_matrix16);
861 av_freep(&s->q_inter_matrix16);
862 av_freep(&s->input_picture);
863 av_freep(&s->reordered_input_picture);
864 av_freep(&s->dct_offset);
867 for(i=0; i<MAX_PICTURE_COUNT; i++){
868 free_picture(s, &s->picture[i]);
871 av_freep(&s->picture);
872 s->context_initialized = 0;
875 s->current_picture_ptr= NULL;
876 s->linesize= s->uvlinesize= 0;
879 av_freep(&s->visualization_buffer[i]);
881 avcodec_default_free_buffers(s->avctx);
884 #ifdef CONFIG_ENCODERS
886 /* init video encoder */
887 int MPV_encode_init(AVCodecContext *avctx)
889 MpegEncContext *s = avctx->priv_data;
891 int chroma_h_shift, chroma_v_shift;
893 MPV_encode_defaults(s);
895 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && avctx->pix_fmt != PIX_FMT_YUV420P){
896 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
900 if(avctx->codec_id == CODEC_ID_MJPEG || avctx->codec_id == CODEC_ID_LJPEG){
901 if(avctx->strict_std_compliance>=0 && avctx->pix_fmt != PIX_FMT_YUVJ420P){
902 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
906 if(avctx->strict_std_compliance>=0 && avctx->pix_fmt != PIX_FMT_YUV420P){
907 av_log(avctx, AV_LOG_ERROR, "colorspace not supported\n");
912 s->bit_rate = avctx->bit_rate;
913 s->width = avctx->width;
914 s->height = avctx->height;
915 if(avctx->gop_size > 600){
916 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
919 s->gop_size = avctx->gop_size;
921 s->flags= avctx->flags;
922 s->flags2= avctx->flags2;
923 s->max_b_frames= avctx->max_b_frames;
924 s->codec_id= avctx->codec->id;
925 s->luma_elim_threshold = avctx->luma_elim_threshold;
926 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
927 s->strict_std_compliance= avctx->strict_std_compliance;
928 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
929 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
930 s->mpeg_quant= avctx->mpeg_quant;
931 s->rtp_mode= !!avctx->rtp_payload_size;
932 s->intra_dc_precision= avctx->intra_dc_precision;
933 s->user_specified_pts = AV_NOPTS_VALUE;
935 if (s->gop_size <= 1) {
942 s->me_method = avctx->me_method;
945 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
947 s->adaptive_quant= ( s->avctx->lumi_masking
948 || s->avctx->dark_masking
949 || s->avctx->temporal_cplx_masking
950 || s->avctx->spatial_cplx_masking
951 || s->avctx->p_masking
952 || s->avctx->border_masking
953 || (s->flags&CODEC_FLAG_QP_RD))
956 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
957 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
958 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
960 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
961 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
965 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
966 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
969 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
970 av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
974 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
975 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
979 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
980 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
981 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
983 av_log(avctx, AV_LOG_INFO, "Warning vbv_delay will be set to 0xFFFF (=VBR) as the specified vbv buffer is too large for the given bitrate!\n");
986 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
987 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
988 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
992 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
993 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
997 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
998 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
1002 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1003 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1007 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1008 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1012 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1013 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1017 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1018 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1019 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1023 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1024 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
1028 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1029 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1033 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1034 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1038 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1039 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1043 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1044 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1045 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1046 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1050 if(s->avctx->thread_count > 1)
1053 if(!avctx->frame_rate || !avctx->frame_rate_base){
1054 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1058 i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
1060 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1061 avctx->frame_rate /= i;
1062 avctx->frame_rate_base /= i;
1066 if(s->codec_id==CODEC_ID_MJPEG){
1067 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1068 s->inter_quant_bias= 0;
1069 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1070 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1071 s->inter_quant_bias= 0;
1073 s->intra_quant_bias=0;
1074 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1077 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1078 s->intra_quant_bias= avctx->intra_quant_bias;
1079 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1080 s->inter_quant_bias= avctx->inter_quant_bias;
1082 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1084 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1085 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1087 switch(avctx->codec->id) {
1088 case CODEC_ID_MPEG1VIDEO:
1089 s->out_format = FMT_MPEG1;
1090 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1091 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1093 case CODEC_ID_MPEG2VIDEO:
1094 s->out_format = FMT_MPEG1;
1095 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1096 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1099 case CODEC_ID_LJPEG:
1100 case CODEC_ID_MJPEG:
1101 s->out_format = FMT_MJPEG;
1102 s->intra_only = 1; /* force intra only for jpeg */
1103 s->mjpeg_write_tables = 1; /* write all tables */
1104 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1105 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1106 s->mjpeg_vsample[1] = 1;
1107 s->mjpeg_vsample[2] = 1;
1108 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1109 s->mjpeg_hsample[1] = 1;
1110 s->mjpeg_hsample[2] = 1;
1111 if (mjpeg_init(s) < 0)
1117 s->out_format = FMT_H261;
1122 if (h263_get_picture_format(s->width, s->height) == 7) {
1123 av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
1126 s->out_format = FMT_H263;
1127 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1131 case CODEC_ID_H263P:
1132 s->out_format = FMT_H263;
1135 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1136 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1137 s->modified_quant= s->h263_aic;
1138 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1139 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1140 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1141 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1142 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1145 /* These are just to be sure */
1150 s->out_format = FMT_H263;
1151 s->h263_flv = 2; /* format = 1; 11-bit codes */
1152 s->unrestricted_mv = 1;
1153 s->rtp_mode=0; /* don't allow GOB */
1158 s->out_format = FMT_H263;
1163 s->out_format = FMT_H263;
1166 s->modified_quant=1;
1170 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1172 case CODEC_ID_MPEG4:
1173 s->out_format = FMT_H263;
1175 s->unrestricted_mv = 1;
1176 s->low_delay= s->max_b_frames ? 0 : 1;
1177 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1179 case CODEC_ID_MSMPEG4V1:
1180 s->out_format = FMT_H263;
1181 s->h263_msmpeg4 = 1;
1183 s->unrestricted_mv = 1;
1184 s->msmpeg4_version= 1;
1188 case CODEC_ID_MSMPEG4V2:
1189 s->out_format = FMT_H263;
1190 s->h263_msmpeg4 = 1;
1192 s->unrestricted_mv = 1;
1193 s->msmpeg4_version= 2;
1197 case CODEC_ID_MSMPEG4V3:
1198 s->out_format = FMT_H263;
1199 s->h263_msmpeg4 = 1;
1201 s->unrestricted_mv = 1;
1202 s->msmpeg4_version= 3;
1203 s->flipflop_rounding=1;
1208 s->out_format = FMT_H263;
1209 s->h263_msmpeg4 = 1;
1211 s->unrestricted_mv = 1;
1212 s->msmpeg4_version= 4;
1213 s->flipflop_rounding=1;
1218 s->out_format = FMT_H263;
1219 s->h263_msmpeg4 = 1;
1221 s->unrestricted_mv = 1;
1222 s->msmpeg4_version= 5;
1223 s->flipflop_rounding=1;
1231 avctx->has_b_frames= !s->low_delay;
1236 if (MPV_common_init(s) < 0)
1239 if(s->modified_quant)
1240 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1241 s->progressive_frame=
1242 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1243 s->quant_precision=5;
1245 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1246 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1248 #ifdef CONFIG_ENCODERS
1249 if (s->out_format == FMT_H261)
1250 ff_h261_encode_init(s);
1251 if (s->out_format == FMT_H263)
1252 h263_encode_init(s);
1253 if(s->msmpeg4_version)
1254 ff_msmpeg4_encode_init(s);
1255 if (s->out_format == FMT_MPEG1)
1256 ff_mpeg1_encode_init(s);
1261 int j= s->dsp.idct_permutation[i];
1262 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1263 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1264 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1265 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1266 s->intra_matrix[j] =
1267 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1270 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1271 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1273 if(s->avctx->intra_matrix)
1274 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1275 if(s->avctx->inter_matrix)
1276 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1279 /* precompute matrix */
1280 /* for mjpeg, we do include qscale in the matrix */
1281 if (s->out_format != FMT_MJPEG) {
1282 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1283 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1284 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1285 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1288 if(ff_rate_control_init(s) < 0)
1294 int MPV_encode_end(AVCodecContext *avctx)
1296 MpegEncContext *s = avctx->priv_data;
1302 ff_rate_control_uninit(s);
1305 if (s->out_format == FMT_MJPEG)
1308 av_freep(&avctx->extradata);
1313 #endif //CONFIG_ENCODERS
1315 void init_rl(RLTable *rl, int use_static)
1317 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1318 uint8_t index_run[MAX_RUN+1];
1319 int last, run, level, start, end, i;
1321 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1322 if(use_static && rl->max_level[0])
1325 /* compute max_level[], max_run[] and index_run[] */
1326 for(last=0;last<2;last++) {
1335 memset(max_level, 0, MAX_RUN + 1);
1336 memset(max_run, 0, MAX_LEVEL + 1);
1337 memset(index_run, rl->n, MAX_RUN + 1);
1338 for(i=start;i<end;i++) {
1339 run = rl->table_run[i];
1340 level = rl->table_level[i];
1341 if (index_run[run] == rl->n)
1343 if (level > max_level[run])
1344 max_level[run] = level;
1345 if (run > max_run[level])
1346 max_run[level] = run;
1349 rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1351 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1352 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1354 rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1356 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1357 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1359 rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1361 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1362 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1366 /* draw the edges of width 'w' of an image of size width, height */
1367 //FIXME check that this is ok for mpeg4 interlaced
1368 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1370 uint8_t *ptr, *last_line;
1373 last_line = buf + (height - 1) * wrap;
1375 /* top and bottom */
1376 memcpy(buf - (i + 1) * wrap, buf, width);
1377 memcpy(last_line + (i + 1) * wrap, last_line, width);
1379 /* left and right */
1381 for(i=0;i<height;i++) {
1382 memset(ptr - w, ptr[0], w);
1383 memset(ptr + width, ptr[width-1], w);
1388 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1389 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1390 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1391 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1395 int ff_find_unused_picture(MpegEncContext *s, int shared){
1399 for(i=0; i<MAX_PICTURE_COUNT; i++){
1400 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1403 for(i=0; i<MAX_PICTURE_COUNT; i++){
1404 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1406 for(i=0; i<MAX_PICTURE_COUNT; i++){
1407 if(s->picture[i].data[0]==NULL) return i;
1415 static void update_noise_reduction(MpegEncContext *s){
1418 for(intra=0; intra<2; intra++){
1419 if(s->dct_count[intra] > (1<<16)){
1420 for(i=0; i<64; i++){
1421 s->dct_error_sum[intra][i] >>=1;
1423 s->dct_count[intra] >>= 1;
1426 for(i=0; i<64; i++){
1427 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);
1433 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1435 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1441 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1443 /* mark&release old frames */
1444 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1445 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1447 /* release forgotten pictures */
1448 /* if(mpeg124/h263) */
1450 for(i=0; i<MAX_PICTURE_COUNT; i++){
1451 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1452 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1453 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1460 /* release non refernce frames */
1461 for(i=0; i<MAX_PICTURE_COUNT; i++){
1462 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1463 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1467 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1468 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1470 i= ff_find_unused_picture(s, 0);
1471 pic= (AVFrame*)&s->picture[i];
1474 pic->reference= s->pict_type != B_TYPE && !s->dropable ? 3 : 0;
1476 pic->coded_picture_number= s->coded_picture_number++;
1478 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1481 s->current_picture_ptr= (Picture*)pic;
1482 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1483 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1486 s->current_picture_ptr->pict_type= s->pict_type;
1487 // if(s->flags && CODEC_FLAG_QSCALE)
1488 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1489 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1491 copy_picture(&s->current_picture, s->current_picture_ptr);
1493 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1494 if (s->pict_type != B_TYPE) {
1495 s->last_picture_ptr= s->next_picture_ptr;
1497 s->next_picture_ptr= s->current_picture_ptr;
1499 /* 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,
1500 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1501 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1502 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1503 s->pict_type, s->dropable);*/
1505 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1506 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1508 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1509 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1510 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1514 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1516 if(s->picture_structure!=PICT_FRAME){
1519 if(s->picture_structure == PICT_BOTTOM_FIELD){
1520 s->current_picture.data[i] += s->current_picture.linesize[i];
1522 s->current_picture.linesize[i] *= 2;
1523 s->last_picture.linesize[i] *=2;
1524 s->next_picture.linesize[i] *=2;
1529 s->hurry_up= s->avctx->hurry_up;
1530 s->error_resilience= avctx->error_resilience;
1532 /* set dequantizer, we cant do it during init as it might change for mpeg4
1533 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1534 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1535 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1536 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1537 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1538 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1539 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1541 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1542 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1545 if(s->dct_error_sum){
1546 assert(s->avctx->noise_reduction && s->encoding);
1548 update_noise_reduction(s);
1552 if(s->avctx->xvmc_acceleration)
1553 return XVMC_field_start(s, avctx);
1558 /* generic function for encode/decode called after a frame has been coded/decoded */
1559 void MPV_frame_end(MpegEncContext *s)
1562 /* draw edge for correct motion prediction if outside */
1564 //just to make sure that all data is rendered.
1565 if(s->avctx->xvmc_acceleration){
1569 if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1570 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1571 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1572 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1576 s->last_pict_type = s->pict_type;
1577 if(s->pict_type!=B_TYPE){
1578 s->last_non_b_pict_type= s->pict_type;
1581 /* copy back current_picture variables */
1582 for(i=0; i<MAX_PICTURE_COUNT; i++){
1583 if(s->picture[i].data[0] == s->current_picture.data[0]){
1584 s->picture[i]= s->current_picture;
1588 assert(i<MAX_PICTURE_COUNT);
1592 /* release non refernce frames */
1593 for(i=0; i<MAX_PICTURE_COUNT; i++){
1594 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1595 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1599 // clear copies, to avoid confusion
1601 memset(&s->last_picture, 0, sizeof(Picture));
1602 memset(&s->next_picture, 0, sizeof(Picture));
1603 memset(&s->current_picture, 0, sizeof(Picture));
1605 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1609 * draws an line from (ex, ey) -> (sx, sy).
1610 * @param w width of the image
1611 * @param h height of the image
1612 * @param stride stride/linesize of the image
1613 * @param color color of the arrow
1615 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1618 sx= clip(sx, 0, w-1);
1619 sy= clip(sy, 0, h-1);
1620 ex= clip(ex, 0, w-1);
1621 ey= clip(ey, 0, h-1);
1623 buf[sy*stride + sx]+= color;
1625 if(ABS(ex - sx) > ABS(ey - sy)){
1630 buf+= sx + sy*stride;
1632 f= ((ey-sy)<<16)/ex;
1633 for(x= 0; x <= ex; x++){
1636 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1637 buf[(y+1)*stride + x]+= (color* fr )>>16;
1644 buf+= sx + sy*stride;
1646 if(ey) f= ((ex-sx)<<16)/ey;
1648 for(y= 0; y <= ey; y++){
1651 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1652 buf[y*stride + x+1]+= (color* fr )>>16;;
1658 * draws an arrow from (ex, ey) -> (sx, sy).
1659 * @param w width of the image
1660 * @param h height of the image
1661 * @param stride stride/linesize of the image
1662 * @param color color of the arrow
1664 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1667 sx= clip(sx, -100, w+100);
1668 sy= clip(sy, -100, h+100);
1669 ex= clip(ex, -100, w+100);
1670 ey= clip(ey, -100, h+100);
1675 if(dx*dx + dy*dy > 3*3){
1678 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1680 //FIXME subpixel accuracy
1681 rx= ROUNDED_DIV(rx*3<<4, length);
1682 ry= ROUNDED_DIV(ry*3<<4, length);
1684 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1685 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1687 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1691 * prints debuging info for the given picture.
1693 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1695 if(!pict || !pict->mb_type) return;
1697 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1700 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1701 switch (pict->pict_type) {
1702 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1703 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1704 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1705 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1706 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1707 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1709 for(y=0; y<s->mb_height; y++){
1710 for(x=0; x<s->mb_width; x++){
1711 if(s->avctx->debug&FF_DEBUG_SKIP){
1712 int count= s->mbskip_table[x + y*s->mb_stride];
1713 if(count>9) count=9;
1714 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1716 if(s->avctx->debug&FF_DEBUG_QP){
1717 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1719 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1720 int mb_type= pict->mb_type[x + y*s->mb_stride];
1721 //Type & MV direction
1723 av_log(s->avctx, AV_LOG_DEBUG, "P");
1724 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1725 av_log(s->avctx, AV_LOG_DEBUG, "A");
1726 else if(IS_INTRA4x4(mb_type))
1727 av_log(s->avctx, AV_LOG_DEBUG, "i");
1728 else if(IS_INTRA16x16(mb_type))
1729 av_log(s->avctx, AV_LOG_DEBUG, "I");
1730 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1731 av_log(s->avctx, AV_LOG_DEBUG, "d");
1732 else if(IS_DIRECT(mb_type))
1733 av_log(s->avctx, AV_LOG_DEBUG, "D");
1734 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1735 av_log(s->avctx, AV_LOG_DEBUG, "g");
1736 else if(IS_GMC(mb_type))
1737 av_log(s->avctx, AV_LOG_DEBUG, "G");
1738 else if(IS_SKIP(mb_type))
1739 av_log(s->avctx, AV_LOG_DEBUG, "S");
1740 else if(!USES_LIST(mb_type, 1))
1741 av_log(s->avctx, AV_LOG_DEBUG, ">");
1742 else if(!USES_LIST(mb_type, 0))
1743 av_log(s->avctx, AV_LOG_DEBUG, "<");
1745 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1746 av_log(s->avctx, AV_LOG_DEBUG, "X");
1751 av_log(s->avctx, AV_LOG_DEBUG, "+");
1752 else if(IS_16X8(mb_type))
1753 av_log(s->avctx, AV_LOG_DEBUG, "-");
1754 else if(IS_8X16(mb_type))
1755 av_log(s->avctx, AV_LOG_DEBUG, "¦");
1756 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1757 av_log(s->avctx, AV_LOG_DEBUG, " ");
1759 av_log(s->avctx, AV_LOG_DEBUG, "?");
1762 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1763 av_log(s->avctx, AV_LOG_DEBUG, "=");
1765 av_log(s->avctx, AV_LOG_DEBUG, " ");
1767 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1769 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1773 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1774 const int shift= 1 + s->quarter_sample;
1778 int h_chroma_shift, v_chroma_shift;
1779 const int width = s->avctx->width;
1780 const int height= s->avctx->height;
1781 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1782 const int mv_stride= (s->mb_width << mv_sample_log2) + 1;
1783 s->low_delay=0; //needed to see the vectors without trashing the buffers
1785 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1787 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1788 pict->data[i]= s->visualization_buffer[i];
1790 pict->type= FF_BUFFER_TYPE_COPY;
1793 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1795 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1796 const int mb_index= mb_x + mb_y*s->mb_stride;
1797 if((s->avctx->debug_mv) && pict->motion_val){
1799 for(type=0; type<3; type++){
1802 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1806 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1810 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1815 if(!USES_LIST(pict->mb_type[mb_index], direction))
1818 if(IS_8X8(pict->mb_type[mb_index])){
1821 int sx= mb_x*16 + 4 + 8*(i&1);
1822 int sy= mb_y*16 + 4 + 8*(i>>1);
1823 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1824 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1825 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1826 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1828 }else if(IS_16X8(pict->mb_type[mb_index])){
1832 int sy=mb_y*16 + 4 + 8*i;
1833 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1834 int mx=(pict->motion_val[direction][xy][0]>>shift);
1835 int my=(pict->motion_val[direction][xy][1]>>shift);
1837 if(IS_INTERLACED(pict->mb_type[mb_index]))
1840 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1842 }else if(IS_8X16(pict->mb_type[mb_index])){
1845 int sx=mb_x*16 + 4 + 8*i;
1847 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1848 int mx=(pict->motion_val[direction][xy][0]>>shift);
1849 int my=(pict->motion_val[direction][xy][1]>>shift);
1851 if(IS_INTERLACED(pict->mb_type[mb_index]))
1854 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1857 int sx= mb_x*16 + 8;
1858 int sy= mb_y*16 + 8;
1859 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1860 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1861 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1862 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1866 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1867 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1870 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1871 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1874 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1875 int mb_type= pict->mb_type[mb_index];
1878 #define COLOR(theta, r)\
1879 u= (int)(128 + r*cos(theta*3.141592/180));\
1880 v= (int)(128 + r*sin(theta*3.141592/180));
1884 if(IS_PCM(mb_type)){
1886 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1888 }else if(IS_INTRA4x4(mb_type)){
1890 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1892 }else if(IS_DIRECT(mb_type)){
1894 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1896 }else if(IS_GMC(mb_type)){
1898 }else if(IS_SKIP(mb_type)){
1900 }else if(!USES_LIST(mb_type, 1)){
1902 }else if(!USES_LIST(mb_type, 0)){
1905 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1909 u*= 0x0101010101010101ULL;
1910 v*= 0x0101010101010101ULL;
1912 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1913 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1917 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1918 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1919 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1921 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1923 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1925 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1926 int dm= 1 << (mv_sample_log2-2);
1928 int sx= mb_x*16 + 8*(i&1);
1929 int sy= mb_y*16 + 8*(i>>1);
1930 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1932 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1933 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1935 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1936 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1937 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1941 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1945 s->mbskip_table[mb_index]=0;
1951 #ifdef CONFIG_ENCODERS
1953 static int get_sae(uint8_t *src, int ref, int stride){
1957 for(y=0; y<16; y++){
1958 for(x=0; x<16; x++){
1959 acc+= ABS(src[x+y*stride] - ref);
1966 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1973 for(y=0; y<h; y+=16){
1974 for(x=0; x<w; x+=16){
1975 int offset= x + y*stride;
1976 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1977 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1978 int sae = get_sae(src + offset, mean, stride);
1980 acc+= sae + 500 < sad;
1987 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1991 const int encoding_delay= s->max_b_frames;
1996 pic_arg->display_picture_number= s->input_picture_number++;
1998 if(pts != AV_NOPTS_VALUE){
1999 if(s->user_specified_pts != AV_NOPTS_VALUE){
2000 int64_t time= av_rescale(pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
2001 int64_t last= av_rescale(s->user_specified_pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
2004 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pts, s->user_specified_pts);
2008 s->user_specified_pts= pts;
2010 if(s->user_specified_pts != AV_NOPTS_VALUE){
2011 s->user_specified_pts=
2012 pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
2013 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pts);
2015 pts= av_rescale(pic_arg->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
2021 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2022 if(pic_arg->linesize[0] != s->linesize) direct=0;
2023 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2024 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2026 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2029 i= ff_find_unused_picture(s, 1);
2031 pic= (AVFrame*)&s->picture[i];
2035 pic->data[i]= pic_arg->data[i];
2036 pic->linesize[i]= pic_arg->linesize[i];
2038 alloc_picture(s, (Picture*)pic, 1);
2041 i= ff_find_unused_picture(s, 0);
2043 pic= (AVFrame*)&s->picture[i];
2046 alloc_picture(s, (Picture*)pic, 0);
2048 if( pic->data[0] + offset == pic_arg->data[0]
2049 && pic->data[1] + offset == pic_arg->data[1]
2050 && pic->data[2] + offset == pic_arg->data[2]){
2053 int h_chroma_shift, v_chroma_shift;
2054 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2057 int src_stride= pic_arg->linesize[i];
2058 int dst_stride= i ? s->uvlinesize : s->linesize;
2059 int h_shift= i ? h_chroma_shift : 0;
2060 int v_shift= i ? v_chroma_shift : 0;
2061 int w= s->width >>h_shift;
2062 int h= s->height>>v_shift;
2063 uint8_t *src= pic_arg->data[i];
2064 uint8_t *dst= pic->data[i] + offset;
2066 if(src_stride==dst_stride)
2067 memcpy(dst, src, src_stride*h);
2070 memcpy(dst, src, w);
2078 copy_picture_attributes(s, pic, pic_arg);
2079 pic->pts= pts; //we set this here to avoid modifiying pic_arg
2082 /* shift buffer entries */
2083 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2084 s->input_picture[i-1]= s->input_picture[i];
2086 s->input_picture[encoding_delay]= (Picture*)pic;
2091 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2096 for(plane=0; plane<3; plane++){
2097 const int stride= p->linesize[plane];
2098 const int bw= plane ? 1 : 2;
2099 for(y=0; y<s->mb_height*bw; y++){
2100 for(x=0; x<s->mb_width*bw; x++){
2101 int v= s->dsp.frame_skip_cmp[1](s, p->data[plane] + 8*(x + y*stride), ref->data[plane] + 8*(x + y*stride), stride, 8);
2103 switch(s->avctx->frame_skip_exp){
2104 case 0: score= FFMAX(score, v); break;
2105 case 1: score+= ABS(v);break;
2106 case 2: score+= v*v;break;
2107 case 3: score64+= ABS(v*v*(int64_t)v);break;
2108 case 4: score64+= v*v*(int64_t)(v*v);break;
2114 if(score) score64= score;
2116 if(score64 < s->avctx->frame_skip_threshold)
2118 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2123 static void select_input_picture(MpegEncContext *s){
2126 for(i=1; i<MAX_PICTURE_COUNT; i++)
2127 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2128 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2130 /* set next picture types & ordering */
2131 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2132 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2133 s->reordered_input_picture[0]= s->input_picture[0];
2134 s->reordered_input_picture[0]->pict_type= I_TYPE;
2135 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2139 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2140 if(skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2141 //av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2143 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2145 s->input_picture[0]->data[i]= NULL;
2146 s->input_picture[0]->type= 0;
2148 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2149 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2151 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2158 if(s->flags&CODEC_FLAG_PASS2){
2159 for(i=0; i<s->max_b_frames+1; i++){
2160 int pict_num= s->input_picture[0]->display_picture_number + i;
2162 if(pict_num >= s->rc_context.num_entries)
2164 if(!s->input_picture[i]){
2165 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2169 s->input_picture[i]->pict_type=
2170 s->rc_context.entry[pict_num].new_pict_type;
2174 if(s->avctx->b_frame_strategy==0){
2175 b_frames= s->max_b_frames;
2176 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2177 }else if(s->avctx->b_frame_strategy==1){
2178 for(i=1; i<s->max_b_frames+1; i++){
2179 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2180 s->input_picture[i]->b_frame_score=
2181 get_intra_count(s, s->input_picture[i ]->data[0],
2182 s->input_picture[i-1]->data[0], s->linesize) + 1;
2185 for(i=0; i<s->max_b_frames; i++){
2186 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2189 b_frames= FFMAX(0, i-1);
2192 for(i=0; i<b_frames+1; i++){
2193 s->input_picture[i]->b_frame_score=0;
2196 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2201 //static int b_count=0;
2202 //b_count+= b_frames;
2203 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2205 for(i= b_frames - 1; i>=0; i--){
2206 int type= s->input_picture[i]->pict_type;
2207 if(type && type != B_TYPE)
2210 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2211 av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2214 if(s->picture_in_gop_number + b_frames >= s->gop_size){
2215 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2216 b_frames= s->gop_size - s->picture_in_gop_number - 1;
2218 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2220 s->input_picture[b_frames]->pict_type= I_TYPE;
2224 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2226 && s->input_picture[b_frames]->pict_type== I_TYPE)
2229 s->reordered_input_picture[0]= s->input_picture[b_frames];
2230 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2231 s->reordered_input_picture[0]->pict_type= P_TYPE;
2232 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2233 for(i=0; i<b_frames; i++){
2234 s->reordered_input_picture[i+1]= s->input_picture[i];
2235 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2236 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2241 if(s->reordered_input_picture[0]){
2242 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2244 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2246 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2247 // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2249 int i= ff_find_unused_picture(s, 0);
2250 Picture *pic= &s->picture[i];
2252 /* mark us unused / free shared pic */
2254 s->reordered_input_picture[0]->data[i]= NULL;
2255 s->reordered_input_picture[0]->type= 0;
2257 pic->reference = s->reordered_input_picture[0]->reference;
2259 alloc_picture(s, pic, 0);
2261 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2263 s->current_picture_ptr= pic;
2265 // input is not a shared pix -> reuse buffer for current_pix
2267 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2268 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2270 s->current_picture_ptr= s->reordered_input_picture[0];
2272 s->new_picture.data[i]+=16;
2275 copy_picture(&s->current_picture, s->current_picture_ptr);
2277 s->picture_number= s->new_picture.display_picture_number;
2278 //printf("dpn:%d\n", s->picture_number);
2280 memset(&s->new_picture, 0, sizeof(Picture));
2284 int MPV_encode_picture(AVCodecContext *avctx,
2285 unsigned char *buf, int buf_size, void *data)
2287 MpegEncContext *s = avctx->priv_data;
2288 AVFrame *pic_arg = data;
2289 int i, stuffing_count;
2291 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUVJ420P){
2292 av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2296 for(i=0; i<avctx->thread_count; i++){
2297 int start_y= s->thread_context[i]->start_mb_y;
2298 int end_y= s->thread_context[i]-> end_mb_y;
2299 int h= s->mb_height;
2300 uint8_t *start= buf + buf_size*start_y/h;
2301 uint8_t *end = buf + buf_size* end_y/h;
2303 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2306 s->picture_in_gop_number++;
2308 if(load_input_picture(s, pic_arg) < 0)
2311 select_input_picture(s);
2314 if(s->new_picture.data[0]){
2315 s->pict_type= s->new_picture.pict_type;
2317 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2318 MPV_frame_start(s, avctx);
2320 encode_picture(s, s->picture_number);
2322 avctx->real_pict_num = s->picture_number;
2323 avctx->header_bits = s->header_bits;
2324 avctx->mv_bits = s->mv_bits;
2325 avctx->misc_bits = s->misc_bits;
2326 avctx->i_tex_bits = s->i_tex_bits;
2327 avctx->p_tex_bits = s->p_tex_bits;
2328 avctx->i_count = s->i_count;
2329 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2330 avctx->skip_count = s->skip_count;
2334 if (s->out_format == FMT_MJPEG)
2335 mjpeg_picture_trailer(s);
2337 if(s->flags&CODEC_FLAG_PASS1)
2338 ff_write_pass1_stats(s);
2341 avctx->error[i] += s->current_picture_ptr->error[i];
2344 if(s->flags&CODEC_FLAG_PASS1)
2345 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2346 flush_put_bits(&s->pb);
2347 s->frame_bits = put_bits_count(&s->pb);
2349 stuffing_count= ff_vbv_update(s, s->frame_bits);
2351 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2352 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2356 switch(s->codec_id){
2357 case CODEC_ID_MPEG1VIDEO:
2358 case CODEC_ID_MPEG2VIDEO:
2359 while(stuffing_count--){
2360 put_bits(&s->pb, 8, 0);
2363 case CODEC_ID_MPEG4:
2364 put_bits(&s->pb, 16, 0);
2365 put_bits(&s->pb, 16, 0x1C3);
2366 stuffing_count -= 4;
2367 while(stuffing_count--){
2368 put_bits(&s->pb, 8, 0xFF);
2372 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2374 flush_put_bits(&s->pb);
2375 s->frame_bits = put_bits_count(&s->pb);
2378 /* update mpeg1/2 vbv_delay for CBR */
2379 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2380 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2383 assert(s->repeat_first_field==0);
2385 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2386 assert(vbv_delay < 0xFFFF);
2388 s->vbv_delay_ptr[0] &= 0xF8;
2389 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2390 s->vbv_delay_ptr[1] = vbv_delay>>5;
2391 s->vbv_delay_ptr[2] &= 0x07;
2392 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2394 s->total_bits += s->frame_bits;
2395 avctx->frame_bits = s->frame_bits;
2397 assert((pbBufPtr(&s->pb) == s->pb.buf));
2400 assert((s->frame_bits&7)==0);
2402 return s->frame_bits/8;
2405 #endif //CONFIG_ENCODERS
2407 static inline void gmc1_motion(MpegEncContext *s,
2408 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2409 uint8_t **ref_picture)
2412 int offset, src_x, src_y, linesize, uvlinesize;
2413 int motion_x, motion_y;
2416 motion_x= s->sprite_offset[0][0];
2417 motion_y= s->sprite_offset[0][1];
2418 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2419 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2420 motion_x<<=(3-s->sprite_warping_accuracy);
2421 motion_y<<=(3-s->sprite_warping_accuracy);
2422 src_x = clip(src_x, -16, s->width);
2423 if (src_x == s->width)
2425 src_y = clip(src_y, -16, s->height);
2426 if (src_y == s->height)
2429 linesize = s->linesize;
2430 uvlinesize = s->uvlinesize;
2432 ptr = ref_picture[0] + (src_y * linesize) + src_x;
2434 if(s->flags&CODEC_FLAG_EMU_EDGE){
2435 if( (unsigned)src_x >= s->h_edge_pos - 17
2436 || (unsigned)src_y >= s->v_edge_pos - 17){
2437 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2438 ptr= s->edge_emu_buffer;
2442 if((motion_x|motion_y)&7){
2443 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2444 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2448 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2449 if (s->no_rounding){
2450 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2452 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2456 if(s->flags&CODEC_FLAG_GRAY) return;
2458 motion_x= s->sprite_offset[1][0];
2459 motion_y= s->sprite_offset[1][1];
2460 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2461 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2462 motion_x<<=(3-s->sprite_warping_accuracy);
2463 motion_y<<=(3-s->sprite_warping_accuracy);
2464 src_x = clip(src_x, -8, s->width>>1);
2465 if (src_x == s->width>>1)
2467 src_y = clip(src_y, -8, s->height>>1);
2468 if (src_y == s->height>>1)
2471 offset = (src_y * uvlinesize) + src_x;
2472 ptr = ref_picture[1] + offset;
2473 if(s->flags&CODEC_FLAG_EMU_EDGE){
2474 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2475 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2476 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2477 ptr= s->edge_emu_buffer;
2481 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2483 ptr = ref_picture[2] + offset;
2485 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
2486 ptr= s->edge_emu_buffer;
2488 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2493 static inline void gmc_motion(MpegEncContext *s,
2494 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2495 uint8_t **ref_picture)
2498 int linesize, uvlinesize;
2499 const int a= s->sprite_warping_accuracy;
2502 linesize = s->linesize;
2503 uvlinesize = s->uvlinesize;
2505 ptr = ref_picture[0];
2507 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2508 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2510 s->dsp.gmc(dest_y, ptr, linesize, 16,
2513 s->sprite_delta[0][0], s->sprite_delta[0][1],
2514 s->sprite_delta[1][0], s->sprite_delta[1][1],
2515 a+1, (1<<(2*a+1)) - s->no_rounding,
2516 s->h_edge_pos, s->v_edge_pos);
2517 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2518 ox + s->sprite_delta[0][0]*8,
2519 oy + s->sprite_delta[1][0]*8,
2520 s->sprite_delta[0][0], s->sprite_delta[0][1],
2521 s->sprite_delta[1][0], s->sprite_delta[1][1],
2522 a+1, (1<<(2*a+1)) - s->no_rounding,
2523 s->h_edge_pos, s->v_edge_pos);
2525 if(s->flags&CODEC_FLAG_GRAY) return;
2527 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2528 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2530 ptr = ref_picture[1];
2531 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2534 s->sprite_delta[0][0], s->sprite_delta[0][1],
2535 s->sprite_delta[1][0], s->sprite_delta[1][1],
2536 a+1, (1<<(2*a+1)) - s->no_rounding,
2537 s->h_edge_pos>>1, s->v_edge_pos>>1);
2539 ptr = ref_picture[2];
2540 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2543 s->sprite_delta[0][0], s->sprite_delta[0][1],
2544 s->sprite_delta[1][0], s->sprite_delta[1][1],
2545 a+1, (1<<(2*a+1)) - s->no_rounding,
2546 s->h_edge_pos>>1, s->v_edge_pos>>1);
2550 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2551 * @param buf destination buffer
2552 * @param src source buffer
2553 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2554 * @param block_w width of block
2555 * @param block_h height of block
2556 * @param src_x x coordinate of the top left sample of the block in the source buffer
2557 * @param src_y y coordinate of the top left sample of the block in the source buffer
2558 * @param w width of the source buffer
2559 * @param h height of the source buffer
2561 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2562 int src_x, int src_y, int w, int h){
2564 int start_y, start_x, end_y, end_x;
2567 src+= (h-1-src_y)*linesize;
2569 }else if(src_y<=-block_h){
2570 src+= (1-block_h-src_y)*linesize;
2576 }else if(src_x<=-block_w){
2577 src+= (1-block_w-src_x);
2581 start_y= FFMAX(0, -src_y);
2582 start_x= FFMAX(0, -src_x);
2583 end_y= FFMIN(block_h, h-src_y);
2584 end_x= FFMIN(block_w, w-src_x);
2586 // copy existing part
2587 for(y=start_y; y<end_y; y++){
2588 for(x=start_x; x<end_x; x++){
2589 buf[x + y*linesize]= src[x + y*linesize];
2594 for(y=0; y<start_y; y++){
2595 for(x=start_x; x<end_x; x++){
2596 buf[x + y*linesize]= buf[x + start_y*linesize];
2601 for(y=end_y; y<block_h; y++){
2602 for(x=start_x; x<end_x; x++){
2603 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2607 for(y=0; y<block_h; y++){
2609 for(x=0; x<start_x; x++){
2610 buf[x + y*linesize]= buf[start_x + y*linesize];
2614 for(x=end_x; x<block_w; x++){
2615 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2620 static inline int hpel_motion(MpegEncContext *s,
2621 uint8_t *dest, uint8_t *src,
2622 int field_based, int field_select,
2623 int src_x, int src_y,
2624 int width, int height, int stride,
2625 int h_edge_pos, int v_edge_pos,
2626 int w, int h, op_pixels_func *pix_op,
2627 int motion_x, int motion_y)
2632 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2633 src_x += motion_x >> 1;
2634 src_y += motion_y >> 1;
2636 /* WARNING: do no forget half pels */
2637 src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2640 src_y = clip(src_y, -16, height);
2641 if (src_y == height)
2643 src += src_y * stride + src_x;
2645 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2646 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2647 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2648 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2649 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2650 src= s->edge_emu_buffer;
2656 pix_op[dxy](dest, src, stride, h);
2660 static inline int hpel_motion_lowres(MpegEncContext *s,
2661 uint8_t *dest, uint8_t *src,
2662 int field_based, int field_select,
2663 int src_x, int src_y,
2664 int width, int height, int stride,
2665 int h_edge_pos, int v_edge_pos,
2666 int w, int h, h264_chroma_mc_func *pix_op,
2667 int motion_x, int motion_y)
2669 const int lowres= s->avctx->lowres;
2670 const int s_mask= (2<<lowres)-1;
2674 if(s->quarter_sample){
2679 sx= motion_x & s_mask;
2680 sy= motion_y & s_mask;
2681 src_x += motion_x >> (lowres+1);
2682 src_y += motion_y >> (lowres+1);
2684 src += src_y * stride + src_x;
2686 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
2687 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2688 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2689 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2690 src= s->edge_emu_buffer;
2698 pix_op[lowres](dest, src, stride, h, sx, sy);
2702 /* apply one mpeg motion vector to the three components */
2703 static always_inline void mpeg_motion(MpegEncContext *s,
2704 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2705 int field_based, int bottom_field, int field_select,
2706 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2707 int motion_x, int motion_y, int h)
2709 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2710 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2713 if(s->quarter_sample)
2720 v_edge_pos = s->v_edge_pos >> field_based;
2721 linesize = s->current_picture.linesize[0] << field_based;
2722 uvlinesize = s->current_picture.linesize[1] << field_based;
2724 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2725 src_x = s->mb_x* 16 + (motion_x >> 1);
2726 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2728 if (s->out_format == FMT_H263) {
2729 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2730 mx = (motion_x>>1)|(motion_x&1);
2732 uvdxy = ((my & 1) << 1) | (mx & 1);
2733 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2734 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2736 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2740 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2744 uvsrc_x = s->mb_x*8 + mx;
2745 uvsrc_y = s->mb_y*8 + my;
2747 if(s->chroma_y_shift){
2750 uvdxy = ((my & 1) << 1) | (mx & 1);
2751 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2752 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2754 if(s->chroma_x_shift){
2757 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2758 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2769 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2770 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2771 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2773 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2774 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2775 if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2776 s->codec_id == CODEC_ID_MPEG1VIDEO){
2777 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2780 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2781 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2782 ptr_y = s->edge_emu_buffer;
2783 if(!(s->flags&CODEC_FLAG_GRAY)){
2784 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2785 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2786 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2787 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2788 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2794 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2795 dest_y += s->linesize;
2796 dest_cb+= s->uvlinesize;
2797 dest_cr+= s->uvlinesize;
2801 ptr_y += s->linesize;
2802 ptr_cb+= s->uvlinesize;
2803 ptr_cr+= s->uvlinesize;
2806 pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2808 if(!(s->flags&CODEC_FLAG_GRAY)){
2809 pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2810 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2812 if(s->out_format == FMT_H261){
2813 ff_h261_loop_filter(s);
2817 /* apply one mpeg motion vector to the three components */
2818 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2819 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2820 int field_based, int bottom_field, int field_select,
2821 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2822 int motion_x, int motion_y, int h)
2824 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2825 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2826 const int lowres= s->avctx->lowres;
2827 const int block_s= 8>>lowres;
2828 const int s_mask= (2<<lowres)-1;
2829 const int h_edge_pos = s->h_edge_pos >> lowres;
2830 const int v_edge_pos = s->v_edge_pos >> lowres;
2831 linesize = s->current_picture.linesize[0] << field_based;
2832 uvlinesize = s->current_picture.linesize[1] << field_based;
2834 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2840 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2843 sx= motion_x & s_mask;
2844 sy= motion_y & s_mask;
2845 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
2846 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2848 if (s->out_format == FMT_H263) {
2849 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2850 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2853 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2856 uvsx = (2*mx) & s_mask;
2857 uvsy = (2*my) & s_mask;
2858 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
2859 uvsrc_y = s->mb_y*block_s + (my >> lowres);
2865 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
2866 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2869 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2870 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2871 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2873 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
2874 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2875 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2876 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2877 ptr_y = s->edge_emu_buffer;
2878 if(!(s->flags&CODEC_FLAG_GRAY)){
2879 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2880 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2881 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2882 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2883 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2889 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2890 dest_y += s->linesize;
2891 dest_cb+= s->uvlinesize;
2892 dest_cr+= s->uvlinesize;
2896 ptr_y += s->linesize;
2897 ptr_cb+= s->uvlinesize;
2898 ptr_cr+= s->uvlinesize;
2903 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2905 if(!(s->flags&CODEC_FLAG_GRAY)){
2906 uvsx <<= 2 - lowres;
2907 uvsy <<= 2 - lowres;
2908 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2909 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2911 //FIXME h261 lowres loop filter
2914 //FIXME move to dsputil, avg variant, 16x16 version
2915 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2917 uint8_t * const top = src[1];
2918 uint8_t * const left = src[2];
2919 uint8_t * const mid = src[0];
2920 uint8_t * const right = src[3];
2921 uint8_t * const bottom= src[4];
2922 #define OBMC_FILTER(x, t, l, m, r, b)\
2923 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2924 #define OBMC_FILTER4(x, t, l, m, r, b)\
2925 OBMC_FILTER(x , t, l, m, r, b);\
2926 OBMC_FILTER(x+1 , t, l, m, r, b);\
2927 OBMC_FILTER(x +stride, t, l, m, r, b);\
2928 OBMC_FILTER(x+1+stride, t, l, m, r, b);
2931 OBMC_FILTER (x , 2, 2, 4, 0, 0);
2932 OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2933 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2934 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2935 OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2936 OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2938 OBMC_FILTER (x , 1, 2, 5, 0, 0);
2939 OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2940 OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2941 OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2943 OBMC_FILTER4(x , 1, 2, 5, 0, 0);
2944 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2945 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2946 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2948 OBMC_FILTER4(x , 0, 2, 5, 0, 1);
2949 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2950 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2951 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2953 OBMC_FILTER (x , 0, 2, 5, 0, 1);
2954 OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2955 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2956 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2957 OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2958 OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2960 OBMC_FILTER (x , 0, 2, 4, 0, 2);
2961 OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2962 OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2963 OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2966 /* obmc for 1 8x8 luma block */
2967 static inline void obmc_motion(MpegEncContext *s,
2968 uint8_t *dest, uint8_t *src,
2969 int src_x, int src_y,
2970 op_pixels_func *pix_op,
2971 int16_t mv[5][2]/* mid top left right bottom*/)
2977 assert(s->quarter_sample==0);
2980 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2983 ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2984 hpel_motion(s, ptr[i], src, 0, 0,
2986 s->width, s->height, s->linesize,
2987 s->h_edge_pos, s->v_edge_pos,
2989 mv[i][0], mv[i][1]);
2993 put_obmc(dest, ptr, s->linesize);
2996 static inline void qpel_motion(MpegEncContext *s,
2997 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2998 int field_based, int bottom_field, int field_select,
2999 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3000 qpel_mc_func (*qpix_op)[16],
3001 int motion_x, int motion_y, int h)
3003 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3004 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3006 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3007 src_x = s->mb_x * 16 + (motion_x >> 2);
3008 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3010 v_edge_pos = s->v_edge_pos >> field_based;
3011 linesize = s->linesize << field_based;
3012 uvlinesize = s->uvlinesize << field_based;
3017 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3018 static const int rtab[8]= {0,0,1,1,0,0,0,1};
3019 mx= (motion_x>>1) + rtab[motion_x&7];
3020 my= (motion_y>>1) + rtab[motion_y&7];
3021 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3022 mx= (motion_x>>1)|(motion_x&1);
3023 my= (motion_y>>1)|(motion_y&1);
3031 uvdxy= (mx&1) | ((my&1)<<1);
3035 uvsrc_x = s->mb_x * 8 + mx;
3036 uvsrc_y = s->mb_y * (8 >> field_based) + my;
3038 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3039 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3040 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3042 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3043 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
3044 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3045 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3046 ptr_y= s->edge_emu_buffer;
3047 if(!(s->flags&CODEC_FLAG_GRAY)){
3048 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3049 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3050 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3051 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3052 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3059 qpix_op[0][dxy](dest_y, ptr_y, linesize);
3062 dest_y += s->linesize;
3063 dest_cb+= s->uvlinesize;
3064 dest_cr+= s->uvlinesize;
3068 ptr_y += s->linesize;
3069 ptr_cb += s->uvlinesize;
3070 ptr_cr += s->uvlinesize;
3072 //damn interlaced mode
3073 //FIXME boundary mirroring is not exactly correct here
3074 qpix_op[1][dxy](dest_y , ptr_y , linesize);
3075 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3077 if(!(s->flags&CODEC_FLAG_GRAY)){
3078 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3079 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3083 inline int ff_h263_round_chroma(int x){
3085 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3088 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3093 * h263 chorma 4mv motion compensation.
3095 static inline void chroma_4mv_motion(MpegEncContext *s,
3096 uint8_t *dest_cb, uint8_t *dest_cr,
3097 uint8_t **ref_picture,
3098 op_pixels_func *pix_op,
3100 int dxy, emu=0, src_x, src_y, offset;
3103 /* In case of 8X8, we construct a single chroma motion vector
3104 with a special rounding */
3105 mx= ff_h263_round_chroma(mx);
3106 my= ff_h263_round_chroma(my);
3108 dxy = ((my & 1) << 1) | (mx & 1);
3112 src_x = s->mb_x * 8 + mx;
3113 src_y = s->mb_y * 8 + my;
3114 src_x = clip(src_x, -8, s->width/2);
3115 if (src_x == s->width/2)
3117 src_y = clip(src_y, -8, s->height/2);
3118 if (src_y == s->height/2)
3121 offset = (src_y * (s->uvlinesize)) + src_x;
3122 ptr = ref_picture[1] + offset;
3123 if(s->flags&CODEC_FLAG_EMU_EDGE){
3124 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3125 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3126 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
3127 ptr= s->edge_emu_buffer;
3131 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3133 ptr = ref_picture[2] + offset;
3135 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
3136 ptr= s->edge_emu_buffer;
3138 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3141 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3142 uint8_t *dest_cb, uint8_t *dest_cr,
3143 uint8_t **ref_picture,
3144 h264_chroma_mc_func *pix_op,
3146 const int lowres= s->avctx->lowres;
3147 const int block_s= 8>>lowres;
3148 const int s_mask= (2<<lowres)-1;
3149 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3150 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3151 int emu=0, src_x, src_y, offset, sx, sy;
3154 if(s->quarter_sample){
3159 /* In case of 8X8, we construct a single chroma motion vector
3160 with a special rounding */
3161 mx= ff_h263_round_chroma(mx);
3162 my= ff_h263_round_chroma(my);
3166 src_x = s->mb_x*block_s + (mx >> (lowres+1));
3167 src_y = s->mb_y*block_s + (my >> (lowres+1));
3169 offset = src_y * s->uvlinesize + src_x;
3170 ptr = ref_picture[1] + offset;
3171 if(s->flags&CODEC_FLAG_EMU_EDGE){
3172 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3173 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3174 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3175 ptr= s->edge_emu_buffer;
3181 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3183 ptr = ref_picture[2] + offset;
3185 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3186 ptr= s->edge_emu_buffer;
3188 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3192 * motion compesation of a single macroblock
3194 * @param dest_y luma destination pointer
3195 * @param dest_cb chroma cb/u destination pointer
3196 * @param dest_cr chroma cr/v destination pointer
3197 * @param dir direction (0->forward, 1->backward)
3198 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3199 * @param pic_op halfpel motion compensation function (average or put normally)
3200 * @param pic_op qpel motion compensation function (average or put normally)
3201 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3203 static inline void MPV_motion(MpegEncContext *s,
3204 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3205 int dir, uint8_t **ref_picture,
3206 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3208 int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3210 uint8_t *ptr, *dest;
3215 if(s->obmc && s->pict_type != B_TYPE){
3216 int16_t mv_cache[4][4][2];
3217 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3218 const int mot_stride= s->b8_stride;
3219 const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3221 assert(!s->mb_skiped);
3223 memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy ], sizeof(int16_t)*4);
3224 memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3225 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3227 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3228 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3230 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3233 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3234 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3235 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3237 *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3238 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3241 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3242 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3243 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3245 *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3246 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3252 const int x= (i&1)+1;
3253 const int y= (i>>1)+1;
3255 {mv_cache[y][x ][0], mv_cache[y][x ][1]},
3256 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3257 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3258 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3259 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3261 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3263 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3270 if(!(s->flags&CODEC_FLAG_GRAY))
3271 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3276 switch(s->mv_type) {
3279 if(s->real_sprite_warping_points==1){
3280 gmc1_motion(s, dest_y, dest_cb, dest_cr,
3283 gmc_motion(s, dest_y, dest_cb, dest_cr,
3286 }else if(s->quarter_sample){
3287 qpel_motion(s, dest_y, dest_cb, dest_cr,
3289 ref_picture, pix_op, qpix_op,
3290 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3292 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3293 ref_picture, pix_op,
3294 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3297 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3299 ref_picture, pix_op,
3300 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3306 if(s->quarter_sample){
3308 motion_x = s->mv[dir][i][0];
3309 motion_y = s->mv[dir][i][1];
3311 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3312 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3313 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3315 /* WARNING: do no forget half pels */
3316 src_x = clip(src_x, -16, s->width);
3317 if (src_x == s->width)
3319 src_y = clip(src_y, -16, s->height);
3320 if (src_y == s->height)
3323 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3324 if(s->flags&CODEC_FLAG_EMU_EDGE){
3325 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3326 || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3327 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->linesize, 9, 9, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
3328 ptr= s->edge_emu_buffer;
3331 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3332 qpix_op[1][dxy](dest, ptr, s->linesize);
3334 mx += s->mv[dir][i][0]/2;
3335 my += s->mv[dir][i][1]/2;
3339 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3340 ref_picture[0], 0, 0,
3341 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3342 s->width, s->height, s->linesize,
3343 s->h_edge_pos, s->v_edge_pos,
3345 s->mv[dir][i][0], s->mv[dir][i][1]);
3347 mx += s->mv[dir][i][0];
3348 my += s->mv[dir][i][1];
3352 if(!(s->flags&CODEC_FLAG_GRAY))
3353 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3356 if (s->picture_structure == PICT_FRAME) {
3357 if(s->quarter_sample){
3359 qpel_motion(s, dest_y, dest_cb, dest_cr,
3360 1, i, s->field_select[dir][i],
3361 ref_picture, pix_op, qpix_op,
3362 s->mv[dir][i][0], s->mv[dir][i][1], 8);
3366 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3367 1, 0, s->field_select[dir][0],
3368 ref_picture, pix_op,
3369 s->mv[dir][0][0], s->mv[dir][0][1], 8);
3371 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3372 1, 1, s->field_select[dir][1],
3373 ref_picture, pix_op,
3374 s->mv[dir][1][0], s->mv[dir][1][1], 8);
3377 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3378 ref_picture= s->current_picture_ptr->data;
3381 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3382 0, 0, s->field_select[dir][0],
3383 ref_picture, pix_op,
3384 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3389 uint8_t ** ref2picture;
3391 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3392 ref2picture= ref_picture;
3394 ref2picture= s->current_picture_ptr->data;
3397 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3398 0, 0, s->field_select[dir][i],
3399 ref2picture, pix_op,
3400 s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3402 dest_y += 16*s->linesize;
3403 dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3404 dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3408 if(s->picture_structure == PICT_FRAME){
3412 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3414 ref_picture, pix_op,
3415 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3417 pix_op = s->dsp.avg_pixels_tab;
3421 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3422 0, 0, s->picture_structure != i+1,
3423 ref_picture, pix_op,
3424 s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3426 // after put we make avg of the same block
3427 pix_op=s->dsp.avg_pixels_tab;
3429 //opposite parity is always in the same frame if this is second field
3430 if(!s->first_field){
3431 ref_picture = s->current_picture_ptr->data;
3441 * motion compesation of a single macroblock
3443 * @param dest_y luma destination pointer
3444 * @param dest_cb chroma cb/u destination pointer
3445 * @param dest_cr chroma cr/v destination pointer
3446 * @param dir direction (0->forward, 1->backward)
3447 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3448 * @param pic_op halfpel motion compensation function (average or put normally)
3449 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3451 static inline void MPV_motion_lowres(MpegEncContext *s,
3452 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3453 int dir, uint8_t **ref_picture,
3454 h264_chroma_mc_func *pix_op)
3458 const int lowres= s->avctx->lowres;
3459 const int block_s= 8>>lowres;
3464 switch(s->mv_type) {
3466 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3468 ref_picture, pix_op,
3469 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3475 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3476 ref_picture[0], 0, 0,
3477 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3478 s->width, s->height, s->linesize,
3479 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3480 block_s, block_s, pix_op,
3481 s->mv[dir][i][0], s->mv[dir][i][1]);
3483 mx += s->mv[dir][i][0];
3484 my += s->mv[dir][i][1];
3487 if(!(s->flags&CODEC_FLAG_GRAY))
3488 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3491 if (s->picture_structure == PICT_FRAME) {
3493 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3494 1, 0, s->field_select[dir][0],
3495 ref_picture, pix_op,
3496 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3498 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3499 1, 1, s->field_select[dir][1],
3500 ref_picture, pix_op,
3501 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3503 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3504 ref_picture= s->current_picture_ptr->data;
3507 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3508 0, 0, s->field_select[dir][0],
3509 ref_picture, pix_op,
3510 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3515 uint8_t ** ref2picture;
3517 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3518 ref2picture= ref_picture;
3520 ref2picture= s->current_picture_ptr->data;
3523 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3524 0, 0, s->field_select[dir][i],
3525 ref2picture, pix_op,
3526 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3528 dest_y += 2*block_s*s->linesize;
3529 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3530 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3534 if(s->picture_structure == PICT_FRAME){
3538 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3540 ref_picture, pix_op,
3541 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3543 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3547 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3548 0, 0, s->picture_structure != i+1,
3549 ref_picture, pix_op,
3550 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3552 // after put we make avg of the same block
3553 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3555 //opposite parity is always in the same frame if this is second field
3556 if(!s->first_field){
3557 ref_picture = s->current_picture_ptr->data;
3566 /* put block[] to dest[] */
3567 static inline void put_dct(MpegEncContext *s,
3568 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3570 s->dct_unquantize_intra(s, block, i, qscale);
3571 s->dsp.idct_put (dest, line_size, block);
3574 /* add block[] to dest[] */
3575 static inline void add_dct(MpegEncContext *s,
3576 DCTELEM *block, int i, uint8_t *dest, int line_size)
3578 if (s->block_last_index[i] >= 0) {
3579 s->dsp.idct_add (dest, line_size, block);
3583 static inline void add_dequant_dct(MpegEncContext *s,
3584 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3586 if (s->block_last_index[i] >= 0) {
3587 s->dct_unquantize_inter(s, block, i, qscale);
3589 s->dsp.idct_add (dest, line_size, block);
3594 * cleans dc, ac, coded_block for the current non intra MB
3596 void ff_clean_intra_table_entries(MpegEncContext *s)
3598 int wrap = s->b8_stride;
3599 int xy = s->block_index[0];
3602 s->dc_val[0][xy + 1 ] =
3603 s->dc_val[0][xy + wrap] =
3604 s->dc_val[0][xy + 1 + wrap] = 1024;
3606 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
3607 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3608 if (s->msmpeg4_version>=3) {
3609 s->coded_block[xy ] =
3610 s->coded_block[xy + 1 ] =
3611 s->coded_block[xy + wrap] =
3612 s->coded_block[xy + 1 + wrap] = 0;
3615 wrap = s->mb_stride;
3616 xy = s->mb_x + s->mb_y * wrap;
3618 s->dc_val[2][xy] = 1024;
3620 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3621 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3623 s->mbintra_table[xy]= 0;
3626 /* generic function called after a macroblock has been parsed by the
3627 decoder or after it has been encoded by the encoder.
3629 Important variables used:
3630 s->mb_intra : true if intra macroblock
3631 s->mv_dir : motion vector direction
3632 s->mv_type : motion vector type
3633 s->mv : motion vector
3634 s->interlaced_dct : true if interlaced dct used (mpeg2)
3636 static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3639 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3641 if(s->avctx->xvmc_acceleration){
3642 XVMC_decode_mb(s);//xvmc uses pblocks
3650 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3651 /* save DCT coefficients */
3653 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3656 *dct++ = block[i][s->dsp.idct_permutation[j]];
3659 s->current_picture.qscale_table[mb_xy]= s->qscale;
3661 /* update DC predictors for P macroblocks */
3663 if (s->h263_pred || s->h263_aic) {
3664 if(s->mbintra_table[mb_xy])
3665 ff_clean_intra_table_entries(s);
3669 s->last_dc[2] = 128 << s->intra_dc_precision;
3672 else if (s->h263_pred || s->h263_aic)
3673 s->mbintra_table[mb_xy]=1;
3675 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3676 uint8_t *dest_y, *dest_cb, *dest_cr;
3677 int dct_linesize, dct_offset;
3678 op_pixels_func (*op_pix)[4];
3679 qpel_mc_func (*op_qpix)[16];
3680 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3681 const int uvlinesize= s->current_picture.linesize[1];
3682 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3683 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3685 /* avoid copy if macroblock skipped in last frame too */
3686 /* skip only during decoding as we might trash the buffers during encoding a bit */
3688 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3689 const int age= s->current_picture.age;
3695 assert(s->pict_type!=I_TYPE);
3697 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3698 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3700 /* if previous was skipped too, then nothing to do ! */
3701 if (*mbskip_ptr >= age && s->current_picture.reference){
3704 } else if(!s->current_picture.reference){
3705 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3706 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3708 *mbskip_ptr = 0; /* not skipped */
3712 dct_linesize = linesize << s->interlaced_dct;
3713 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3717 dest_cb= s->dest[1];
3718 dest_cr= s->dest[2];
3720 dest_y = s->b_scratchpad;
3721 dest_cb= s->b_scratchpad+16*linesize;
3722 dest_cr= s->b_scratchpad+32*linesize;
3726 /* motion handling */
3727 /* decoding or more than one mb_type (MC was allready done otherwise) */
3730 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3732 if (s->mv_dir & MV_DIR_FORWARD) {
3733 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3734 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3736 if (s->mv_dir & MV_DIR_BACKWARD) {
3737 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3740 if ((!s->no_rounding) || s->pict_type==B_TYPE){
3741 op_pix = s->dsp.put_pixels_tab;
3742 op_qpix= s->dsp.put_qpel_pixels_tab;
3744 op_pix = s->dsp.put_no_rnd_pixels_tab;
3745 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3747 if (s->mv_dir & MV_DIR_FORWARD) {
3748 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3749 op_pix = s->dsp.avg_pixels_tab;
3750 op_qpix= s->dsp.avg_qpel_pixels_tab;
3752 if (s->mv_dir & MV_DIR_BACKWARD) {
3753 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3758 /* skip dequant / idct if we are really late ;) */
3759 if(s->hurry_up>1) return;
3761 /* add dct residue */
3762 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3763 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3764 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
3765 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
3766 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
3767 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3769 if(!(s->flags&CODEC_FLAG_GRAY)){
3770 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3771 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3773 } else if(s->codec_id != CODEC_ID_WMV2){
3774 add_dct(s, block[0], 0, dest_y , dct_linesize);
3775 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
3776 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
3777 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3779 if(!(s->flags&CODEC_FLAG_GRAY)){
3780 if(s->chroma_y_shift){//Chroma420
3781 add_dct(s, block[4], 4, dest_cb, uvlinesize);
3782 add_dct(s, block[5], 5, dest_cr, uvlinesize);
3785 dct_linesize = uvlinesize << s->interlaced_dct;
3786 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3788 add_dct(s, block[4], 4, dest_cb, dct_linesize);
3789 add_dct(s, block[5], 5, dest_cr, dct_linesize);
3790 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3791 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3792 if(!s->chroma_x_shift){//Chroma444
3793 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3794 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3795 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3796 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3802 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3805 /* dct only in intra block */
3806 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3807 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
3808 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
3809 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
3810 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3812 if(!(s->flags&CODEC_FLAG_GRAY)){
3813 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3814 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3817 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
3818 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
3819 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
3820 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3822 if(!(s->flags&CODEC_FLAG_GRAY)){
3823 if(s->chroma_y_shift){
3824 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3825 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3828 dct_linesize = uvlinesize << s->interlaced_dct;
3829 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3831 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
3832 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
3833 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3834 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3835 if(!s->chroma_x_shift){//Chroma444
3836 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
3837 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
3838 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3839 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3846 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
3847 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3848 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3853 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
3854 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
3855 else MPV_decode_mb_internal(s, block, 0);
3858 #ifdef CONFIG_ENCODERS
3860 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3862 static const char tab[64]=
3874 DCTELEM *block= s->block[n];
3875 const int last_index= s->block_last_index[n];
3880 threshold= -threshold;
3884 /* are all which we could set to zero are allready zero? */
3885 if(last_index<=skip_dc - 1) return;
3887 for(i=0; i<=last_index; i++){
3888 const int j = s->intra_scantable.permutated[i];
3889 const int level = ABS(block[j]);
3891 if(skip_dc && i==0) continue;
3900 if(score >= threshold) return;
3901 for(i=skip_dc; i<=last_index; i++){
3902 const int j = s->intra_scantable.permutated[i];
3905 if(block[0]) s->block_last_index[n]= 0;
3906 else s->block_last_index[n]= -1;
3909 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3912 const int maxlevel= s->max_qcoeff;
3913 const int minlevel= s->min_qcoeff;
3917 i=1; //skip clipping of intra dc
3921 for(;i<=last_index; i++){
3922 const int j= s->intra_scantable.permutated[i];
3923 int level = block[j];
3925 if (level>maxlevel){
3928 }else if(level<minlevel){
3936 if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3937 av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3940 #endif //CONFIG_ENCODERS
3944 * @param h is the normal height, this will be reduced automatically if needed for the last row
3946 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3947 if (s->avctx->draw_horiz_band) {
3951 if(s->picture_structure != PICT_FRAME){
3954 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3957 h= FFMIN(h, s->avctx->height - y);
3959 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
3960 src= (AVFrame*)s->current_picture_ptr;
3961 else if(s->last_picture_ptr)
3962 src= (AVFrame*)s->last_picture_ptr;
3966 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3972 offset[0]= y * s->linesize;;
3974 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
3980 s->avctx->draw_horiz_band(s->avctx, src, offset,
3981 y, s->picture_structure, h);
3985 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3986 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3987 const int uvlinesize= s->current_picture.linesize[1];
3988 const int mb_size= 4 - s->avctx->lowres;
3990 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
3991 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
3992 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3993 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3994 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3995 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;
3996 //block_index is not used by mpeg2, so it is not affected by chroma_format
3998 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
3999 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4000 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4002 if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
4004 s->dest[0] += s->mb_y * linesize << mb_size;
4005 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4006 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4010 #ifdef CONFIG_ENCODERS
4012 static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
4022 for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
4023 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
4024 int v= ptr[x2 + y2*stride];