2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard.
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
25 * The simplest mpeg encoder (well, it was the simplest!).
30 #include "mpegvideo.h"
35 #include "fastmemcpy.h"
41 #ifdef CONFIG_ENCODERS
42 static void encode_picture(MpegEncContext *s, int picture_number);
43 #endif //CONFIG_ENCODERS
44 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
45 DCTELEM *block, int n, int qscale);
46 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
47 DCTELEM *block, int n, int qscale);
48 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
49 DCTELEM *block, int n, int qscale);
50 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
51 DCTELEM *block, int n, int qscale);
52 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
53 DCTELEM *block, int n, int qscale);
54 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
55 DCTELEM *block, int n, int qscale);
56 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
57 #ifdef CONFIG_ENCODERS
58 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
59 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
60 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
61 static int sse_mb(MpegEncContext *s);
62 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
63 #endif //CONFIG_ENCODERS
66 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
67 extern void XVMC_field_end(MpegEncContext *s);
68 extern void XVMC_decode_mb(MpegEncContext *s);
71 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
74 /* enable all paranoid tests for rounding, overflows, etc... */
80 /* for jpeg fast DCT */
83 static const uint16_t aanscales[64] = {
84 /* precomputed values scaled up by 14 bits */
85 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
86 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
87 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
88 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
89 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
90 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
91 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
92 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
95 static const uint8_t h263_chroma_roundtab[16] = {
96 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
97 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
100 static const uint8_t ff_default_chroma_qscale_table[32]={
101 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
102 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
105 #ifdef CONFIG_ENCODERS
106 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
107 static uint8_t default_fcode_tab[MAX_MV*2+1];
109 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
111 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
112 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
117 for(qscale=qmin; qscale<=qmax; qscale++){
119 if (dsp->fdct == ff_jpeg_fdct_islow
120 #ifdef FAAN_POSTSCALE
121 || dsp->fdct == ff_faandct
125 const int j= dsp->idct_permutation[i];
126 /* 16 <= qscale * quant_matrix[i] <= 7905 */
127 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
128 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
129 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
131 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
132 (qscale * quant_matrix[j]));
134 } else if (dsp->fdct == fdct_ifast
135 #ifndef FAAN_POSTSCALE
136 || dsp->fdct == ff_faandct
140 const int j= dsp->idct_permutation[i];
141 /* 16 <= qscale * quant_matrix[i] <= 7905 */
142 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
143 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
144 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
146 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
147 (aanscales[i] * qscale * quant_matrix[j]));
151 const int j= dsp->idct_permutation[i];
152 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
153 So 16 <= qscale * quant_matrix[i] <= 7905
154 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
155 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
157 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
158 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
159 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
161 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
162 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
166 for(i=intra; i<64; i++){
168 if (dsp->fdct == fdct_ifast
169 #ifndef FAAN_POSTSCALE
170 || dsp->fdct == ff_faandct
173 max= (8191LL*aanscales[i]) >> 14;
175 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
181 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger then %d, overflows possible\n", QMAT_SHIFT - shift);
185 static inline void update_qscale(MpegEncContext *s){
186 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
187 s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
189 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
191 #endif //CONFIG_ENCODERS
193 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
197 st->scantable= src_scantable;
201 j = src_scantable[i];
202 st->permutated[i] = permutation[j];
211 j = st->permutated[i];
213 st->raster_end[i]= end;
217 #ifdef CONFIG_ENCODERS
218 void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
224 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
229 #endif //CONFIG_ENCODERS
231 /* init common dct for both encoder and decoder */
232 int DCT_common_init(MpegEncContext *s)
234 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
235 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
236 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
237 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
238 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
239 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
241 #ifdef CONFIG_ENCODERS
242 s->dct_quantize= dct_quantize_c;
243 s->denoise_dct= denoise_dct_c;
247 MPV_common_init_mmx(s);
250 MPV_common_init_axp(s);
253 MPV_common_init_mlib(s);
256 MPV_common_init_mmi(s);
259 MPV_common_init_armv4l(s);
262 MPV_common_init_ppc(s);
265 #ifdef CONFIG_ENCODERS
266 s->fast_dct_quantize= s->dct_quantize;
268 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
269 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
272 #endif //CONFIG_ENCODERS
274 /* load & permutate scantables
275 note: only wmv uses differnt ones
277 if(s->alternate_scan){
278 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
279 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
281 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
282 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
284 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
285 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
290 static void copy_picture(Picture *dst, Picture *src){
292 dst->type= FF_BUFFER_TYPE_COPY;
295 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
298 dst->pict_type = src->pict_type;
299 dst->quality = src->quality;
300 dst->coded_picture_number = src->coded_picture_number;
301 dst->display_picture_number = src->display_picture_number;
302 // dst->reference = src->reference;
304 dst->interlaced_frame = src->interlaced_frame;
305 dst->top_field_first = src->top_field_first;
307 if(s->avctx->me_threshold){
308 if(!src->motion_val[0])
309 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
311 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
312 if(!src->ref_index[0])
313 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
314 if(src->motion_subsample_log2 != dst->motion_subsample_log2)
315 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesnt match! (%d!=%d)\n",
316 src->motion_subsample_log2, dst->motion_subsample_log2);
318 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
321 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
322 int height= ((16*s->mb_height)>>src->motion_subsample_log2);
324 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
325 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
327 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
328 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
335 * allocates a Picture
336 * The pixels are allocated/set by calling get_buffer() if shared=0
338 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
339 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
340 const int mb_array_size= s->mb_stride*s->mb_height;
341 const int b8_array_size= s->b8_stride*s->mb_height*2;
342 const int b4_array_size= s->b4_stride*s->mb_height*4;
346 assert(pic->data[0]);
347 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
348 pic->type= FF_BUFFER_TYPE_SHARED;
352 assert(!pic->data[0]);
354 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
356 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
357 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
361 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
362 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
366 if(pic->linesize[1] != pic->linesize[2]){
367 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride missmatch)\n");
371 s->linesize = pic->linesize[0];
372 s->uvlinesize= pic->linesize[1];
375 if(pic->qscale_table==NULL){
377 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
378 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
379 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
382 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
383 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
384 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
385 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
386 if(s->out_format == FMT_H264){
388 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+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= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
1060 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1061 avctx->frame_rate /= i;
1062 avctx->frame_rate_base /= i;
1066 if(s->codec_id==CODEC_ID_MJPEG){
1067 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1068 s->inter_quant_bias= 0;
1069 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1070 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1071 s->inter_quant_bias= 0;
1073 s->intra_quant_bias=0;
1074 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1077 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1078 s->intra_quant_bias= avctx->intra_quant_bias;
1079 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1080 s->inter_quant_bias= avctx->inter_quant_bias;
1082 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1084 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1085 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1087 switch(avctx->codec->id) {
1088 case CODEC_ID_MPEG1VIDEO:
1089 s->out_format = FMT_MPEG1;
1090 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1091 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1093 case CODEC_ID_MPEG2VIDEO:
1094 s->out_format = FMT_MPEG1;
1095 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1096 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1099 case CODEC_ID_LJPEG:
1100 case CODEC_ID_MJPEG:
1101 s->out_format = FMT_MJPEG;
1102 s->intra_only = 1; /* force intra only for jpeg */
1103 s->mjpeg_write_tables = 1; /* write all tables */
1104 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1105 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1106 s->mjpeg_vsample[1] = 1;
1107 s->mjpeg_vsample[2] = 1;
1108 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1109 s->mjpeg_hsample[1] = 1;
1110 s->mjpeg_hsample[2] = 1;
1111 if (mjpeg_init(s) < 0)
1117 s->out_format = FMT_H261;
1122 if (h263_get_picture_format(s->width, s->height) == 7) {
1123 av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
1126 s->out_format = FMT_H263;
1127 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1131 case CODEC_ID_H263P:
1132 s->out_format = FMT_H263;
1135 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1136 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1137 s->modified_quant= s->h263_aic;
1138 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1139 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1140 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1141 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1142 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1145 /* These are just to be sure */
1150 s->out_format = FMT_H263;
1151 s->h263_flv = 2; /* format = 1; 11-bit codes */
1152 s->unrestricted_mv = 1;
1153 s->rtp_mode=0; /* don't allow GOB */
1158 s->out_format = FMT_H263;
1163 s->out_format = FMT_H263;
1166 s->modified_quant=1;
1170 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1172 case CODEC_ID_MPEG4:
1173 s->out_format = FMT_H263;
1175 s->unrestricted_mv = 1;
1176 s->low_delay= s->max_b_frames ? 0 : 1;
1177 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1179 case CODEC_ID_MSMPEG4V1:
1180 s->out_format = FMT_H263;
1181 s->h263_msmpeg4 = 1;
1183 s->unrestricted_mv = 1;
1184 s->msmpeg4_version= 1;
1188 case CODEC_ID_MSMPEG4V2:
1189 s->out_format = FMT_H263;
1190 s->h263_msmpeg4 = 1;
1192 s->unrestricted_mv = 1;
1193 s->msmpeg4_version= 2;
1197 case CODEC_ID_MSMPEG4V3:
1198 s->out_format = FMT_H263;
1199 s->h263_msmpeg4 = 1;
1201 s->unrestricted_mv = 1;
1202 s->msmpeg4_version= 3;
1203 s->flipflop_rounding=1;
1208 s->out_format = FMT_H263;
1209 s->h263_msmpeg4 = 1;
1211 s->unrestricted_mv = 1;
1212 s->msmpeg4_version= 4;
1213 s->flipflop_rounding=1;
1218 s->out_format = FMT_H263;
1219 s->h263_msmpeg4 = 1;
1221 s->unrestricted_mv = 1;
1222 s->msmpeg4_version= 5;
1223 s->flipflop_rounding=1;
1231 avctx->has_b_frames= !s->low_delay;
1236 if (MPV_common_init(s) < 0)
1239 if(s->modified_quant)
1240 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1241 s->progressive_frame=
1242 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1243 s->quant_precision=5;
1245 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1246 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1248 #ifdef CONFIG_ENCODERS
1249 if (s->out_format == FMT_H261)
1250 ff_h261_encode_init(s);
1251 if (s->out_format == FMT_H263)
1252 h263_encode_init(s);
1253 if(s->msmpeg4_version)
1254 ff_msmpeg4_encode_init(s);
1255 if (s->out_format == FMT_MPEG1)
1256 ff_mpeg1_encode_init(s);
1261 int j= s->dsp.idct_permutation[i];
1262 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1263 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1264 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1265 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1266 s->intra_matrix[j] =
1267 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1270 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1271 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1273 if(s->avctx->intra_matrix)
1274 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1275 if(s->avctx->inter_matrix)
1276 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1279 /* precompute matrix */
1280 /* for mjpeg, we do include qscale in the matrix */
1281 if (s->out_format != FMT_MJPEG) {
1282 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1283 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1284 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1285 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1288 if(ff_rate_control_init(s) < 0)
1294 int MPV_encode_end(AVCodecContext *avctx)
1296 MpegEncContext *s = avctx->priv_data;
1302 ff_rate_control_uninit(s);
1305 if (s->out_format == FMT_MJPEG)
1308 av_freep(&avctx->extradata);
1313 #endif //CONFIG_ENCODERS
1315 void init_rl(RLTable *rl, int use_static)
1317 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1318 uint8_t index_run[MAX_RUN+1];
1319 int last, run, level, start, end, i;
1321 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1322 if(use_static && rl->max_level[0])
1325 /* compute max_level[], max_run[] and index_run[] */
1326 for(last=0;last<2;last++) {
1335 memset(max_level, 0, MAX_RUN + 1);
1336 memset(max_run, 0, MAX_LEVEL + 1);
1337 memset(index_run, rl->n, MAX_RUN + 1);
1338 for(i=start;i<end;i++) {
1339 run = rl->table_run[i];
1340 level = rl->table_level[i];
1341 if (index_run[run] == rl->n)
1343 if (level > max_level[run])
1344 max_level[run] = level;
1345 if (run > max_run[level])
1346 max_run[level] = run;
1349 rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1351 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1352 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1354 rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1356 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1357 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1359 rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1361 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1362 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1366 /* draw the edges of width 'w' of an image of size width, height */
1367 //FIXME check that this is ok for mpeg4 interlaced
1368 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1370 uint8_t *ptr, *last_line;
1373 last_line = buf + (height - 1) * wrap;
1375 /* top and bottom */
1376 memcpy(buf - (i + 1) * wrap, buf, width);
1377 memcpy(last_line + (i + 1) * wrap, last_line, width);
1379 /* left and right */
1381 for(i=0;i<height;i++) {
1382 memset(ptr - w, ptr[0], w);
1383 memset(ptr + width, ptr[width-1], w);
1388 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1389 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1390 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1391 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1395 int ff_find_unused_picture(MpegEncContext *s, int shared){
1399 for(i=0; i<MAX_PICTURE_COUNT; i++){
1400 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1403 for(i=0; i<MAX_PICTURE_COUNT; i++){
1404 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1406 for(i=0; i<MAX_PICTURE_COUNT; i++){
1407 if(s->picture[i].data[0]==NULL) return i;
1415 static void update_noise_reduction(MpegEncContext *s){
1418 for(intra=0; intra<2; intra++){
1419 if(s->dct_count[intra] > (1<<16)){
1420 for(i=0; i<64; i++){
1421 s->dct_error_sum[intra][i] >>=1;
1423 s->dct_count[intra] >>= 1;
1426 for(i=0; i<64; i++){
1427 s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1);
1433 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1435 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1441 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1443 /* mark&release old frames */
1444 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1445 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1447 /* release forgotten pictures */
1448 /* if(mpeg124/h263) */
1450 for(i=0; i<MAX_PICTURE_COUNT; i++){
1451 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1452 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1453 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1460 /* release non refernce frames */
1461 for(i=0; i<MAX_PICTURE_COUNT; i++){
1462 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1463 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1467 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1468 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1470 i= ff_find_unused_picture(s, 0);
1471 pic= (AVFrame*)&s->picture[i];
1474 pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1475 && !s->dropable ? 3 : 0;
1477 pic->coded_picture_number= s->coded_picture_number++;
1479 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1482 s->current_picture_ptr= (Picture*)pic;
1483 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1484 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1487 s->current_picture_ptr->pict_type= s->pict_type;
1488 // if(s->flags && CODEC_FLAG_QSCALE)
1489 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1490 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1492 copy_picture(&s->current_picture, s->current_picture_ptr);
1494 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1495 if (s->pict_type != B_TYPE) {
1496 s->last_picture_ptr= s->next_picture_ptr;
1498 s->next_picture_ptr= s->current_picture_ptr;
1500 /* 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,
1501 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1502 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1503 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1504 s->pict_type, s->dropable);*/
1506 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1507 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1509 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1510 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1511 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1515 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1517 if(s->picture_structure!=PICT_FRAME){
1520 if(s->picture_structure == PICT_BOTTOM_FIELD){
1521 s->current_picture.data[i] += s->current_picture.linesize[i];
1523 s->current_picture.linesize[i] *= 2;
1524 s->last_picture.linesize[i] *=2;
1525 s->next_picture.linesize[i] *=2;
1530 s->hurry_up= s->avctx->hurry_up;
1531 s->error_resilience= avctx->error_resilience;
1533 /* set dequantizer, we cant do it during init as it might change for mpeg4
1534 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1535 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1536 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1537 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1538 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1539 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1540 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1542 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1543 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1546 if(s->dct_error_sum){
1547 assert(s->avctx->noise_reduction && s->encoding);
1549 update_noise_reduction(s);
1553 if(s->avctx->xvmc_acceleration)
1554 return XVMC_field_start(s, avctx);
1559 /* generic function for encode/decode called after a frame has been coded/decoded */
1560 void MPV_frame_end(MpegEncContext *s)
1563 /* draw edge for correct motion prediction if outside */
1565 //just to make sure that all data is rendered.
1566 if(s->avctx->xvmc_acceleration){
1570 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1571 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1572 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1573 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1577 s->last_pict_type = s->pict_type;
1578 if(s->pict_type!=B_TYPE){
1579 s->last_non_b_pict_type= s->pict_type;
1582 /* copy back current_picture variables */
1583 for(i=0; i<MAX_PICTURE_COUNT; i++){
1584 if(s->picture[i].data[0] == s->current_picture.data[0]){
1585 s->picture[i]= s->current_picture;
1589 assert(i<MAX_PICTURE_COUNT);
1593 /* release non refernce frames */
1594 for(i=0; i<MAX_PICTURE_COUNT; i++){
1595 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1596 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1600 // clear copies, to avoid confusion
1602 memset(&s->last_picture, 0, sizeof(Picture));
1603 memset(&s->next_picture, 0, sizeof(Picture));
1604 memset(&s->current_picture, 0, sizeof(Picture));
1606 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1610 * draws an line from (ex, ey) -> (sx, sy).
1611 * @param w width of the image
1612 * @param h height of the image
1613 * @param stride stride/linesize of the image
1614 * @param color color of the arrow
1616 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1619 sx= clip(sx, 0, w-1);
1620 sy= clip(sy, 0, h-1);
1621 ex= clip(ex, 0, w-1);
1622 ey= clip(ey, 0, h-1);
1624 buf[sy*stride + sx]+= color;
1626 if(ABS(ex - sx) > ABS(ey - sy)){
1631 buf+= sx + sy*stride;
1633 f= ((ey-sy)<<16)/ex;
1634 for(x= 0; x <= ex; x++){
1637 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1638 buf[(y+1)*stride + x]+= (color* fr )>>16;
1645 buf+= sx + sy*stride;
1647 if(ey) f= ((ex-sx)<<16)/ey;
1649 for(y= 0; y <= ey; y++){
1652 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1653 buf[y*stride + x+1]+= (color* fr )>>16;;
1659 * draws an arrow from (ex, ey) -> (sx, sy).
1660 * @param w width of the image
1661 * @param h height of the image
1662 * @param stride stride/linesize of the image
1663 * @param color color of the arrow
1665 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1668 sx= clip(sx, -100, w+100);
1669 sy= clip(sy, -100, h+100);
1670 ex= clip(ex, -100, w+100);
1671 ey= clip(ey, -100, h+100);
1676 if(dx*dx + dy*dy > 3*3){
1679 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1681 //FIXME subpixel accuracy
1682 rx= ROUNDED_DIV(rx*3<<4, length);
1683 ry= ROUNDED_DIV(ry*3<<4, length);
1685 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1686 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1688 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1692 * prints debuging info for the given picture.
1694 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1696 if(!pict || !pict->mb_type) return;
1698 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1701 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1702 switch (pict->pict_type) {
1703 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1704 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1705 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1706 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1707 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1708 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1710 for(y=0; y<s->mb_height; y++){
1711 for(x=0; x<s->mb_width; x++){
1712 if(s->avctx->debug&FF_DEBUG_SKIP){
1713 int count= s->mbskip_table[x + y*s->mb_stride];
1714 if(count>9) count=9;
1715 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1717 if(s->avctx->debug&FF_DEBUG_QP){
1718 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1720 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1721 int mb_type= pict->mb_type[x + y*s->mb_stride];
1722 //Type & MV direction
1724 av_log(s->avctx, AV_LOG_DEBUG, "P");
1725 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1726 av_log(s->avctx, AV_LOG_DEBUG, "A");
1727 else if(IS_INTRA4x4(mb_type))
1728 av_log(s->avctx, AV_LOG_DEBUG, "i");
1729 else if(IS_INTRA16x16(mb_type))
1730 av_log(s->avctx, AV_LOG_DEBUG, "I");
1731 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1732 av_log(s->avctx, AV_LOG_DEBUG, "d");
1733 else if(IS_DIRECT(mb_type))
1734 av_log(s->avctx, AV_LOG_DEBUG, "D");
1735 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1736 av_log(s->avctx, AV_LOG_DEBUG, "g");
1737 else if(IS_GMC(mb_type))
1738 av_log(s->avctx, AV_LOG_DEBUG, "G");
1739 else if(IS_SKIP(mb_type))
1740 av_log(s->avctx, AV_LOG_DEBUG, "S");
1741 else if(!USES_LIST(mb_type, 1))
1742 av_log(s->avctx, AV_LOG_DEBUG, ">");
1743 else if(!USES_LIST(mb_type, 0))
1744 av_log(s->avctx, AV_LOG_DEBUG, "<");
1746 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1747 av_log(s->avctx, AV_LOG_DEBUG, "X");
1752 av_log(s->avctx, AV_LOG_DEBUG, "+");
1753 else if(IS_16X8(mb_type))
1754 av_log(s->avctx, AV_LOG_DEBUG, "-");
1755 else if(IS_8X16(mb_type))
1756 av_log(s->avctx, AV_LOG_DEBUG, "¦");
1757 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1758 av_log(s->avctx, AV_LOG_DEBUG, " ");
1760 av_log(s->avctx, AV_LOG_DEBUG, "?");
1763 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1764 av_log(s->avctx, AV_LOG_DEBUG, "=");
1766 av_log(s->avctx, AV_LOG_DEBUG, " ");
1768 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1770 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1774 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1775 const int shift= 1 + s->quarter_sample;
1779 int h_chroma_shift, v_chroma_shift;
1780 const int width = s->avctx->width;
1781 const int height= s->avctx->height;
1782 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1783 const int mv_stride= (s->mb_width << mv_sample_log2) + 1;
1784 s->low_delay=0; //needed to see the vectors without trashing the buffers
1786 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1788 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1789 pict->data[i]= s->visualization_buffer[i];
1791 pict->type= FF_BUFFER_TYPE_COPY;
1794 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1796 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1797 const int mb_index= mb_x + mb_y*s->mb_stride;
1798 if((s->avctx->debug_mv) && pict->motion_val){
1800 for(type=0; type<3; type++){
1803 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1807 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1811 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1816 if(!USES_LIST(pict->mb_type[mb_index], direction))
1819 if(IS_8X8(pict->mb_type[mb_index])){
1822 int sx= mb_x*16 + 4 + 8*(i&1);
1823 int sy= mb_y*16 + 4 + 8*(i>>1);
1824 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1825 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1826 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1827 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1829 }else if(IS_16X8(pict->mb_type[mb_index])){
1833 int sy=mb_y*16 + 4 + 8*i;
1834 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1835 int mx=(pict->motion_val[direction][xy][0]>>shift);
1836 int my=(pict->motion_val[direction][xy][1]>>shift);
1838 if(IS_INTERLACED(pict->mb_type[mb_index]))
1841 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1843 }else if(IS_8X16(pict->mb_type[mb_index])){
1846 int sx=mb_x*16 + 4 + 8*i;
1848 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1849 int mx=(pict->motion_val[direction][xy][0]>>shift);
1850 int my=(pict->motion_val[direction][xy][1]>>shift);
1852 if(IS_INTERLACED(pict->mb_type[mb_index]))
1855 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1858 int sx= mb_x*16 + 8;
1859 int sy= mb_y*16 + 8;
1860 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1861 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1862 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1863 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1867 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1868 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1871 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1872 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1875 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1876 int mb_type= pict->mb_type[mb_index];
1879 #define COLOR(theta, r)\
1880 u= (int)(128 + r*cos(theta*3.141592/180));\
1881 v= (int)(128 + r*sin(theta*3.141592/180));
1885 if(IS_PCM(mb_type)){
1887 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1889 }else if(IS_INTRA4x4(mb_type)){
1891 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1893 }else if(IS_DIRECT(mb_type)){
1895 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1897 }else if(IS_GMC(mb_type)){
1899 }else if(IS_SKIP(mb_type)){
1901 }else if(!USES_LIST(mb_type, 1)){
1903 }else if(!USES_LIST(mb_type, 0)){
1906 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1910 u*= 0x0101010101010101ULL;
1911 v*= 0x0101010101010101ULL;
1913 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1914 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1918 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1919 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1920 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1922 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1924 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1926 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1927 int dm= 1 << (mv_sample_log2-2);
1929 int sx= mb_x*16 + 8*(i&1);
1930 int sy= mb_y*16 + 8*(i>>1);
1931 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1933 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1934 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1936 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1937 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1938 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1942 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1946 s->mbskip_table[mb_index]=0;
1952 #ifdef CONFIG_ENCODERS
1954 static int get_sae(uint8_t *src, int ref, int stride){
1958 for(y=0; y<16; y++){
1959 for(x=0; x<16; x++){
1960 acc+= ABS(src[x+y*stride] - ref);
1967 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1974 for(y=0; y<h; y+=16){
1975 for(x=0; x<w; x+=16){
1976 int offset= x + y*stride;
1977 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1978 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1979 int sae = get_sae(src + offset, mean, stride);
1981 acc+= sae + 500 < sad;
1988 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1992 const int encoding_delay= s->max_b_frames;
1997 pic_arg->display_picture_number= s->input_picture_number++;
1999 if(pts != AV_NOPTS_VALUE){
2000 if(s->user_specified_pts != AV_NOPTS_VALUE){
2001 int64_t time= av_rescale(pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
2002 int64_t last= av_rescale(s->user_specified_pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
2005 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pts, s->user_specified_pts);
2009 s->user_specified_pts= pts;
2011 if(s->user_specified_pts != AV_NOPTS_VALUE){
2012 s->user_specified_pts=
2013 pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
2014 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pts);
2016 pts= av_rescale(pic_arg->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
2022 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2023 if(pic_arg->linesize[0] != s->linesize) direct=0;
2024 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2025 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2027 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2030 i= ff_find_unused_picture(s, 1);
2032 pic= (AVFrame*)&s->picture[i];
2036 pic->data[i]= pic_arg->data[i];
2037 pic->linesize[i]= pic_arg->linesize[i];
2039 alloc_picture(s, (Picture*)pic, 1);
2042 i= ff_find_unused_picture(s, 0);
2044 pic= (AVFrame*)&s->picture[i];
2047 alloc_picture(s, (Picture*)pic, 0);
2049 if( pic->data[0] + offset == pic_arg->data[0]
2050 && pic->data[1] + offset == pic_arg->data[1]
2051 && pic->data[2] + offset == pic_arg->data[2]){
2054 int h_chroma_shift, v_chroma_shift;
2055 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2058 int src_stride= pic_arg->linesize[i];
2059 int dst_stride= i ? s->uvlinesize : s->linesize;
2060 int h_shift= i ? h_chroma_shift : 0;
2061 int v_shift= i ? v_chroma_shift : 0;
2062 int w= s->width >>h_shift;
2063 int h= s->height>>v_shift;
2064 uint8_t *src= pic_arg->data[i];
2065 uint8_t *dst= pic->data[i] + offset;
2067 if(src_stride==dst_stride)
2068 memcpy(dst, src, src_stride*h);
2071 memcpy(dst, src, w);
2079 copy_picture_attributes(s, pic, pic_arg);
2080 pic->pts= pts; //we set this here to avoid modifiying pic_arg
2083 /* shift buffer entries */
2084 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2085 s->input_picture[i-1]= s->input_picture[i];
2087 s->input_picture[encoding_delay]= (Picture*)pic;
2092 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2097 for(plane=0; plane<3; plane++){
2098 const int stride= p->linesize[plane];
2099 const int bw= plane ? 1 : 2;
2100 for(y=0; y<s->mb_height*bw; y++){
2101 for(x=0; x<s->mb_width*bw; x++){
2102 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);
2104 switch(s->avctx->frame_skip_exp){
2105 case 0: score= FFMAX(score, v); break;
2106 case 1: score+= ABS(v);break;
2107 case 2: score+= v*v;break;
2108 case 3: score64+= ABS(v*v*(int64_t)v);break;
2109 case 4: score64+= v*v*(int64_t)(v*v);break;
2115 if(score) score64= score;
2117 if(score64 < s->avctx->frame_skip_threshold)
2119 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2124 static void select_input_picture(MpegEncContext *s){
2127 for(i=1; i<MAX_PICTURE_COUNT; i++)
2128 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2129 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2131 /* set next picture types & ordering */
2132 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2133 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2134 s->reordered_input_picture[0]= s->input_picture[0];
2135 s->reordered_input_picture[0]->pict_type= I_TYPE;
2136 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2140 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2141 if(skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2142 //av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2144 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2146 s->input_picture[0]->data[i]= NULL;
2147 s->input_picture[0]->type= 0;
2149 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2150 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2152 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2159 if(s->flags&CODEC_FLAG_PASS2){
2160 for(i=0; i<s->max_b_frames+1; i++){
2161 int pict_num= s->input_picture[0]->display_picture_number + i;
2163 if(pict_num >= s->rc_context.num_entries)
2165 if(!s->input_picture[i]){
2166 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2170 s->input_picture[i]->pict_type=
2171 s->rc_context.entry[pict_num].new_pict_type;
2175 if(s->avctx->b_frame_strategy==0){
2176 b_frames= s->max_b_frames;
2177 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2178 }else if(s->avctx->b_frame_strategy==1){
2179 for(i=1; i<s->max_b_frames+1; i++){
2180 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2181 s->input_picture[i]->b_frame_score=
2182 get_intra_count(s, s->input_picture[i ]->data[0],
2183 s->input_picture[i-1]->data[0], s->linesize) + 1;
2186 for(i=0; i<s->max_b_frames; i++){
2187 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2190 b_frames= FFMAX(0, i-1);
2193 for(i=0; i<b_frames+1; i++){
2194 s->input_picture[i]->b_frame_score=0;
2197 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2202 //static int b_count=0;
2203 //b_count+= b_frames;
2204 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2206 for(i= b_frames - 1; i>=0; i--){
2207 int type= s->input_picture[i]->pict_type;
2208 if(type && type != B_TYPE)
2211 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2212 av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2215 if(s->picture_in_gop_number + b_frames >= s->gop_size){
2216 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2217 b_frames= s->gop_size - s->picture_in_gop_number - 1;
2219 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2221 s->input_picture[b_frames]->pict_type= I_TYPE;
2225 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2227 && s->input_picture[b_frames]->pict_type== I_TYPE)
2230 s->reordered_input_picture[0]= s->input_picture[b_frames];
2231 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2232 s->reordered_input_picture[0]->pict_type= P_TYPE;
2233 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2234 for(i=0; i<b_frames; i++){
2235 s->reordered_input_picture[i+1]= s->input_picture[i];
2236 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2237 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2242 if(s->reordered_input_picture[0]){
2243 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2245 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2247 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2248 // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2250 int i= ff_find_unused_picture(s, 0);
2251 Picture *pic= &s->picture[i];
2253 /* mark us unused / free shared pic */
2255 s->reordered_input_picture[0]->data[i]= NULL;
2256 s->reordered_input_picture[0]->type= 0;
2258 pic->reference = s->reordered_input_picture[0]->reference;
2260 alloc_picture(s, pic, 0);
2262 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2264 s->current_picture_ptr= pic;
2266 // input is not a shared pix -> reuse buffer for current_pix
2268 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2269 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2271 s->current_picture_ptr= s->reordered_input_picture[0];
2273 s->new_picture.data[i]+=16;
2276 copy_picture(&s->current_picture, s->current_picture_ptr);
2278 s->picture_number= s->new_picture.display_picture_number;
2279 //printf("dpn:%d\n", s->picture_number);
2281 memset(&s->new_picture, 0, sizeof(Picture));
2285 int MPV_encode_picture(AVCodecContext *avctx,
2286 unsigned char *buf, int buf_size, void *data)
2288 MpegEncContext *s = avctx->priv_data;
2289 AVFrame *pic_arg = data;
2290 int i, stuffing_count;
2292 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUVJ420P){
2293 av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2297 for(i=0; i<avctx->thread_count; i++){
2298 int start_y= s->thread_context[i]->start_mb_y;
2299 int end_y= s->thread_context[i]-> end_mb_y;
2300 int h= s->mb_height;
2301 uint8_t *start= buf + buf_size*start_y/h;
2302 uint8_t *end = buf + buf_size* end_y/h;
2304 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2307 s->picture_in_gop_number++;
2309 if(load_input_picture(s, pic_arg) < 0)
2312 select_input_picture(s);
2315 if(s->new_picture.data[0]){
2316 s->pict_type= s->new_picture.pict_type;
2318 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2319 MPV_frame_start(s, avctx);
2321 encode_picture(s, s->picture_number);
2323 avctx->real_pict_num = s->picture_number;
2324 avctx->header_bits = s->header_bits;
2325 avctx->mv_bits = s->mv_bits;
2326 avctx->misc_bits = s->misc_bits;
2327 avctx->i_tex_bits = s->i_tex_bits;
2328 avctx->p_tex_bits = s->p_tex_bits;
2329 avctx->i_count = s->i_count;
2330 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2331 avctx->skip_count = s->skip_count;
2335 if (s->out_format == FMT_MJPEG)
2336 mjpeg_picture_trailer(s);
2338 if(s->flags&CODEC_FLAG_PASS1)
2339 ff_write_pass1_stats(s);
2342 avctx->error[i] += s->current_picture_ptr->error[i];
2345 if(s->flags&CODEC_FLAG_PASS1)
2346 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2347 flush_put_bits(&s->pb);
2348 s->frame_bits = put_bits_count(&s->pb);
2350 stuffing_count= ff_vbv_update(s, s->frame_bits);
2352 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2353 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2357 switch(s->codec_id){
2358 case CODEC_ID_MPEG1VIDEO:
2359 case CODEC_ID_MPEG2VIDEO:
2360 while(stuffing_count--){
2361 put_bits(&s->pb, 8, 0);
2364 case CODEC_ID_MPEG4:
2365 put_bits(&s->pb, 16, 0);
2366 put_bits(&s->pb, 16, 0x1C3);
2367 stuffing_count -= 4;
2368 while(stuffing_count--){
2369 put_bits(&s->pb, 8, 0xFF);
2373 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2375 flush_put_bits(&s->pb);
2376 s->frame_bits = put_bits_count(&s->pb);
2379 /* update mpeg1/2 vbv_delay for CBR */
2380 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2381 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2384 assert(s->repeat_first_field==0);
2386 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2387 assert(vbv_delay < 0xFFFF);
2389 s->vbv_delay_ptr[0] &= 0xF8;
2390 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2391 s->vbv_delay_ptr[1] = vbv_delay>>5;
2392 s->vbv_delay_ptr[2] &= 0x07;
2393 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2395 s->total_bits += s->frame_bits;
2396 avctx->frame_bits = s->frame_bits;
2398 assert((pbBufPtr(&s->pb) == s->pb.buf));
2401 assert((s->frame_bits&7)==0);
2403 return s->frame_bits/8;
2406 #endif //CONFIG_ENCODERS
2408 static inline void gmc1_motion(MpegEncContext *s,
2409 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2410 uint8_t **ref_picture)
2413 int offset, src_x, src_y, linesize, uvlinesize;
2414 int motion_x, motion_y;
2417 motion_x= s->sprite_offset[0][0];
2418 motion_y= s->sprite_offset[0][1];
2419 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2420 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2421 motion_x<<=(3-s->sprite_warping_accuracy);
2422 motion_y<<=(3-s->sprite_warping_accuracy);
2423 src_x = clip(src_x, -16, s->width);
2424 if (src_x == s->width)
2426 src_y = clip(src_y, -16, s->height);
2427 if (src_y == s->height)
2430 linesize = s->linesize;
2431 uvlinesize = s->uvlinesize;
2433 ptr = ref_picture[0] + (src_y * linesize) + src_x;
2435 if(s->flags&CODEC_FLAG_EMU_EDGE){
2436 if( (unsigned)src_x >= s->h_edge_pos - 17
2437 || (unsigned)src_y >= s->v_edge_pos - 17){
2438 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2439 ptr= s->edge_emu_buffer;
2443 if((motion_x|motion_y)&7){
2444 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2445 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2449 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2450 if (s->no_rounding){
2451 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2453 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2457 if(s->flags&CODEC_FLAG_GRAY) return;
2459 motion_x= s->sprite_offset[1][0];
2460 motion_y= s->sprite_offset[1][1];
2461 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2462 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2463 motion_x<<=(3-s->sprite_warping_accuracy);
2464 motion_y<<=(3-s->sprite_warping_accuracy);
2465 src_x = clip(src_x, -8, s->width>>1);
2466 if (src_x == s->width>>1)
2468 src_y = clip(src_y, -8, s->height>>1);
2469 if (src_y == s->height>>1)
2472 offset = (src_y * uvlinesize) + src_x;
2473 ptr = ref_picture[1] + offset;
2474 if(s->flags&CODEC_FLAG_EMU_EDGE){
2475 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2476 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2477 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);
2478 ptr= s->edge_emu_buffer;
2482 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2484 ptr = ref_picture[2] + offset;
2486 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);
2487 ptr= s->edge_emu_buffer;
2489 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2494 static inline void gmc_motion(MpegEncContext *s,
2495 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2496 uint8_t **ref_picture)
2499 int linesize, uvlinesize;
2500 const int a= s->sprite_warping_accuracy;
2503 linesize = s->linesize;
2504 uvlinesize = s->uvlinesize;
2506 ptr = ref_picture[0];
2508 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2509 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2511 s->dsp.gmc(dest_y, ptr, linesize, 16,
2514 s->sprite_delta[0][0], s->sprite_delta[0][1],
2515 s->sprite_delta[1][0], s->sprite_delta[1][1],
2516 a+1, (1<<(2*a+1)) - s->no_rounding,
2517 s->h_edge_pos, s->v_edge_pos);
2518 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2519 ox + s->sprite_delta[0][0]*8,
2520 oy + s->sprite_delta[1][0]*8,
2521 s->sprite_delta[0][0], s->sprite_delta[0][1],
2522 s->sprite_delta[1][0], s->sprite_delta[1][1],
2523 a+1, (1<<(2*a+1)) - s->no_rounding,
2524 s->h_edge_pos, s->v_edge_pos);
2526 if(s->flags&CODEC_FLAG_GRAY) return;
2528 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2529 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2531 ptr = ref_picture[1];
2532 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2535 s->sprite_delta[0][0], s->sprite_delta[0][1],
2536 s->sprite_delta[1][0], s->sprite_delta[1][1],
2537 a+1, (1<<(2*a+1)) - s->no_rounding,
2538 s->h_edge_pos>>1, s->v_edge_pos>>1);
2540 ptr = ref_picture[2];
2541 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2544 s->sprite_delta[0][0], s->sprite_delta[0][1],
2545 s->sprite_delta[1][0], s->sprite_delta[1][1],
2546 a+1, (1<<(2*a+1)) - s->no_rounding,
2547 s->h_edge_pos>>1, s->v_edge_pos>>1);
2551 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2552 * @param buf destination buffer
2553 * @param src source buffer
2554 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2555 * @param block_w width of block
2556 * @param block_h height of block
2557 * @param src_x x coordinate of the top left sample of the block in the source buffer
2558 * @param src_y y coordinate of the top left sample of the block in the source buffer
2559 * @param w width of the source buffer
2560 * @param h height of the source buffer
2562 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2563 int src_x, int src_y, int w, int h){
2565 int start_y, start_x, end_y, end_x;
2568 src+= (h-1-src_y)*linesize;
2570 }else if(src_y<=-block_h){
2571 src+= (1-block_h-src_y)*linesize;
2577 }else if(src_x<=-block_w){
2578 src+= (1-block_w-src_x);
2582 start_y= FFMAX(0, -src_y);
2583 start_x= FFMAX(0, -src_x);
2584 end_y= FFMIN(block_h, h-src_y);
2585 end_x= FFMIN(block_w, w-src_x);
2587 // copy existing part
2588 for(y=start_y; y<end_y; y++){
2589 for(x=start_x; x<end_x; x++){
2590 buf[x + y*linesize]= src[x + y*linesize];
2595 for(y=0; y<start_y; y++){
2596 for(x=start_x; x<end_x; x++){
2597 buf[x + y*linesize]= buf[x + start_y*linesize];
2602 for(y=end_y; y<block_h; y++){
2603 for(x=start_x; x<end_x; x++){
2604 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2608 for(y=0; y<block_h; y++){
2610 for(x=0; x<start_x; x++){
2611 buf[x + y*linesize]= buf[start_x + y*linesize];
2615 for(x=end_x; x<block_w; x++){
2616 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2621 static inline int hpel_motion(MpegEncContext *s,
2622 uint8_t *dest, uint8_t *src,
2623 int field_based, int field_select,
2624 int src_x, int src_y,
2625 int width, int height, int stride,
2626 int h_edge_pos, int v_edge_pos,
2627 int w, int h, op_pixels_func *pix_op,
2628 int motion_x, int motion_y)
2633 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2634 src_x += motion_x >> 1;
2635 src_y += motion_y >> 1;
2637 /* WARNING: do no forget half pels */
2638 src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2641 src_y = clip(src_y, -16, height);
2642 if (src_y == height)
2644 src += src_y * stride + src_x;
2646 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2647 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2648 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2649 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2650 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2651 src= s->edge_emu_buffer;
2657 pix_op[dxy](dest, src, stride, h);
2661 static inline int hpel_motion_lowres(MpegEncContext *s,
2662 uint8_t *dest, uint8_t *src,
2663 int field_based, int field_select,
2664 int src_x, int src_y,
2665 int width, int height, int stride,
2666 int h_edge_pos, int v_edge_pos,
2667 int w, int h, h264_chroma_mc_func *pix_op,
2668 int motion_x, int motion_y)
2670 const int lowres= s->avctx->lowres;
2671 const int s_mask= (2<<lowres)-1;
2675 if(s->quarter_sample){
2680 sx= motion_x & s_mask;
2681 sy= motion_y & s_mask;
2682 src_x += motion_x >> (lowres+1);
2683 src_y += motion_y >> (lowres+1);
2685 src += src_y * stride + src_x;
2687 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
2688 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2689 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2690 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2691 src= s->edge_emu_buffer;
2699 pix_op[lowres](dest, src, stride, h, sx, sy);
2703 /* apply one mpeg motion vector to the three components */
2704 static always_inline void mpeg_motion(MpegEncContext *s,
2705 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2706 int field_based, int bottom_field, int field_select,
2707 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2708 int motion_x, int motion_y, int h)
2710 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2711 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2714 if(s->quarter_sample)
2721 v_edge_pos = s->v_edge_pos >> field_based;
2722 linesize = s->current_picture.linesize[0] << field_based;
2723 uvlinesize = s->current_picture.linesize[1] << field_based;
2725 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2726 src_x = s->mb_x* 16 + (motion_x >> 1);
2727 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2729 if (s->out_format == FMT_H263) {
2730 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2731 mx = (motion_x>>1)|(motion_x&1);
2733 uvdxy = ((my & 1) << 1) | (mx & 1);
2734 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2735 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2737 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2741 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2745 uvsrc_x = s->mb_x*8 + mx;
2746 uvsrc_y = s->mb_y*8 + my;
2748 if(s->chroma_y_shift){
2751 uvdxy = ((my & 1) << 1) | (mx & 1);
2752 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2753 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2755 if(s->chroma_x_shift){
2758 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2759 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2770 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2771 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2772 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2774 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2775 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2776 if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2777 s->codec_id == CODEC_ID_MPEG1VIDEO){
2778 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2781 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2782 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2783 ptr_y = s->edge_emu_buffer;
2784 if(!(s->flags&CODEC_FLAG_GRAY)){
2785 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2786 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2787 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2788 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2789 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2795 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2796 dest_y += s->linesize;
2797 dest_cb+= s->uvlinesize;
2798 dest_cr+= s->uvlinesize;
2802 ptr_y += s->linesize;
2803 ptr_cb+= s->uvlinesize;
2804 ptr_cr+= s->uvlinesize;
2807 pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2809 if(!(s->flags&CODEC_FLAG_GRAY)){
2810 pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2811 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2813 if(s->out_format == FMT_H261){
2814 ff_h261_loop_filter(s);
2818 /* apply one mpeg motion vector to the three components */
2819 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2820 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2821 int field_based, int bottom_field, int field_select,
2822 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2823 int motion_x, int motion_y, int h)
2825 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2826 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2827 const int lowres= s->avctx->lowres;
2828 const int block_s= 8>>lowres;
2829 const int s_mask= (2<<lowres)-1;
2830 const int h_edge_pos = s->h_edge_pos >> lowres;
2831 const int v_edge_pos = s->v_edge_pos >> lowres;
2832 linesize = s->current_picture.linesize[0] << field_based;
2833 uvlinesize = s->current_picture.linesize[1] << field_based;
2835 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2841 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2844 sx= motion_x & s_mask;
2845 sy= motion_y & s_mask;
2846 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
2847 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2849 if (s->out_format == FMT_H263) {
2850 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2851 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2854 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2857 uvsx = (2*mx) & s_mask;
2858 uvsy = (2*my) & s_mask;
2859 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
2860 uvsrc_y = s->mb_y*block_s + (my >> lowres);
2866 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
2867 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2870 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2871 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2872 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2874 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
2875 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2876 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2877 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2878 ptr_y = s->edge_emu_buffer;
2879 if(!(s->flags&CODEC_FLAG_GRAY)){
2880 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2881 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2882 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2883 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2884 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2890 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2891 dest_y += s->linesize;
2892 dest_cb+= s->uvlinesize;
2893 dest_cr+= s->uvlinesize;
2897 ptr_y += s->linesize;
2898 ptr_cb+= s->uvlinesize;
2899 ptr_cr+= s->uvlinesize;
2904 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2906 if(!(s->flags&CODEC_FLAG_GRAY)){
2907 uvsx <<= 2 - lowres;
2908 uvsy <<= 2 - lowres;
2909 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2910 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2912 //FIXME h261 lowres loop filter
2915 //FIXME move to dsputil, avg variant, 16x16 version
2916 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2918 uint8_t * const top = src[1];
2919 uint8_t * const left = src[2];
2920 uint8_t * const mid = src[0];
2921 uint8_t * const right = src[3];
2922 uint8_t * const bottom= src[4];
2923 #define OBMC_FILTER(x, t, l, m, r, b)\
2924 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2925 #define OBMC_FILTER4(x, t, l, m, r, b)\
2926 OBMC_FILTER(x , t, l, m, r, b);\
2927 OBMC_FILTER(x+1 , t, l, m, r, b);\
2928 OBMC_FILTER(x +stride, t, l, m, r, b);\
2929 OBMC_FILTER(x+1+stride, t, l, m, r, b);
2932 OBMC_FILTER (x , 2, 2, 4, 0, 0);
2933 OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2934 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2935 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2936 OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2937 OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2939 OBMC_FILTER (x , 1, 2, 5, 0, 0);
2940 OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2941 OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2942 OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2944 OBMC_FILTER4(x , 1, 2, 5, 0, 0);
2945 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2946 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2947 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2949 OBMC_FILTER4(x , 0, 2, 5, 0, 1);
2950 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2951 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2952 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2954 OBMC_FILTER (x , 0, 2, 5, 0, 1);
2955 OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2956 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2957 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2958 OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2959 OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2961 OBMC_FILTER (x , 0, 2, 4, 0, 2);
2962 OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2963 OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2964 OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2967 /* obmc for 1 8x8 luma block */
2968 static inline void obmc_motion(MpegEncContext *s,
2969 uint8_t *dest, uint8_t *src,
2970 int src_x, int src_y,
2971 op_pixels_func *pix_op,
2972 int16_t mv[5][2]/* mid top left right bottom*/)
2978 assert(s->quarter_sample==0);
2981 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2984 ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2985 hpel_motion(s, ptr[i], src, 0, 0,
2987 s->width, s->height, s->linesize,
2988 s->h_edge_pos, s->v_edge_pos,
2990 mv[i][0], mv[i][1]);
2994 put_obmc(dest, ptr, s->linesize);
2997 static inline void qpel_motion(MpegEncContext *s,
2998 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2999 int field_based, int bottom_field, int field_select,
3000 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3001 qpel_mc_func (*qpix_op)[16],
3002 int motion_x, int motion_y, int h)
3004 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3005 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3007 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3008 src_x = s->mb_x * 16 + (motion_x >> 2);
3009 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3011 v_edge_pos = s->v_edge_pos >> field_based;
3012 linesize = s->linesize << field_based;
3013 uvlinesize = s->uvlinesize << field_based;
3018 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3019 static const int rtab[8]= {0,0,1,1,0,0,0,1};
3020 mx= (motion_x>>1) + rtab[motion_x&7];
3021 my= (motion_y>>1) + rtab[motion_y&7];
3022 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3023 mx= (motion_x>>1)|(motion_x&1);
3024 my= (motion_y>>1)|(motion_y&1);
3032 uvdxy= (mx&1) | ((my&1)<<1);
3036 uvsrc_x = s->mb_x * 8 + mx;
3037 uvsrc_y = s->mb_y * (8 >> field_based) + my;
3039 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3040 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3041 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3043 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3044 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
3045 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3046 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3047 ptr_y= s->edge_emu_buffer;
3048 if(!(s->flags&CODEC_FLAG_GRAY)){
3049 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3050 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3051 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3052 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3053 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3060 qpix_op[0][dxy](dest_y, ptr_y, linesize);
3063 dest_y += s->linesize;
3064 dest_cb+= s->uvlinesize;
3065 dest_cr+= s->uvlinesize;
3069 ptr_y += s->linesize;
3070 ptr_cb += s->uvlinesize;
3071 ptr_cr += s->uvlinesize;
3073 //damn interlaced mode
3074 //FIXME boundary mirroring is not exactly correct here
3075 qpix_op[1][dxy](dest_y , ptr_y , linesize);
3076 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3078 if(!(s->flags&CODEC_FLAG_GRAY)){
3079 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3080 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3084 inline int ff_h263_round_chroma(int x){
3086 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3089 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3094 * h263 chorma 4mv motion compensation.
3096 static inline void chroma_4mv_motion(MpegEncContext *s,
3097 uint8_t *dest_cb, uint8_t *dest_cr,
3098 uint8_t **ref_picture,
3099 op_pixels_func *pix_op,
3101 int dxy, emu=0, src_x, src_y, offset;
3104 /* In case of 8X8, we construct a single chroma motion vector
3105 with a special rounding */
3106 mx= ff_h263_round_chroma(mx);
3107 my= ff_h263_round_chroma(my);
3109 dxy = ((my & 1) << 1) | (mx & 1);
3113 src_x = s->mb_x * 8 + mx;
3114 src_y = s->mb_y * 8 + my;
3115 src_x = clip(src_x, -8, s->width/2);
3116 if (src_x == s->width/2)
3118 src_y = clip(src_y, -8, s->height/2);
3119 if (src_y == s->height/2)
3122 offset = (src_y * (s->uvlinesize)) + src_x;
3123 ptr = ref_picture[1] + offset;
3124 if(s->flags&CODEC_FLAG_EMU_EDGE){
3125 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3126 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3127 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);
3128 ptr= s->edge_emu_buffer;
3132 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3134 ptr = ref_picture[2] + offset;
3136 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);
3137 ptr= s->edge_emu_buffer;
3139 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3142 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3143 uint8_t *dest_cb, uint8_t *dest_cr,
3144 uint8_t **ref_picture,
3145 h264_chroma_mc_func *pix_op,
3147 const int lowres= s->avctx->lowres;
3148 const int block_s= 8>>lowres;
3149 const int s_mask= (2<<lowres)-1;
3150 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3151 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3152 int emu=0, src_x, src_y, offset, sx, sy;
3155 if(s->quarter_sample){
3160 /* In case of 8X8, we construct a single chroma motion vector
3161 with a special rounding */
3162 mx= ff_h263_round_chroma(mx);
3163 my= ff_h263_round_chroma(my);
3167 src_x = s->mb_x*block_s + (mx >> (lowres+1));
3168 src_y = s->mb_y*block_s + (my >> (lowres+1));
3170 offset = src_y * s->uvlinesize + src_x;
3171 ptr = ref_picture[1] + offset;
3172 if(s->flags&CODEC_FLAG_EMU_EDGE){
3173 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3174 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3175 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3176 ptr= s->edge_emu_buffer;
3182 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3184 ptr = ref_picture[2] + offset;
3186 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3187 ptr= s->edge_emu_buffer;
3189 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3193 * motion compesation of a single macroblock
3195 * @param dest_y luma destination pointer
3196 * @param dest_cb chroma cb/u destination pointer
3197 * @param dest_cr chroma cr/v destination pointer
3198 * @param dir direction (0->forward, 1->backward)
3199 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3200 * @param pic_op halfpel motion compensation function (average or put normally)
3201 * @param pic_op qpel motion compensation function (average or put normally)
3202 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3204 static inline void MPV_motion(MpegEncContext *s,
3205 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3206 int dir, uint8_t **ref_picture,
3207 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3209 int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3211 uint8_t *ptr, *dest;
3216 if(s->obmc && s->pict_type != B_TYPE){
3217 int16_t mv_cache[4][4][2];
3218 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3219 const int mot_stride= s->b8_stride;
3220 const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3222 assert(!s->mb_skiped);
3224 memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy ], sizeof(int16_t)*4);
3225 memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3226 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3228 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3229 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3231 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3234 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3235 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3236 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3238 *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3239 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3242 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3243 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3244 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3246 *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3247 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3253 const int x= (i&1)+1;
3254 const int y= (i>>1)+1;
3256 {mv_cache[y][x ][0], mv_cache[y][x ][1]},
3257 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3258 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3259 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3260 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3262 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3264 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3271 if(!(s->flags&CODEC_FLAG_GRAY))
3272 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3277 switch(s->mv_type) {
3280 if(s->real_sprite_warping_points==1){
3281 gmc1_motion(s, dest_y, dest_cb, dest_cr,
3284 gmc_motion(s, dest_y, dest_cb, dest_cr,
3287 }else if(s->quarter_sample){
3288 qpel_motion(s, dest_y, dest_cb, dest_cr,
3290 ref_picture, pix_op, qpix_op,
3291 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3293 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3294 ref_picture, pix_op,
3295 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3298 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3300 ref_picture, pix_op,
3301 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3307 if(s->quarter_sample){
3309 motion_x = s->mv[dir][i][0];
3310 motion_y = s->mv[dir][i][1];
3312 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3313 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3314 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3316 /* WARNING: do no forget half pels */
3317 src_x = clip(src_x, -16, s->width);
3318 if (src_x == s->width)
3320 src_y = clip(src_y, -16, s->height);
3321 if (src_y == s->height)
3324 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3325 if(s->flags&CODEC_FLAG_EMU_EDGE){
3326 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3327 || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3328 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);
3329 ptr= s->edge_emu_buffer;
3332 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3333 qpix_op[1][dxy](dest, ptr, s->linesize);
3335 mx += s->mv[dir][i][0]/2;
3336 my += s->mv[dir][i][1]/2;
3340 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3341 ref_picture[0], 0, 0,
3342 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3343 s->width, s->height, s->linesize,
3344 s->h_edge_pos, s->v_edge_pos,
3346 s->mv[dir][i][0], s->mv[dir][i][1]);
3348 mx += s->mv[dir][i][0];
3349 my += s->mv[dir][i][1];
3353 if(!(s->flags&CODEC_FLAG_GRAY))
3354 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3357 if (s->picture_structure == PICT_FRAME) {
3358 if(s->quarter_sample){
3360 qpel_motion(s, dest_y, dest_cb, dest_cr,
3361 1, i, s->field_select[dir][i],
3362 ref_picture, pix_op, qpix_op,
3363 s->mv[dir][i][0], s->mv[dir][i][1], 8);
3367 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3368 1, 0, s->field_select[dir][0],
3369 ref_picture, pix_op,
3370 s->mv[dir][0][0], s->mv[dir][0][1], 8);
3372 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3373 1, 1, s->field_select[dir][1],
3374 ref_picture, pix_op,
3375 s->mv[dir][1][0], s->mv[dir][1][1], 8);
3378 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3379 ref_picture= s->current_picture_ptr->data;
3382 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3383 0, 0, s->field_select[dir][0],
3384 ref_picture, pix_op,
3385 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3390 uint8_t ** ref2picture;
3392 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3393 ref2picture= ref_picture;
3395 ref2picture= s->current_picture_ptr->data;
3398 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3399 0, 0, s->field_select[dir][i],
3400 ref2picture, pix_op,
3401 s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3403 dest_y += 16*s->linesize;
3404 dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3405 dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3409 if(s->picture_structure == PICT_FRAME){
3413 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3415 ref_picture, pix_op,
3416 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3418 pix_op = s->dsp.avg_pixels_tab;
3422 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3423 0, 0, s->picture_structure != i+1,
3424 ref_picture, pix_op,
3425 s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3427 // after put we make avg of the same block
3428 pix_op=s->dsp.avg_pixels_tab;
3430 //opposite parity is always in the same frame if this is second field
3431 if(!s->first_field){
3432 ref_picture = s->current_picture_ptr->data;
3442 * motion compesation of a single macroblock
3444 * @param dest_y luma destination pointer
3445 * @param dest_cb chroma cb/u destination pointer
3446 * @param dest_cr chroma cr/v destination pointer
3447 * @param dir direction (0->forward, 1->backward)
3448 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3449 * @param pic_op halfpel motion compensation function (average or put normally)
3450 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3452 static inline void MPV_motion_lowres(MpegEncContext *s,
3453 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3454 int dir, uint8_t **ref_picture,
3455 h264_chroma_mc_func *pix_op)
3459 const int lowres= s->avctx->lowres;
3460 const int block_s= 8>>lowres;