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;
244 #endif //CONFIG_ENCODERS
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+4) * sizeof(int16_t))
389 pic->motion_val[i]= pic->motion_val_base[i]+4;
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+4) * sizeof(int16_t))
396 pic->motion_val[i]= pic->motion_val_base[i]+4;
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= (INT_MAX/2+128)>>8;
1059 if(avctx->me_threshold >= i){
1060 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1063 if(avctx->mb_threshold >= i){
1064 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1068 i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
1070 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1071 avctx->frame_rate /= i;
1072 avctx->frame_rate_base /= i;
1076 if(s->codec_id==CODEC_ID_MJPEG){
1077 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1078 s->inter_quant_bias= 0;
1079 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1080 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1081 s->inter_quant_bias= 0;
1083 s->intra_quant_bias=0;
1084 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1087 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1088 s->intra_quant_bias= avctx->intra_quant_bias;
1089 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1090 s->inter_quant_bias= avctx->inter_quant_bias;
1092 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1094 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1095 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1097 switch(avctx->codec->id) {
1098 case CODEC_ID_MPEG1VIDEO:
1099 s->out_format = FMT_MPEG1;
1100 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1101 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1103 case CODEC_ID_MPEG2VIDEO:
1104 s->out_format = FMT_MPEG1;
1105 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1106 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1109 case CODEC_ID_LJPEG:
1110 case CODEC_ID_MJPEG:
1111 s->out_format = FMT_MJPEG;
1112 s->intra_only = 1; /* force intra only for jpeg */
1113 s->mjpeg_write_tables = 1; /* write all tables */
1114 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1115 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1116 s->mjpeg_vsample[1] = 1;
1117 s->mjpeg_vsample[2] = 1;
1118 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1119 s->mjpeg_hsample[1] = 1;
1120 s->mjpeg_hsample[2] = 1;
1121 if (mjpeg_init(s) < 0)
1127 s->out_format = FMT_H261;
1132 if (h263_get_picture_format(s->width, s->height) == 7) {
1133 av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
1136 s->out_format = FMT_H263;
1137 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1141 case CODEC_ID_H263P:
1142 s->out_format = FMT_H263;
1145 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1146 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1147 s->modified_quant= s->h263_aic;
1148 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1149 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1150 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1151 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1152 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1155 /* These are just to be sure */
1160 s->out_format = FMT_H263;
1161 s->h263_flv = 2; /* format = 1; 11-bit codes */
1162 s->unrestricted_mv = 1;
1163 s->rtp_mode=0; /* don't allow GOB */
1168 s->out_format = FMT_H263;
1173 s->out_format = FMT_H263;
1176 s->modified_quant=1;
1180 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1182 case CODEC_ID_MPEG4:
1183 s->out_format = FMT_H263;
1185 s->unrestricted_mv = 1;
1186 s->low_delay= s->max_b_frames ? 0 : 1;
1187 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1189 case CODEC_ID_MSMPEG4V1:
1190 s->out_format = FMT_H263;
1191 s->h263_msmpeg4 = 1;
1193 s->unrestricted_mv = 1;
1194 s->msmpeg4_version= 1;
1198 case CODEC_ID_MSMPEG4V2:
1199 s->out_format = FMT_H263;
1200 s->h263_msmpeg4 = 1;
1202 s->unrestricted_mv = 1;
1203 s->msmpeg4_version= 2;
1207 case CODEC_ID_MSMPEG4V3:
1208 s->out_format = FMT_H263;
1209 s->h263_msmpeg4 = 1;
1211 s->unrestricted_mv = 1;
1212 s->msmpeg4_version= 3;
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= 4;
1223 s->flipflop_rounding=1;
1228 s->out_format = FMT_H263;
1229 s->h263_msmpeg4 = 1;
1231 s->unrestricted_mv = 1;
1232 s->msmpeg4_version= 5;
1233 s->flipflop_rounding=1;
1241 avctx->has_b_frames= !s->low_delay;
1246 if (MPV_common_init(s) < 0)
1249 if(s->modified_quant)
1250 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1251 s->progressive_frame=
1252 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1253 s->quant_precision=5;
1255 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1256 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1258 if (s->out_format == FMT_H261)
1259 ff_h261_encode_init(s);
1260 if (s->out_format == FMT_H263)
1261 h263_encode_init(s);
1262 if(s->msmpeg4_version)
1263 ff_msmpeg4_encode_init(s);
1264 if (s->out_format == FMT_MPEG1)
1265 ff_mpeg1_encode_init(s);
1269 int j= s->dsp.idct_permutation[i];
1270 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1271 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1272 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1273 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1274 s->intra_matrix[j] =
1275 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1278 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1279 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1281 if(s->avctx->intra_matrix)
1282 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1283 if(s->avctx->inter_matrix)
1284 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1287 /* precompute matrix */
1288 /* for mjpeg, we do include qscale in the matrix */
1289 if (s->out_format != FMT_MJPEG) {
1290 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1291 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1292 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1293 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1296 if(ff_rate_control_init(s) < 0)
1302 int MPV_encode_end(AVCodecContext *avctx)
1304 MpegEncContext *s = avctx->priv_data;
1310 ff_rate_control_uninit(s);
1313 if (s->out_format == FMT_MJPEG)
1316 av_freep(&avctx->extradata);
1321 #endif //CONFIG_ENCODERS
1323 void init_rl(RLTable *rl, int use_static)
1325 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1326 uint8_t index_run[MAX_RUN+1];
1327 int last, run, level, start, end, i;
1329 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1330 if(use_static && rl->max_level[0])
1333 /* compute max_level[], max_run[] and index_run[] */
1334 for(last=0;last<2;last++) {
1343 memset(max_level, 0, MAX_RUN + 1);
1344 memset(max_run, 0, MAX_LEVEL + 1);
1345 memset(index_run, rl->n, MAX_RUN + 1);
1346 for(i=start;i<end;i++) {
1347 run = rl->table_run[i];
1348 level = rl->table_level[i];
1349 if (index_run[run] == rl->n)
1351 if (level > max_level[run])
1352 max_level[run] = level;
1353 if (run > max_run[level])
1354 max_run[level] = run;
1357 rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1359 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1360 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1362 rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1364 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1365 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1367 rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1369 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1370 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1374 /* draw the edges of width 'w' of an image of size width, height */
1375 //FIXME check that this is ok for mpeg4 interlaced
1376 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1378 uint8_t *ptr, *last_line;
1381 last_line = buf + (height - 1) * wrap;
1383 /* top and bottom */
1384 memcpy(buf - (i + 1) * wrap, buf, width);
1385 memcpy(last_line + (i + 1) * wrap, last_line, width);
1387 /* left and right */
1389 for(i=0;i<height;i++) {
1390 memset(ptr - w, ptr[0], w);
1391 memset(ptr + width, ptr[width-1], w);
1396 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1397 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1398 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1399 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1403 int ff_find_unused_picture(MpegEncContext *s, int shared){
1407 for(i=0; i<MAX_PICTURE_COUNT; i++){
1408 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1411 for(i=0; i<MAX_PICTURE_COUNT; i++){
1412 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1414 for(i=0; i<MAX_PICTURE_COUNT; i++){
1415 if(s->picture[i].data[0]==NULL) return i;
1423 static void update_noise_reduction(MpegEncContext *s){
1426 for(intra=0; intra<2; intra++){
1427 if(s->dct_count[intra] > (1<<16)){
1428 for(i=0; i<64; i++){
1429 s->dct_error_sum[intra][i] >>=1;
1431 s->dct_count[intra] >>= 1;
1434 for(i=0; i<64; i++){
1435 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);
1441 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1443 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1449 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1451 /* mark&release old frames */
1452 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1453 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1455 /* release forgotten pictures */
1456 /* if(mpeg124/h263) */
1458 for(i=0; i<MAX_PICTURE_COUNT; i++){
1459 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1460 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1461 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1468 /* release non refernce frames */
1469 for(i=0; i<MAX_PICTURE_COUNT; i++){
1470 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1471 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1475 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1476 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1478 i= ff_find_unused_picture(s, 0);
1479 pic= (AVFrame*)&s->picture[i];
1482 pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1483 && !s->dropable ? 3 : 0;
1485 pic->coded_picture_number= s->coded_picture_number++;
1487 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1490 s->current_picture_ptr= (Picture*)pic;
1491 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1492 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1495 s->current_picture_ptr->pict_type= s->pict_type;
1496 // if(s->flags && CODEC_FLAG_QSCALE)
1497 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1498 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1500 copy_picture(&s->current_picture, s->current_picture_ptr);
1502 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1503 if (s->pict_type != B_TYPE) {
1504 s->last_picture_ptr= s->next_picture_ptr;
1506 s->next_picture_ptr= s->current_picture_ptr;
1508 /* 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,
1509 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1510 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1511 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1512 s->pict_type, s->dropable);*/
1514 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1515 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1517 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1518 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1519 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1523 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1525 if(s->picture_structure!=PICT_FRAME){
1528 if(s->picture_structure == PICT_BOTTOM_FIELD){
1529 s->current_picture.data[i] += s->current_picture.linesize[i];
1531 s->current_picture.linesize[i] *= 2;
1532 s->last_picture.linesize[i] *=2;
1533 s->next_picture.linesize[i] *=2;
1538 s->hurry_up= s->avctx->hurry_up;
1539 s->error_resilience= avctx->error_resilience;
1541 /* set dequantizer, we cant do it during init as it might change for mpeg4
1542 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1543 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1544 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1545 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1546 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1547 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1548 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1550 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1551 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1554 if(s->dct_error_sum){
1555 assert(s->avctx->noise_reduction && s->encoding);
1557 update_noise_reduction(s);
1561 if(s->avctx->xvmc_acceleration)
1562 return XVMC_field_start(s, avctx);
1567 /* generic function for encode/decode called after a frame has been coded/decoded */
1568 void MPV_frame_end(MpegEncContext *s)
1571 /* draw edge for correct motion prediction if outside */
1573 //just to make sure that all data is rendered.
1574 if(s->avctx->xvmc_acceleration){
1578 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1579 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1580 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1581 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1585 s->last_pict_type = s->pict_type;
1586 if(s->pict_type!=B_TYPE){
1587 s->last_non_b_pict_type= s->pict_type;
1590 /* copy back current_picture variables */
1591 for(i=0; i<MAX_PICTURE_COUNT; i++){
1592 if(s->picture[i].data[0] == s->current_picture.data[0]){
1593 s->picture[i]= s->current_picture;
1597 assert(i<MAX_PICTURE_COUNT);
1601 /* release non refernce frames */
1602 for(i=0; i<MAX_PICTURE_COUNT; i++){
1603 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1604 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1608 // clear copies, to avoid confusion
1610 memset(&s->last_picture, 0, sizeof(Picture));
1611 memset(&s->next_picture, 0, sizeof(Picture));
1612 memset(&s->current_picture, 0, sizeof(Picture));
1614 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1618 * draws an line from (ex, ey) -> (sx, sy).
1619 * @param w width of the image
1620 * @param h height of the image
1621 * @param stride stride/linesize of the image
1622 * @param color color of the arrow
1624 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1627 sx= clip(sx, 0, w-1);
1628 sy= clip(sy, 0, h-1);
1629 ex= clip(ex, 0, w-1);
1630 ey= clip(ey, 0, h-1);
1632 buf[sy*stride + sx]+= color;
1634 if(ABS(ex - sx) > ABS(ey - sy)){
1639 buf+= sx + sy*stride;
1641 f= ((ey-sy)<<16)/ex;
1642 for(x= 0; x <= ex; x++){
1645 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1646 buf[(y+1)*stride + x]+= (color* fr )>>16;
1653 buf+= sx + sy*stride;
1655 if(ey) f= ((ex-sx)<<16)/ey;
1657 for(y= 0; y <= ey; y++){
1660 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1661 buf[y*stride + x+1]+= (color* fr )>>16;;
1667 * draws an arrow from (ex, ey) -> (sx, sy).
1668 * @param w width of the image
1669 * @param h height of the image
1670 * @param stride stride/linesize of the image
1671 * @param color color of the arrow
1673 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1676 sx= clip(sx, -100, w+100);
1677 sy= clip(sy, -100, h+100);
1678 ex= clip(ex, -100, w+100);
1679 ey= clip(ey, -100, h+100);
1684 if(dx*dx + dy*dy > 3*3){
1687 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1689 //FIXME subpixel accuracy
1690 rx= ROUNDED_DIV(rx*3<<4, length);
1691 ry= ROUNDED_DIV(ry*3<<4, length);
1693 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1694 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1696 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1700 * prints debuging info for the given picture.
1702 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1704 if(!pict || !pict->mb_type) return;
1706 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1709 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1710 switch (pict->pict_type) {
1711 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1712 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1713 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1714 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1715 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1716 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1718 for(y=0; y<s->mb_height; y++){
1719 for(x=0; x<s->mb_width; x++){
1720 if(s->avctx->debug&FF_DEBUG_SKIP){
1721 int count= s->mbskip_table[x + y*s->mb_stride];
1722 if(count>9) count=9;
1723 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1725 if(s->avctx->debug&FF_DEBUG_QP){
1726 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1728 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1729 int mb_type= pict->mb_type[x + y*s->mb_stride];
1730 //Type & MV direction
1732 av_log(s->avctx, AV_LOG_DEBUG, "P");
1733 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1734 av_log(s->avctx, AV_LOG_DEBUG, "A");
1735 else if(IS_INTRA4x4(mb_type))
1736 av_log(s->avctx, AV_LOG_DEBUG, "i");
1737 else if(IS_INTRA16x16(mb_type))
1738 av_log(s->avctx, AV_LOG_DEBUG, "I");
1739 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1740 av_log(s->avctx, AV_LOG_DEBUG, "d");
1741 else if(IS_DIRECT(mb_type))
1742 av_log(s->avctx, AV_LOG_DEBUG, "D");
1743 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1744 av_log(s->avctx, AV_LOG_DEBUG, "g");
1745 else if(IS_GMC(mb_type))
1746 av_log(s->avctx, AV_LOG_DEBUG, "G");
1747 else if(IS_SKIP(mb_type))
1748 av_log(s->avctx, AV_LOG_DEBUG, "S");
1749 else if(!USES_LIST(mb_type, 1))
1750 av_log(s->avctx, AV_LOG_DEBUG, ">");
1751 else if(!USES_LIST(mb_type, 0))
1752 av_log(s->avctx, AV_LOG_DEBUG, "<");
1754 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1755 av_log(s->avctx, AV_LOG_DEBUG, "X");
1760 av_log(s->avctx, AV_LOG_DEBUG, "+");
1761 else if(IS_16X8(mb_type))
1762 av_log(s->avctx, AV_LOG_DEBUG, "-");
1763 else if(IS_8X16(mb_type))
1764 av_log(s->avctx, AV_LOG_DEBUG, "¦");
1765 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1766 av_log(s->avctx, AV_LOG_DEBUG, " ");
1768 av_log(s->avctx, AV_LOG_DEBUG, "?");
1771 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1772 av_log(s->avctx, AV_LOG_DEBUG, "=");
1774 av_log(s->avctx, AV_LOG_DEBUG, " ");
1776 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1778 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1782 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1783 const int shift= 1 + s->quarter_sample;
1787 int h_chroma_shift, v_chroma_shift;
1788 const int width = s->avctx->width;
1789 const int height= s->avctx->height;
1790 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1791 const int mv_stride= (s->mb_width << mv_sample_log2) + 1;
1792 s->low_delay=0; //needed to see the vectors without trashing the buffers
1794 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1796 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1797 pict->data[i]= s->visualization_buffer[i];
1799 pict->type= FF_BUFFER_TYPE_COPY;
1802 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1804 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1805 const int mb_index= mb_x + mb_y*s->mb_stride;
1806 if((s->avctx->debug_mv) && pict->motion_val){
1808 for(type=0; type<3; type++){
1811 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1815 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1819 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1824 if(!USES_LIST(pict->mb_type[mb_index], direction))
1827 if(IS_8X8(pict->mb_type[mb_index])){
1830 int sx= mb_x*16 + 4 + 8*(i&1);
1831 int sy= mb_y*16 + 4 + 8*(i>>1);
1832 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1833 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1834 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1835 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1837 }else if(IS_16X8(pict->mb_type[mb_index])){
1841 int sy=mb_y*16 + 4 + 8*i;
1842 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1843 int mx=(pict->motion_val[direction][xy][0]>>shift);
1844 int my=(pict->motion_val[direction][xy][1]>>shift);
1846 if(IS_INTERLACED(pict->mb_type[mb_index]))
1849 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1851 }else if(IS_8X16(pict->mb_type[mb_index])){
1854 int sx=mb_x*16 + 4 + 8*i;
1856 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1857 int mx=(pict->motion_val[direction][xy][0]>>shift);
1858 int my=(pict->motion_val[direction][xy][1]>>shift);
1860 if(IS_INTERLACED(pict->mb_type[mb_index]))
1863 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1866 int sx= mb_x*16 + 8;
1867 int sy= mb_y*16 + 8;
1868 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1869 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1870 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1871 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1875 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1876 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1879 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1880 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1883 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1884 int mb_type= pict->mb_type[mb_index];
1887 #define COLOR(theta, r)\
1888 u= (int)(128 + r*cos(theta*3.141592/180));\
1889 v= (int)(128 + r*sin(theta*3.141592/180));
1893 if(IS_PCM(mb_type)){
1895 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1897 }else if(IS_INTRA4x4(mb_type)){
1899 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1901 }else if(IS_DIRECT(mb_type)){
1903 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1905 }else if(IS_GMC(mb_type)){
1907 }else if(IS_SKIP(mb_type)){
1909 }else if(!USES_LIST(mb_type, 1)){
1911 }else if(!USES_LIST(mb_type, 0)){
1914 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1918 u*= 0x0101010101010101ULL;
1919 v*= 0x0101010101010101ULL;
1921 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1922 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1926 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1927 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1928 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1930 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1932 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1934 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1935 int dm= 1 << (mv_sample_log2-2);
1937 int sx= mb_x*16 + 8*(i&1);
1938 int sy= mb_y*16 + 8*(i>>1);
1939 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1941 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1942 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1944 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1945 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1946 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1950 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1954 s->mbskip_table[mb_index]=0;
1960 #ifdef CONFIG_ENCODERS
1962 static int get_sae(uint8_t *src, int ref, int stride){
1966 for(y=0; y<16; y++){
1967 for(x=0; x<16; x++){
1968 acc+= ABS(src[x+y*stride] - ref);
1975 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1982 for(y=0; y<h; y+=16){
1983 for(x=0; x<w; x+=16){
1984 int offset= x + y*stride;
1985 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1986 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1987 int sae = get_sae(src + offset, mean, stride);
1989 acc+= sae + 500 < sad;
1996 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2000 const int encoding_delay= s->max_b_frames;
2005 pic_arg->display_picture_number= s->input_picture_number++;
2007 if(pts != AV_NOPTS_VALUE){
2008 if(s->user_specified_pts != AV_NOPTS_VALUE){
2009 int64_t time= av_rescale(pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
2010 int64_t last= av_rescale(s->user_specified_pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
2013 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pts, s->user_specified_pts);
2017 s->user_specified_pts= pts;
2019 if(s->user_specified_pts != AV_NOPTS_VALUE){
2020 s->user_specified_pts=
2021 pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
2022 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pts);
2024 pts= av_rescale(pic_arg->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
2030 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2031 if(pic_arg->linesize[0] != s->linesize) direct=0;
2032 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2033 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2035 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2038 i= ff_find_unused_picture(s, 1);
2040 pic= (AVFrame*)&s->picture[i];
2044 pic->data[i]= pic_arg->data[i];
2045 pic->linesize[i]= pic_arg->linesize[i];
2047 alloc_picture(s, (Picture*)pic, 1);
2050 i= ff_find_unused_picture(s, 0);
2052 pic= (AVFrame*)&s->picture[i];
2055 alloc_picture(s, (Picture*)pic, 0);
2057 if( pic->data[0] + offset == pic_arg->data[0]
2058 && pic->data[1] + offset == pic_arg->data[1]
2059 && pic->data[2] + offset == pic_arg->data[2]){
2062 int h_chroma_shift, v_chroma_shift;
2063 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2066 int src_stride= pic_arg->linesize[i];
2067 int dst_stride= i ? s->uvlinesize : s->linesize;
2068 int h_shift= i ? h_chroma_shift : 0;
2069 int v_shift= i ? v_chroma_shift : 0;
2070 int w= s->width >>h_shift;
2071 int h= s->height>>v_shift;
2072 uint8_t *src= pic_arg->data[i];
2073 uint8_t *dst= pic->data[i] + offset;
2075 if(src_stride==dst_stride)
2076 memcpy(dst, src, src_stride*h);
2079 memcpy(dst, src, w);
2087 copy_picture_attributes(s, pic, pic_arg);
2088 pic->pts= pts; //we set this here to avoid modifiying pic_arg
2091 /* shift buffer entries */
2092 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2093 s->input_picture[i-1]= s->input_picture[i];
2095 s->input_picture[encoding_delay]= (Picture*)pic;
2100 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2105 for(plane=0; plane<3; plane++){
2106 const int stride= p->linesize[plane];
2107 const int bw= plane ? 1 : 2;
2108 for(y=0; y<s->mb_height*bw; y++){
2109 for(x=0; x<s->mb_width*bw; x++){
2110 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);
2112 switch(s->avctx->frame_skip_exp){
2113 case 0: score= FFMAX(score, v); break;
2114 case 1: score+= ABS(v);break;
2115 case 2: score+= v*v;break;
2116 case 3: score64+= ABS(v*v*(int64_t)v);break;
2117 case 4: score64+= v*v*(int64_t)(v*v);break;
2123 if(score) score64= score;
2125 if(score64 < s->avctx->frame_skip_threshold)
2127 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2132 static void select_input_picture(MpegEncContext *s){
2135 for(i=1; i<MAX_PICTURE_COUNT; i++)
2136 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2137 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2139 /* set next picture types & ordering */
2140 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2141 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2142 s->reordered_input_picture[0]= s->input_picture[0];
2143 s->reordered_input_picture[0]->pict_type= I_TYPE;
2144 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2148 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2149 if(skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2150 //av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2152 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2154 s->input_picture[0]->data[i]= NULL;
2155 s->input_picture[0]->type= 0;
2157 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2158 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2160 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2167 if(s->flags&CODEC_FLAG_PASS2){
2168 for(i=0; i<s->max_b_frames+1; i++){
2169 int pict_num= s->input_picture[0]->display_picture_number + i;
2171 if(pict_num >= s->rc_context.num_entries)
2173 if(!s->input_picture[i]){
2174 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2178 s->input_picture[i]->pict_type=
2179 s->rc_context.entry[pict_num].new_pict_type;
2183 if(s->avctx->b_frame_strategy==0){
2184 b_frames= s->max_b_frames;
2185 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2186 }else if(s->avctx->b_frame_strategy==1){
2187 for(i=1; i<s->max_b_frames+1; i++){
2188 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2189 s->input_picture[i]->b_frame_score=
2190 get_intra_count(s, s->input_picture[i ]->data[0],
2191 s->input_picture[i-1]->data[0], s->linesize) + 1;
2194 for(i=0; i<s->max_b_frames; i++){
2195 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2198 b_frames= FFMAX(0, i-1);
2201 for(i=0; i<b_frames+1; i++){
2202 s->input_picture[i]->b_frame_score=0;
2205 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2210 //static int b_count=0;
2211 //b_count+= b_frames;
2212 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2214 for(i= b_frames - 1; i>=0; i--){
2215 int type= s->input_picture[i]->pict_type;
2216 if(type && type != B_TYPE)
2219 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2220 av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2223 if(s->picture_in_gop_number + b_frames >= s->gop_size){
2224 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2225 b_frames= s->gop_size - s->picture_in_gop_number - 1;
2227 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2229 s->input_picture[b_frames]->pict_type= I_TYPE;
2233 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2235 && s->input_picture[b_frames]->pict_type== I_TYPE)
2238 s->reordered_input_picture[0]= s->input_picture[b_frames];
2239 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2240 s->reordered_input_picture[0]->pict_type= P_TYPE;
2241 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2242 for(i=0; i<b_frames; i++){
2243 s->reordered_input_picture[i+1]= s->input_picture[i];
2244 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2245 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2250 if(s->reordered_input_picture[0]){
2251 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2253 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2255 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2256 // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2258 int i= ff_find_unused_picture(s, 0);
2259 Picture *pic= &s->picture[i];
2261 /* mark us unused / free shared pic */
2263 s->reordered_input_picture[0]->data[i]= NULL;
2264 s->reordered_input_picture[0]->type= 0;
2266 pic->reference = s->reordered_input_picture[0]->reference;
2268 alloc_picture(s, pic, 0);
2270 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2272 s->current_picture_ptr= pic;
2274 // input is not a shared pix -> reuse buffer for current_pix
2276 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2277 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2279 s->current_picture_ptr= s->reordered_input_picture[0];
2281 s->new_picture.data[i]+=16;
2284 copy_picture(&s->current_picture, s->current_picture_ptr);
2286 s->picture_number= s->new_picture.display_picture_number;
2287 //printf("dpn:%d\n", s->picture_number);
2289 memset(&s->new_picture, 0, sizeof(Picture));
2293 int MPV_encode_picture(AVCodecContext *avctx,
2294 unsigned char *buf, int buf_size, void *data)
2296 MpegEncContext *s = avctx->priv_data;
2297 AVFrame *pic_arg = data;
2298 int i, stuffing_count;
2300 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUVJ420P){
2301 av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2305 for(i=0; i<avctx->thread_count; i++){
2306 int start_y= s->thread_context[i]->start_mb_y;
2307 int end_y= s->thread_context[i]-> end_mb_y;
2308 int h= s->mb_height;
2309 uint8_t *start= buf + buf_size*start_y/h;
2310 uint8_t *end = buf + buf_size* end_y/h;
2312 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2315 s->picture_in_gop_number++;
2317 if(load_input_picture(s, pic_arg) < 0)
2320 select_input_picture(s);
2323 if(s->new_picture.data[0]){
2324 s->pict_type= s->new_picture.pict_type;
2326 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2327 MPV_frame_start(s, avctx);
2329 encode_picture(s, s->picture_number);
2331 avctx->real_pict_num = s->picture_number;
2332 avctx->header_bits = s->header_bits;
2333 avctx->mv_bits = s->mv_bits;
2334 avctx->misc_bits = s->misc_bits;
2335 avctx->i_tex_bits = s->i_tex_bits;
2336 avctx->p_tex_bits = s->p_tex_bits;
2337 avctx->i_count = s->i_count;
2338 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2339 avctx->skip_count = s->skip_count;
2343 if (s->out_format == FMT_MJPEG)
2344 mjpeg_picture_trailer(s);
2346 if(s->flags&CODEC_FLAG_PASS1)
2347 ff_write_pass1_stats(s);
2350 avctx->error[i] += s->current_picture_ptr->error[i];
2353 if(s->flags&CODEC_FLAG_PASS1)
2354 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2355 flush_put_bits(&s->pb);
2356 s->frame_bits = put_bits_count(&s->pb);
2358 stuffing_count= ff_vbv_update(s, s->frame_bits);
2360 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2361 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2365 switch(s->codec_id){
2366 case CODEC_ID_MPEG1VIDEO:
2367 case CODEC_ID_MPEG2VIDEO:
2368 while(stuffing_count--){
2369 put_bits(&s->pb, 8, 0);
2372 case CODEC_ID_MPEG4:
2373 put_bits(&s->pb, 16, 0);
2374 put_bits(&s->pb, 16, 0x1C3);
2375 stuffing_count -= 4;
2376 while(stuffing_count--){
2377 put_bits(&s->pb, 8, 0xFF);
2381 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2383 flush_put_bits(&s->pb);
2384 s->frame_bits = put_bits_count(&s->pb);
2387 /* update mpeg1/2 vbv_delay for CBR */
2388 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2389 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2392 assert(s->repeat_first_field==0);
2394 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2395 assert(vbv_delay < 0xFFFF);
2397 s->vbv_delay_ptr[0] &= 0xF8;
2398 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2399 s->vbv_delay_ptr[1] = vbv_delay>>5;
2400 s->vbv_delay_ptr[2] &= 0x07;
2401 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2403 s->total_bits += s->frame_bits;
2404 avctx->frame_bits = s->frame_bits;
2406 assert((pbBufPtr(&s->pb) == s->pb.buf));
2409 assert((s->frame_bits&7)==0);
2411 return s->frame_bits/8;
2414 #endif //CONFIG_ENCODERS
2416 static inline void gmc1_motion(MpegEncContext *s,
2417 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2418 uint8_t **ref_picture)
2421 int offset, src_x, src_y, linesize, uvlinesize;
2422 int motion_x, motion_y;
2425 motion_x= s->sprite_offset[0][0];
2426 motion_y= s->sprite_offset[0][1];
2427 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2428 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2429 motion_x<<=(3-s->sprite_warping_accuracy);
2430 motion_y<<=(3-s->sprite_warping_accuracy);
2431 src_x = clip(src_x, -16, s->width);
2432 if (src_x == s->width)
2434 src_y = clip(src_y, -16, s->height);
2435 if (src_y == s->height)
2438 linesize = s->linesize;
2439 uvlinesize = s->uvlinesize;
2441 ptr = ref_picture[0] + (src_y * linesize) + src_x;
2443 if(s->flags&CODEC_FLAG_EMU_EDGE){
2444 if( (unsigned)src_x >= s->h_edge_pos - 17
2445 || (unsigned)src_y >= s->v_edge_pos - 17){
2446 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2447 ptr= s->edge_emu_buffer;
2451 if((motion_x|motion_y)&7){
2452 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2453 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2457 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2458 if (s->no_rounding){
2459 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2461 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2465 if(s->flags&CODEC_FLAG_GRAY) return;
2467 motion_x= s->sprite_offset[1][0];
2468 motion_y= s->sprite_offset[1][1];
2469 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2470 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2471 motion_x<<=(3-s->sprite_warping_accuracy);
2472 motion_y<<=(3-s->sprite_warping_accuracy);
2473 src_x = clip(src_x, -8, s->width>>1);
2474 if (src_x == s->width>>1)
2476 src_y = clip(src_y, -8, s->height>>1);
2477 if (src_y == s->height>>1)
2480 offset = (src_y * uvlinesize) + src_x;
2481 ptr = ref_picture[1] + offset;
2482 if(s->flags&CODEC_FLAG_EMU_EDGE){
2483 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2484 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
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;
2490 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2492 ptr = ref_picture[2] + offset;
2494 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);
2495 ptr= s->edge_emu_buffer;
2497 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2502 static inline void gmc_motion(MpegEncContext *s,
2503 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2504 uint8_t **ref_picture)
2507 int linesize, uvlinesize;
2508 const int a= s->sprite_warping_accuracy;
2511 linesize = s->linesize;
2512 uvlinesize = s->uvlinesize;
2514 ptr = ref_picture[0];
2516 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2517 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2519 s->dsp.gmc(dest_y, ptr, linesize, 16,
2522 s->sprite_delta[0][0], s->sprite_delta[0][1],
2523 s->sprite_delta[1][0], s->sprite_delta[1][1],
2524 a+1, (1<<(2*a+1)) - s->no_rounding,
2525 s->h_edge_pos, s->v_edge_pos);
2526 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2527 ox + s->sprite_delta[0][0]*8,
2528 oy + s->sprite_delta[1][0]*8,
2529 s->sprite_delta[0][0], s->sprite_delta[0][1],
2530 s->sprite_delta[1][0], s->sprite_delta[1][1],
2531 a+1, (1<<(2*a+1)) - s->no_rounding,
2532 s->h_edge_pos, s->v_edge_pos);
2534 if(s->flags&CODEC_FLAG_GRAY) return;
2536 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2537 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2539 ptr = ref_picture[1];
2540 s->dsp.gmc(dest_cb, 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);
2548 ptr = ref_picture[2];
2549 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2552 s->sprite_delta[0][0], s->sprite_delta[0][1],
2553 s->sprite_delta[1][0], s->sprite_delta[1][1],
2554 a+1, (1<<(2*a+1)) - s->no_rounding,
2555 s->h_edge_pos>>1, s->v_edge_pos>>1);
2559 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2560 * @param buf destination buffer
2561 * @param src source buffer
2562 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2563 * @param block_w width of block
2564 * @param block_h height of block
2565 * @param src_x x coordinate of the top left sample of the block in the source buffer
2566 * @param src_y y coordinate of the top left sample of the block in the source buffer
2567 * @param w width of the source buffer
2568 * @param h height of the source buffer
2570 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2571 int src_x, int src_y, int w, int h){
2573 int start_y, start_x, end_y, end_x;
2576 src+= (h-1-src_y)*linesize;
2578 }else if(src_y<=-block_h){
2579 src+= (1-block_h-src_y)*linesize;
2585 }else if(src_x<=-block_w){
2586 src+= (1-block_w-src_x);
2590 start_y= FFMAX(0, -src_y);
2591 start_x= FFMAX(0, -src_x);
2592 end_y= FFMIN(block_h, h-src_y);
2593 end_x= FFMIN(block_w, w-src_x);
2595 // copy existing part
2596 for(y=start_y; y<end_y; y++){
2597 for(x=start_x; x<end_x; x++){
2598 buf[x + y*linesize]= src[x + y*linesize];
2603 for(y=0; y<start_y; y++){
2604 for(x=start_x; x<end_x; x++){
2605 buf[x + y*linesize]= buf[x + start_y*linesize];
2610 for(y=end_y; y<block_h; y++){
2611 for(x=start_x; x<end_x; x++){
2612 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2616 for(y=0; y<block_h; y++){
2618 for(x=0; x<start_x; x++){
2619 buf[x + y*linesize]= buf[start_x + y*linesize];
2623 for(x=end_x; x<block_w; x++){
2624 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2629 static inline int hpel_motion(MpegEncContext *s,
2630 uint8_t *dest, uint8_t *src,
2631 int field_based, int field_select,
2632 int src_x, int src_y,
2633 int width, int height, int stride,
2634 int h_edge_pos, int v_edge_pos,
2635 int w, int h, op_pixels_func *pix_op,
2636 int motion_x, int motion_y)
2641 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2642 src_x += motion_x >> 1;
2643 src_y += motion_y >> 1;
2645 /* WARNING: do no forget half pels */
2646 src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2649 src_y = clip(src_y, -16, height);
2650 if (src_y == height)
2652 src += src_y * stride + src_x;
2654 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2655 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2656 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2657 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2658 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2659 src= s->edge_emu_buffer;
2665 pix_op[dxy](dest, src, stride, h);
2669 static inline int hpel_motion_lowres(MpegEncContext *s,
2670 uint8_t *dest, uint8_t *src,
2671 int field_based, int field_select,
2672 int src_x, int src_y,
2673 int width, int height, int stride,
2674 int h_edge_pos, int v_edge_pos,
2675 int w, int h, h264_chroma_mc_func *pix_op,
2676 int motion_x, int motion_y)
2678 const int lowres= s->avctx->lowres;
2679 const int s_mask= (2<<lowres)-1;
2683 if(s->quarter_sample){
2688 sx= motion_x & s_mask;
2689 sy= motion_y & s_mask;
2690 src_x += motion_x >> (lowres+1);
2691 src_y += motion_y >> (lowres+1);
2693 src += src_y * stride + src_x;
2695 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
2696 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2697 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2698 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2699 src= s->edge_emu_buffer;
2707 pix_op[lowres](dest, src, stride, h, sx, sy);
2711 /* apply one mpeg motion vector to the three components */
2712 static always_inline void mpeg_motion(MpegEncContext *s,
2713 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2714 int field_based, int bottom_field, int field_select,
2715 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2716 int motion_x, int motion_y, int h)
2718 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2719 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2722 if(s->quarter_sample)
2729 v_edge_pos = s->v_edge_pos >> field_based;
2730 linesize = s->current_picture.linesize[0] << field_based;
2731 uvlinesize = s->current_picture.linesize[1] << field_based;
2733 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2734 src_x = s->mb_x* 16 + (motion_x >> 1);
2735 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2737 if (s->out_format == FMT_H263) {
2738 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2739 mx = (motion_x>>1)|(motion_x&1);
2741 uvdxy = ((my & 1) << 1) | (mx & 1);
2742 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2743 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2745 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2749 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2753 uvsrc_x = s->mb_x*8 + mx;
2754 uvsrc_y = s->mb_y*8 + my;
2756 if(s->chroma_y_shift){
2759 uvdxy = ((my & 1) << 1) | (mx & 1);
2760 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2761 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2763 if(s->chroma_x_shift){
2766 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2767 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2778 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2779 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2780 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2782 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2783 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2784 if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2785 s->codec_id == CODEC_ID_MPEG1VIDEO){
2786 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2789 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2790 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2791 ptr_y = s->edge_emu_buffer;
2792 if(!(s->flags&CODEC_FLAG_GRAY)){
2793 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2794 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2795 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2796 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2797 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2803 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2804 dest_y += s->linesize;
2805 dest_cb+= s->uvlinesize;
2806 dest_cr+= s->uvlinesize;
2810 ptr_y += s->linesize;
2811 ptr_cb+= s->uvlinesize;
2812 ptr_cr+= s->uvlinesize;
2815 pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2817 if(!(s->flags&CODEC_FLAG_GRAY)){
2818 pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2819 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2821 if(s->out_format == FMT_H261){
2822 ff_h261_loop_filter(s);
2826 /* apply one mpeg motion vector to the three components */
2827 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2828 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2829 int field_based, int bottom_field, int field_select,
2830 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2831 int motion_x, int motion_y, int h)
2833 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2834 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2835 const int lowres= s->avctx->lowres;
2836 const int block_s= 8>>lowres;
2837 const int s_mask= (2<<lowres)-1;
2838 const int h_edge_pos = s->h_edge_pos >> lowres;
2839 const int v_edge_pos = s->v_edge_pos >> lowres;
2840 linesize = s->current_picture.linesize[0] << field_based;
2841 uvlinesize = s->current_picture.linesize[1] << field_based;
2843 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2849 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2852 sx= motion_x & s_mask;
2853 sy= motion_y & s_mask;
2854 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
2855 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2857 if (s->out_format == FMT_H263) {
2858 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2859 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2862 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2865 uvsx = (2*mx) & s_mask;
2866 uvsy = (2*my) & s_mask;
2867 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
2868 uvsrc_y = s->mb_y*block_s + (my >> lowres);
2874 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
2875 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2878 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2879 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2880 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2882 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
2883 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2884 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2885 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2886 ptr_y = s->edge_emu_buffer;
2887 if(!(s->flags&CODEC_FLAG_GRAY)){
2888 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2889 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2890 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2891 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2892 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2898 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2899 dest_y += s->linesize;
2900 dest_cb+= s->uvlinesize;
2901 dest_cr+= s->uvlinesize;
2905 ptr_y += s->linesize;
2906 ptr_cb+= s->uvlinesize;
2907 ptr_cr+= s->uvlinesize;
2912 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2914 if(!(s->flags&CODEC_FLAG_GRAY)){
2915 uvsx <<= 2 - lowres;
2916 uvsy <<= 2 - lowres;
2917 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2918 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2920 //FIXME h261 lowres loop filter
2923 //FIXME move to dsputil, avg variant, 16x16 version
2924 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2926 uint8_t * const top = src[1];
2927 uint8_t * const left = src[2];
2928 uint8_t * const mid = src[0];
2929 uint8_t * const right = src[3];
2930 uint8_t * const bottom= src[4];
2931 #define OBMC_FILTER(x, t, l, m, r, b)\
2932 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2933 #define OBMC_FILTER4(x, t, l, m, r, b)\
2934 OBMC_FILTER(x , t, l, m, r, b);\
2935 OBMC_FILTER(x+1 , t, l, m, r, b);\
2936 OBMC_FILTER(x +stride, t, l, m, r, b);\
2937 OBMC_FILTER(x+1+stride, t, l, m, r, b);
2940 OBMC_FILTER (x , 2, 2, 4, 0, 0);
2941 OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2942 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2943 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2944 OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2945 OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2947 OBMC_FILTER (x , 1, 2, 5, 0, 0);
2948 OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2949 OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2950 OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2952 OBMC_FILTER4(x , 1, 2, 5, 0, 0);
2953 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2954 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2955 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2957 OBMC_FILTER4(x , 0, 2, 5, 0, 1);
2958 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2959 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2960 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2962 OBMC_FILTER (x , 0, 2, 5, 0, 1);
2963 OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2964 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2965 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2966 OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2967 OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2969 OBMC_FILTER (x , 0, 2, 4, 0, 2);
2970 OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2971 OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2972 OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2975 /* obmc for 1 8x8 luma block */
2976 static inline void obmc_motion(MpegEncContext *s,
2977 uint8_t *dest, uint8_t *src,
2978 int src_x, int src_y,
2979 op_pixels_func *pix_op,
2980 int16_t mv[5][2]/* mid top left right bottom*/)
2986 assert(s->quarter_sample==0);
2989 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2992 ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2993 hpel_motion(s, ptr[i], src, 0, 0,
2995 s->width, s->height, s->linesize,
2996 s->h_edge_pos, s->v_edge_pos,
2998 mv[i][0], mv[i][1]);
3002 put_obmc(dest, ptr, s->linesize);
3005 static inline void qpel_motion(MpegEncContext *s,
3006 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3007 int field_based, int bottom_field, int field_select,
3008 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3009 qpel_mc_func (*qpix_op)[16],
3010 int motion_x, int motion_y, int h)
3012 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3013 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3015 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3016 src_x = s->mb_x * 16 + (motion_x >> 2);
3017 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3019 v_edge_pos = s->v_edge_pos >> field_based;
3020 linesize = s->linesize << field_based;
3021 uvlinesize = s->uvlinesize << field_based;
3026 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3027 static const int rtab[8]= {0,0,1,1,0,0,0,1};
3028 mx= (motion_x>>1) + rtab[motion_x&7];
3029 my= (motion_y>>1) + rtab[motion_y&7];
3030 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3031 mx= (motion_x>>1)|(motion_x&1);
3032 my= (motion_y>>1)|(motion_y&1);
3040 uvdxy= (mx&1) | ((my&1)<<1);
3044 uvsrc_x = s->mb_x * 8 + mx;
3045 uvsrc_y = s->mb_y * (8 >> field_based) + my;
3047 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3048 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3049 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3051 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3052 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
3053 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3054 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3055 ptr_y= s->edge_emu_buffer;
3056 if(!(s->flags&CODEC_FLAG_GRAY)){
3057 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3058 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3059 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3060 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3061 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3068 qpix_op[0][dxy](dest_y, ptr_y, linesize);
3071 dest_y += s->linesize;
3072 dest_cb+= s->uvlinesize;
3073 dest_cr+= s->uvlinesize;
3077 ptr_y += s->linesize;
3078 ptr_cb += s->uvlinesize;
3079 ptr_cr += s->uvlinesize;
3081 //damn interlaced mode
3082 //FIXME boundary mirroring is not exactly correct here
3083 qpix_op[1][dxy](dest_y , ptr_y , linesize);
3084 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3086 if(!(s->flags&CODEC_FLAG_GRAY)){
3087 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3088 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3092 inline int ff_h263_round_chroma(int x){
3094 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3097 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3102 * h263 chorma 4mv motion compensation.
3104 static inline void chroma_4mv_motion(MpegEncContext *s,
3105 uint8_t *dest_cb, uint8_t *dest_cr,
3106 uint8_t **ref_picture,
3107 op_pixels_func *pix_op,
3109 int dxy, emu=0, src_x, src_y, offset;
3112 /* In case of 8X8, we construct a single chroma motion vector
3113 with a special rounding */
3114 mx= ff_h263_round_chroma(mx);
3115 my= ff_h263_round_chroma(my);
3117 dxy = ((my & 1) << 1) | (mx & 1);
3121 src_x = s->mb_x * 8 + mx;
3122 src_y = s->mb_y * 8 + my;
3123 src_x = clip(src_x, -8, s->width/2);
3124 if (src_x == s->width/2)
3126 src_y = clip(src_y, -8, s->height/2);
3127 if (src_y == s->height/2)
3130 offset = (src_y * (s->uvlinesize)) + src_x;
3131 ptr = ref_picture[1] + offset;
3132 if(s->flags&CODEC_FLAG_EMU_EDGE){
3133 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3134 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
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;
3140 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3142 ptr = ref_picture[2] + offset;
3144 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);
3145 ptr= s->edge_emu_buffer;
3147 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3150 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3151 uint8_t *dest_cb, uint8_t *dest_cr,
3152 uint8_t **ref_picture,
3153 h264_chroma_mc_func *pix_op,
3155 const int lowres= s->avctx->lowres;
3156 const int block_s= 8>>lowres;
3157 const int s_mask= (2<<lowres)-1;
3158 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3159 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3160 int emu=0, src_x, src_y, offset, sx, sy;
3163 if(s->quarter_sample){
3168 /* In case of 8X8, we construct a single chroma motion vector
3169 with a special rounding */
3170 mx= ff_h263_round_chroma(mx);
3171 my= ff_h263_round_chroma(my);
3175 src_x = s->mb_x*block_s + (mx >> (lowres+1));
3176 src_y = s->mb_y*block_s + (my >> (lowres+1));
3178 offset = src_y * s->uvlinesize + src_x;
3179 ptr = ref_picture[1] + offset;
3180 if(s->flags&CODEC_FLAG_EMU_EDGE){
3181 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3182 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3183 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3184 ptr= s->edge_emu_buffer;
3190 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3192 ptr = ref_picture[2] + offset;
3194 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3195 ptr= s->edge_emu_buffer;
3197 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3201 * motion compesation of a single macroblock
3203 * @param dest_y luma destination pointer
3204 * @param dest_cb chroma cb/u destination pointer
3205 * @param dest_cr chroma cr/v destination pointer
3206 * @param dir direction (0->forward, 1->backward)
3207 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3208 * @param pic_op halfpel motion compensation function (average or put normally)
3209 * @param pic_op qpel motion compensation function (average or put normally)
3210 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3212 static inline void MPV_motion(MpegEncContext *s,
3213 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3214 int dir, uint8_t **ref_picture,
3215 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3217 int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3219 uint8_t *ptr, *dest;
3224 if(s->obmc && s->pict_type != B_TYPE){
3225 int16_t mv_cache[4][4][2];
3226 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3227 const int mot_stride= s->b8_stride;
3228 const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3230 assert(!s->mb_skiped);
3232 memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy ], sizeof(int16_t)*4);
3233 memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3234 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3236 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3237 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3239 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3242 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3243 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3244 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3246 *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3247 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3250 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3251 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3252 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3254 *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3255 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3261 const int x= (i&1)+1;
3262 const int y= (i>>1)+1;
3264 {mv_cache[y][x ][0], mv_cache[y][x ][1]},
3265 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3266 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3267 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3268 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3270 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3272 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3279 if(!(s->flags&CODEC_FLAG_GRAY))
3280 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3285 switch(s->mv_type) {
3288 if(s->real_sprite_warping_points==1){
3289 gmc1_motion(s, dest_y, dest_cb, dest_cr,
3292 gmc_motion(s, dest_y, dest_cb, dest_cr,
3295 }else if(s->quarter_sample){
3296 qpel_motion(s, dest_y, dest_cb, dest_cr,
3298 ref_picture, pix_op, qpix_op,
3299 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3301 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3302 ref_picture, pix_op,
3303 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3306 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3308 ref_picture, pix_op,
3309 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3315 if(s->quarter_sample){
3317 motion_x = s->mv[dir][i][0];
3318 motion_y = s->mv[dir][i][1];
3320 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3321 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3322 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3324 /* WARNING: do no forget half pels */
3325 src_x = clip(src_x, -16, s->width);
3326 if (src_x == s->width)
3328 src_y = clip(src_y, -16, s->height);
3329 if (src_y == s->height)
3332 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3333 if(s->flags&CODEC_FLAG_EMU_EDGE){
3334 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3335 || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3336 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);
3337 ptr= s->edge_emu_buffer;
3340 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3341 qpix_op[1][dxy](dest, ptr, s->linesize);
3343 mx += s->mv[dir][i][0]/2;
3344 my += s->mv[dir][i][1]/2;
3348 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3349 ref_picture[0], 0, 0,
3350 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3351 s->width, s->height, s->linesize,
3352 s->h_edge_pos, s->v_edge_pos,
3354 s->mv[dir][i][0], s->mv[dir][i][1]);
3356 mx += s->mv[dir][i][0];
3357 my += s->mv[dir][i][1];
3361 if(!(s->flags&CODEC_FLAG_GRAY))
3362 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3365 if (s->picture_structure == PICT_FRAME) {
3366 if(s->quarter_sample){
3368 qpel_motion(s, dest_y, dest_cb, dest_cr,
3369 1, i, s->field_select[dir][i],
3370 ref_picture, pix_op, qpix_op,
3371 s->mv[dir][i][0], s->mv[dir][i][1], 8);
3375 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3376 1, 0, s->field_select[dir][0],
3377 ref_picture, pix_op,
3378 s->mv[dir][0][0], s->mv[dir][0][1], 8);
3380 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3381 1, 1, s->field_select[dir][1],
3382 ref_picture, pix_op,
3383 s->mv[dir][1][0], s->mv[dir][1][1], 8);
3386 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3387 ref_picture= s->current_picture_ptr->data;
3390 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3391 0, 0, s->field_select[dir][0],
3392 ref_picture, pix_op,
3393 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3398 uint8_t ** ref2picture;
3400 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3401 ref2picture= ref_picture;
3403 ref2picture= s->current_picture_ptr->data;
3406 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3407 0, 0, s->field_select[dir][i],
3408 ref2picture, pix_op,
3409 s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3411 dest_y += 16*s->linesize;
3412 dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3413 dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3417 if(s->picture_structure == PICT_FRAME){
3421 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3423 ref_picture, pix_op,
3424 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3426 pix_op = s->dsp.avg_pixels_tab;
3430 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3431 0, 0, s->picture_structure != i+1,
3432 ref_picture, pix_op,
3433 s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3435 // after put we make avg of the same block
3436 pix_op=s->dsp.avg_pixels_tab;
3438 //opposite parity is always in the same frame if this is second field
3439 if(!s->first_field){
3440 ref_picture = s->current_picture_ptr->data;
3450 * motion compesation of a single macroblock
3452 * @param dest_y luma destination pointer
3453 * @param dest_cb chroma cb/u destination pointer
3454 * @param dest_cr chroma cr/v destination pointer
3455 * @param dir direction (0->forward, 1->backward)
3456 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3457 * @param pic_op halfpel motion compensation function (average or put normally)
3458 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3460 static inline void MPV_motion_lowres(MpegEncContext *s,
3461 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3462 int dir, uint8_t **ref_picture,
3463 h264_chroma_mc_func *pix_op)
3467 const int lowres= s->avctx->lowres;
3468 const int block_s= 8>>lowres;
3473 switch(s->mv_type) {
3475 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3477 ref_picture, pix_op,
3478 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3484 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3485 ref_picture[0], 0, 0,
3486 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3487 s->width, s->height, s->linesize,
3488 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3489 block_s, block_s, pix_op,
3490 s->mv[dir][i][0], s->mv[dir][i][1]);
3492 mx += s->mv[dir][i][0];
3493 my += s->mv[dir][i][1];
3496 if(!(s->flags&CODEC_FLAG_GRAY))
3497 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3500 if (s->picture_structure == PICT_FRAME) {
3502 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3503 1, 0, s->field_select[dir][0],
3504 ref_picture, pix_op,
3505 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3507 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3508 1, 1, s->field_select[dir][1],
3509 ref_picture, pix_op,
3510 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3512 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3513 ref_picture= s->current_picture_ptr->data;
3516 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3517 0, 0, s->field_select[dir][0],
3518 ref_picture, pix_op,
3519 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3524 uint8_t ** ref2picture;
3526 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3527 ref2picture= ref_picture;
3529 ref2picture= s->current_picture_ptr->data;
3532 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3533 0, 0, s->field_select[dir][i],
3534 ref2picture, pix_op,
3535 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3537 dest_y += 2*block_s*s->linesize;
3538 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3539 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3543 if(s->picture_structure == PICT_FRAME){
3547 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3549 ref_picture, pix_op,
3550 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3552 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3556 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3557 0, 0, s->picture_structure != i+1,
3558 ref_picture, pix_op,
3559 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3561 // after put we make avg of the same block
3562 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3564 //opposite parity is always in the same frame if this is second field
3565 if(!s->first_field){
3566 ref_picture = s->current_picture_ptr->data;
3575 /* put block[] to dest[] */
3576 static inline void put_dct(MpegEncContext *s,
3577 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3579 s->dct_unquantize_intra(s, block, i, qscale);
3580 s->dsp.idct_put (dest, line_size, block);
3583 /* add block[] to dest[] */
3584 static inline void add_dct(MpegEncContext *s,
3585 DCTELEM *block, int i, uint8_t *dest, int line_size)
3587 if (s->block_last_index[i] >= 0) {
3588 s->dsp.idct_add (dest, line_size, block);
3592 static inline void add_dequant_dct(MpegEncContext *s,
3593 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3595 if (s->block_last_index[i] >= 0) {
3596 s->dct_unquantize_inter(s, block, i, qscale);
3598 s->dsp.idct_add (dest, line_size, block);
3603 * cleans dc, ac, coded_block for the current non intra MB
3605 void ff_clean_intra_table_entries(MpegEncContext *s)
3607 int wrap = s->b8_stride;
3608 int xy = s->block_index[0];
3611 s->dc_val[0][xy + 1 ] =
3612 s->dc_val[0][xy + wrap] =
3613 s->dc_val[0][xy + 1 + wrap] = 1024;
3615 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
3616 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3617 if (s->msmpeg4_version>=3) {
3618 s->coded_block[xy ] =
3619 s->coded_block[xy + 1 ] =
3620 s->coded_block[xy + wrap] =
3621 s->coded_block[xy + 1 + wrap] = 0;
3624 wrap = s->mb_stride;
3625 xy = s->mb_x + s->mb_y * wrap;
3627 s->dc_val[2][xy] = 1024;
3629 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3630 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3632 s->mbintra_table[xy]= 0;
3635 /* generic function called after a macroblock has been parsed by the
3636 decoder or after it has been encoded by the encoder.
3638 Important variables used:
3639 s->mb_intra : true if intra macroblock
3640 s->mv_dir : motion vector direction
3641 s->mv_type : motion vector type
3642 s->mv : motion vector
3643 s->interlaced_dct : true if interlaced dct used (mpeg2)
3645 static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3648 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3650 if(s->avctx->xvmc_acceleration){
3651 XVMC_decode_mb(s);//xvmc uses pblocks
3659 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3660 /* save DCT coefficients */
3662 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3665 *dct++ = block[i][s->dsp.idct_permutation[j]];
3668 s->current_picture.qscale_table[mb_xy]= s->qscale;
3670 /* update DC predictors for P macroblocks */
3672 if (s->h263_pred || s->h263_aic) {
3673 if(s->mbintra_table[mb_xy])
3674 ff_clean_intra_table_entries(s);
3678 s->last_dc[2] = 128 << s->intra_dc_precision;
3681 else if (s->h263_pred || s->h263_aic)
3682 s->mbintra_table[mb_xy]=1;
3684 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3685 uint8_t *dest_y, *dest_cb, *dest_cr;
3686 int dct_linesize, dct_offset;
3687 op_pixels_func (*op_pix)[4];
3688 qpel_mc_func (*op_qpix)[16];
3689 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3690 const int uvlinesize= s->current_picture.linesize[1];
3691 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3692 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3694 /* avoid copy if macroblock skipped in last frame too */
3695 /* skip only during decoding as we might trash the buffers during encoding a bit */
3697 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3698 const int age= s->current_picture.age;
3704 assert(s->pict_type!=I_TYPE);
3706 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3707 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3709 /* if previous was skipped too, then nothing to do ! */
3710 if (*mbskip_ptr >= age && s->current_picture.reference){
3713 } else if(!s->current_picture.reference){
3714 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3715 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3717 *mbskip_ptr = 0; /* not skipped */
3721 dct_linesize = linesize << s->interlaced_dct;
3722 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3726 dest_cb= s->dest[1];
3727 dest_cr= s->dest[2];
3729 dest_y = s->b_scratchpad;
3730 dest_cb= s->b_scratchpad+16*linesize;
3731 dest_cr= s->b_scratchpad+32*linesize;
3735 /* motion handling */
3736 /* decoding or more than one mb_type (MC was allready done otherwise) */
3739 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3741 if (s->mv_dir & MV_DIR_FORWARD) {
3742 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3743 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3745 if (s->mv_dir & MV_DIR_BACKWARD) {
3746 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3749 if ((!s->no_rounding) || s->pict_type==B_TYPE){
3750 op_pix = s->dsp.put_pixels_tab;
3751 op_qpix= s->dsp.put_qpel_pixels_tab;
3753 op_pix = s->dsp.put_no_rnd_pixels_tab;
3754 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3756 if (s->mv_dir & MV_DIR_FORWARD) {
3757 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3758 op_pix = s->dsp.avg_pixels_tab;
3759 op_qpix= s->dsp.avg_qpel_pixels_tab;
3761 if (s->mv_dir & MV_DIR_BACKWARD) {
3762 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3767 /* skip dequant / idct if we are really late ;) */
3768 if(s->hurry_up>1) return;
3770 /* add dct residue */
3771 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3772 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3773 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
3774 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
3775 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
3776 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3778 if(!(s->flags&CODEC_FLAG_GRAY)){
3779 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3780 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3782 } else if(s->codec_id != CODEC_ID_WMV2){
3783 add_dct(s, block[0], 0, dest_y , dct_linesize);
3784 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
3785 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
3786 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3788 if(!(s->flags&CODEC_FLAG_GRAY)){
3789 if(s->chroma_y_shift){//Chroma420
3790 add_dct(s, block[4], 4, dest_cb, uvlinesize);
3791 add_dct(s, block[5], 5, dest_cr, uvlinesize);
3794 dct_linesize = uvlinesize << s->interlaced_dct;
3795 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3797 add_dct(s, block[4], 4, dest_cb, dct_linesize);
3798 add_dct(s, block[5], 5, dest_cr, dct_linesize);
3799 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3800 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3801 if(!s->chroma_x_shift){//Chroma444
3802 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3803 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3804 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3805 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3811 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3814 /* dct only in intra block */
3815 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3816 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
3817 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
3818 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
3819 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3821 if(!(s->flags&CODEC_FLAG_GRAY)){
3822 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3823 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3826 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
3827 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
3828 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
3829 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3831 if(!(s->flags&CODEC_FLAG_GRAY)){
3832 if(s->chroma_y_shift){
3833 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3834 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3837 dct_linesize = uvlinesize << s->interlaced_dct;
3838 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3840 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
3841 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
3842 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3843 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3844 if(!s->chroma_x_shift){//Chroma444
3845 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
3846 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
3847 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3848 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3855 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
3856 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3857 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3862 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
3863 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
3864 else MPV_decode_mb_internal(s, block, 0);
3867 #ifdef CONFIG_ENCODERS
3869 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3871 static const char tab[64]=
3883 DCTELEM *block= s->block[n];
3884 const int last_index= s->block_last_index[n];
3889 threshold= -threshold;
3893 /* are all which we could set to zero are allready zero? */
3894 if(last_index<=skip_dc - 1) return;
3896 for(i=0; i<=last_index; i++){
3897 const int j = s->intra_scantable.permutated[i];
3898 const int level = ABS(block[j]);
3900 if(skip_dc && i==0) continue;
3909 if(score >= threshold) return;
3910 for(i=skip_dc; i<=last_index; i++){
3911 const int j = s->intra_scantable.permutated[i];
3914 if(block[0]) s->block_last_index[n]= 0;
3915 else s->block_last_index[n]= -1;
3918 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3921 const int maxlevel= s->max_qcoeff;
3922 const int minlevel= s->min_qcoeff;
3926 i=1; //skip clipping of intra dc
3930 for(;i<=last_index; i++){
3931 const int j= s->intra_scantable.permutated[i];
3932 int level = block[j];
3934 if (level>maxlevel){
3937 }else if(level<minlevel){
3945 if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3946 av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3949 #endif //CONFIG_ENCODERS
3953 * @param h is the normal height, this will be reduced automatically if needed for the last row
3955 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3956 if (s->avctx->draw_horiz_band) {
3960 if(s->picture_structure != PICT_FRAME){
3963 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3966 h= FFMIN(h, s->avctx->height - y);
3968 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
3969 src= (AVFrame*)s->current_picture_ptr;
3970 else if(s->last_picture_ptr)
3971 src= (AVFrame*)s->last_picture_ptr;
3975 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3981 offset[0]= y * s->linesize;;
3983 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
3989 s->avctx->draw_horiz_band(s->avctx, src, offset,
3990 y, s->picture_structure, h);
3994 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3995 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3996 const int uvlinesize= s->current_picture.linesize[1];
3997 const int mb_size= 4 - s->avctx->lowres;
3999 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
4000 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
4001 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
4002 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
4003 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
4004 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;
4005 //block_index is not used by mpeg2, so it is not affected by chroma_format
4007 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4008 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4009 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4011 if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
4013 s->dest[0] += s->mb_y * linesize << mb_size;
4014 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4015 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4019 #ifdef CONFIG_ENCODERS
4021 static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){