2 * The simplest mpeg encoder (well, it was the simplest!)
3 * Copyright (c) 2000,2001 Fabrice Bellard.
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 * 4MV & hq & b-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
25 * The simplest mpeg encoder (well, it was the simplest!).
30 #include "mpegvideo.h"
35 #include "fastmemcpy.h"
41 #ifdef CONFIG_ENCODERS
42 static void encode_picture(MpegEncContext *s, int picture_number);
43 #endif //CONFIG_ENCODERS
44 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
45 DCTELEM *block, int n, int qscale);
46 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
47 DCTELEM *block, int n, int qscale);
48 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
49 DCTELEM *block, int n, int qscale);
50 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
51 DCTELEM *block, int n, int qscale);
52 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
53 DCTELEM *block, int n, int qscale);
54 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
55 DCTELEM *block, int n, int qscale);
56 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
57 #ifdef CONFIG_ENCODERS
58 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
59 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
60 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
61 static int sse_mb(MpegEncContext *s);
62 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
63 #endif //CONFIG_ENCODERS
66 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
67 extern void XVMC_field_end(MpegEncContext *s);
68 extern void XVMC_decode_mb(MpegEncContext *s);
71 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
74 /* enable all paranoid tests for rounding, overflows, etc... */
80 /* for jpeg fast DCT */
83 static const uint16_t aanscales[64] = {
84 /* precomputed values scaled up by 14 bits */
85 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
86 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
87 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
88 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
89 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
90 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
91 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
92 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
95 static const uint8_t h263_chroma_roundtab[16] = {
96 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
97 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
100 static const uint8_t ff_default_chroma_qscale_table[32]={
101 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
102 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
105 #ifdef CONFIG_ENCODERS
106 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
107 static uint8_t default_fcode_tab[MAX_MV*2+1];
109 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
111 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
112 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
117 for(qscale=qmin; qscale<=qmax; qscale++){
119 if (dsp->fdct == ff_jpeg_fdct_islow
120 #ifdef FAAN_POSTSCALE
121 || dsp->fdct == ff_faandct
125 const int j= dsp->idct_permutation[i];
126 /* 16 <= qscale * quant_matrix[i] <= 7905 */
127 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
128 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
129 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
131 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
132 (qscale * quant_matrix[j]));
134 } else if (dsp->fdct == fdct_ifast
135 #ifndef FAAN_POSTSCALE
136 || dsp->fdct == ff_faandct
140 const int j= dsp->idct_permutation[i];
141 /* 16 <= qscale * quant_matrix[i] <= 7905 */
142 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
143 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
144 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
146 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
147 (aanscales[i] * qscale * quant_matrix[j]));
151 const int j= dsp->idct_permutation[i];
152 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
153 So 16 <= qscale * quant_matrix[i] <= 7905
154 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
155 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
157 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
158 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
159 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
161 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
162 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
166 for(i=intra; i<64; i++){
168 if (dsp->fdct == fdct_ifast
169 #ifndef FAAN_POSTSCALE
170 || dsp->fdct == ff_faandct
173 max= (8191LL*aanscales[i]) >> 14;
175 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
181 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger then %d, overflows possible\n", QMAT_SHIFT - shift);
185 static inline void update_qscale(MpegEncContext *s){
186 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
187 s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
189 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
191 #endif //CONFIG_ENCODERS
193 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
197 st->scantable= src_scantable;
201 j = src_scantable[i];
202 st->permutated[i] = permutation[j];
211 j = st->permutated[i];
213 st->raster_end[i]= end;
217 #ifdef CONFIG_ENCODERS
218 void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
224 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
229 #endif //CONFIG_ENCODERS
231 /* init common dct for both encoder and decoder */
232 int DCT_common_init(MpegEncContext *s)
234 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
235 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
236 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
237 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
238 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
239 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
241 #ifdef CONFIG_ENCODERS
242 s->dct_quantize= dct_quantize_c;
243 s->denoise_dct= denoise_dct_c;
244 #endif //CONFIG_ENCODERS
247 MPV_common_init_mmx(s);
250 MPV_common_init_axp(s);
253 MPV_common_init_mlib(s);
256 MPV_common_init_mmi(s);
259 MPV_common_init_armv4l(s);
262 MPV_common_init_ppc(s);
265 #ifdef CONFIG_ENCODERS
266 s->fast_dct_quantize= s->dct_quantize;
268 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
269 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
272 #endif //CONFIG_ENCODERS
274 /* load & permutate scantables
275 note: only wmv uses different 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 doesn't 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; // skipped 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 isn't recommended!\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 decision\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 supported 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->time_base.den || !avctx->time_base.num){
1054 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1058 i= (INT_MAX/2+128)>>8;
1059 if(avctx->me_threshold >= i){
1060 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1063 if(avctx->mb_threshold >= i){
1064 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1068 i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1070 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1071 avctx->time_base.den /= i;
1072 avctx->time_base.num /= i;
1076 if(s->codec_id==CODEC_ID_MJPEG){
1077 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1078 s->inter_quant_bias= 0;
1079 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1080 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1081 s->inter_quant_bias= 0;
1083 s->intra_quant_bias=0;
1084 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1087 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1088 s->intra_quant_bias= avctx->intra_quant_bias;
1089 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1090 s->inter_quant_bias= avctx->inter_quant_bias;
1092 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1094 if(s->avctx->time_base.den > (1<<16)-1){
1095 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1098 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1100 switch(avctx->codec->id) {
1101 case CODEC_ID_MPEG1VIDEO:
1102 s->out_format = FMT_MPEG1;
1103 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1104 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1106 case CODEC_ID_MPEG2VIDEO:
1107 s->out_format = FMT_MPEG1;
1108 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1109 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1112 case CODEC_ID_LJPEG:
1113 case CODEC_ID_MJPEG:
1114 s->out_format = FMT_MJPEG;
1115 s->intra_only = 1; /* force intra only for jpeg */
1116 s->mjpeg_write_tables = 1; /* write all tables */
1117 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1118 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1119 s->mjpeg_vsample[1] = 1;
1120 s->mjpeg_vsample[2] = 1;
1121 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1122 s->mjpeg_hsample[1] = 1;
1123 s->mjpeg_hsample[2] = 1;
1124 if (mjpeg_init(s) < 0)
1130 s->out_format = FMT_H261;
1135 if (h263_get_picture_format(s->width, s->height) == 7) {
1136 av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
1139 s->out_format = FMT_H263;
1140 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1144 case CODEC_ID_H263P:
1145 s->out_format = FMT_H263;
1148 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1149 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1150 s->modified_quant= s->h263_aic;
1151 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1152 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1153 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1154 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1155 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1158 /* These are just to be sure */
1163 s->out_format = FMT_H263;
1164 s->h263_flv = 2; /* format = 1; 11-bit codes */
1165 s->unrestricted_mv = 1;
1166 s->rtp_mode=0; /* don't allow GOB */
1171 s->out_format = FMT_H263;
1176 s->out_format = FMT_H263;
1179 s->modified_quant=1;
1183 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1185 case CODEC_ID_MPEG4:
1186 s->out_format = FMT_H263;
1188 s->unrestricted_mv = 1;
1189 s->low_delay= s->max_b_frames ? 0 : 1;
1190 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1192 case CODEC_ID_MSMPEG4V1:
1193 s->out_format = FMT_H263;
1194 s->h263_msmpeg4 = 1;
1196 s->unrestricted_mv = 1;
1197 s->msmpeg4_version= 1;
1201 case CODEC_ID_MSMPEG4V2:
1202 s->out_format = FMT_H263;
1203 s->h263_msmpeg4 = 1;
1205 s->unrestricted_mv = 1;
1206 s->msmpeg4_version= 2;
1210 case CODEC_ID_MSMPEG4V3:
1211 s->out_format = FMT_H263;
1212 s->h263_msmpeg4 = 1;
1214 s->unrestricted_mv = 1;
1215 s->msmpeg4_version= 3;
1216 s->flipflop_rounding=1;
1221 s->out_format = FMT_H263;
1222 s->h263_msmpeg4 = 1;
1224 s->unrestricted_mv = 1;
1225 s->msmpeg4_version= 4;
1226 s->flipflop_rounding=1;
1231 s->out_format = FMT_H263;
1232 s->h263_msmpeg4 = 1;
1234 s->unrestricted_mv = 1;
1235 s->msmpeg4_version= 5;
1236 s->flipflop_rounding=1;
1244 avctx->has_b_frames= !s->low_delay;
1249 if (MPV_common_init(s) < 0)
1252 if(s->modified_quant)
1253 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1254 s->progressive_frame=
1255 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1256 s->quant_precision=5;
1258 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1259 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1261 if (s->out_format == FMT_H261)
1262 ff_h261_encode_init(s);
1263 if (s->out_format == FMT_H263)
1264 h263_encode_init(s);
1265 if(s->msmpeg4_version)
1266 ff_msmpeg4_encode_init(s);
1267 if (s->out_format == FMT_MPEG1)
1268 ff_mpeg1_encode_init(s);
1272 int j= s->dsp.idct_permutation[i];
1273 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1274 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1275 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1276 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1277 s->intra_matrix[j] =
1278 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1281 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1282 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1284 if(s->avctx->intra_matrix)
1285 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1286 if(s->avctx->inter_matrix)
1287 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1290 /* precompute matrix */
1291 /* for mjpeg, we do include qscale in the matrix */
1292 if (s->out_format != FMT_MJPEG) {
1293 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1294 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1295 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1296 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1299 if(ff_rate_control_init(s) < 0)
1305 int MPV_encode_end(AVCodecContext *avctx)
1307 MpegEncContext *s = avctx->priv_data;
1313 ff_rate_control_uninit(s);
1316 if (s->out_format == FMT_MJPEG)
1319 av_freep(&avctx->extradata);
1324 #endif //CONFIG_ENCODERS
1326 void init_rl(RLTable *rl, int use_static)
1328 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1329 uint8_t index_run[MAX_RUN+1];
1330 int last, run, level, start, end, i;
1332 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1333 if(use_static && rl->max_level[0])
1336 /* compute max_level[], max_run[] and index_run[] */
1337 for(last=0;last<2;last++) {
1346 memset(max_level, 0, MAX_RUN + 1);
1347 memset(max_run, 0, MAX_LEVEL + 1);
1348 memset(index_run, rl->n, MAX_RUN + 1);
1349 for(i=start;i<end;i++) {
1350 run = rl->table_run[i];
1351 level = rl->table_level[i];
1352 if (index_run[run] == rl->n)
1354 if (level > max_level[run])
1355 max_level[run] = level;
1356 if (run > max_run[level])
1357 max_run[level] = run;
1360 rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1362 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1363 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1365 rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1367 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1368 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1370 rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1372 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1373 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1377 /* draw the edges of width 'w' of an image of size width, height */
1378 //FIXME check that this is ok for mpeg4 interlaced
1379 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1381 uint8_t *ptr, *last_line;
1384 last_line = buf + (height - 1) * wrap;
1386 /* top and bottom */
1387 memcpy(buf - (i + 1) * wrap, buf, width);
1388 memcpy(last_line + (i + 1) * wrap, last_line, width);
1390 /* left and right */
1392 for(i=0;i<height;i++) {
1393 memset(ptr - w, ptr[0], w);
1394 memset(ptr + width, ptr[width-1], w);
1399 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1400 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1401 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1402 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1406 int ff_find_unused_picture(MpegEncContext *s, int shared){
1410 for(i=0; i<MAX_PICTURE_COUNT; i++){
1411 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1414 for(i=0; i<MAX_PICTURE_COUNT; i++){
1415 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1417 for(i=0; i<MAX_PICTURE_COUNT; i++){
1418 if(s->picture[i].data[0]==NULL) return i;
1426 static void update_noise_reduction(MpegEncContext *s){
1429 for(intra=0; intra<2; intra++){
1430 if(s->dct_count[intra] > (1<<16)){
1431 for(i=0; i<64; i++){
1432 s->dct_error_sum[intra][i] >>=1;
1434 s->dct_count[intra] >>= 1;
1437 for(i=0; i<64; i++){
1438 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);
1444 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1446 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1452 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1454 /* mark&release old frames */
1455 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1456 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1458 /* release forgotten pictures */
1459 /* if(mpeg124/h263) */
1461 for(i=0; i<MAX_PICTURE_COUNT; i++){
1462 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1463 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1464 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1471 /* release non refernce frames */
1472 for(i=0; i<MAX_PICTURE_COUNT; i++){
1473 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1474 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1478 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1479 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1481 i= ff_find_unused_picture(s, 0);
1482 pic= (AVFrame*)&s->picture[i];
1485 pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1486 && !s->dropable ? 3 : 0;
1488 pic->coded_picture_number= s->coded_picture_number++;
1490 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1493 s->current_picture_ptr= (Picture*)pic;
1494 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1495 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1498 s->current_picture_ptr->pict_type= s->pict_type;
1499 // if(s->flags && CODEC_FLAG_QSCALE)
1500 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1501 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1503 copy_picture(&s->current_picture, s->current_picture_ptr);
1505 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1506 if (s->pict_type != B_TYPE) {
1507 s->last_picture_ptr= s->next_picture_ptr;
1509 s->next_picture_ptr= s->current_picture_ptr;
1511 /* 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,
1512 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1513 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1514 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1515 s->pict_type, s->dropable);*/
1517 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1518 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1520 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1521 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1522 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1526 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1528 if(s->picture_structure!=PICT_FRAME){
1531 if(s->picture_structure == PICT_BOTTOM_FIELD){
1532 s->current_picture.data[i] += s->current_picture.linesize[i];
1534 s->current_picture.linesize[i] *= 2;
1535 s->last_picture.linesize[i] *=2;
1536 s->next_picture.linesize[i] *=2;
1541 s->hurry_up= s->avctx->hurry_up;
1542 s->error_resilience= avctx->error_resilience;
1544 /* set dequantizer, we cant do it during init as it might change for mpeg4
1545 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1546 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1547 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1548 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1549 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1550 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1551 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1553 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1554 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1557 if(s->dct_error_sum){
1558 assert(s->avctx->noise_reduction && s->encoding);
1560 update_noise_reduction(s);
1564 if(s->avctx->xvmc_acceleration)
1565 return XVMC_field_start(s, avctx);
1570 /* generic function for encode/decode called after a frame has been coded/decoded */
1571 void MPV_frame_end(MpegEncContext *s)
1574 /* draw edge for correct motion prediction if outside */
1576 //just to make sure that all data is rendered.
1577 if(s->avctx->xvmc_acceleration){
1581 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1582 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1583 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1584 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1588 s->last_pict_type = s->pict_type;
1589 if(s->pict_type!=B_TYPE){
1590 s->last_non_b_pict_type= s->pict_type;
1593 /* copy back current_picture variables */
1594 for(i=0; i<MAX_PICTURE_COUNT; i++){
1595 if(s->picture[i].data[0] == s->current_picture.data[0]){
1596 s->picture[i]= s->current_picture;
1600 assert(i<MAX_PICTURE_COUNT);
1604 /* release non refernce frames */
1605 for(i=0; i<MAX_PICTURE_COUNT; i++){
1606 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1607 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1611 // clear copies, to avoid confusion
1613 memset(&s->last_picture, 0, sizeof(Picture));
1614 memset(&s->next_picture, 0, sizeof(Picture));
1615 memset(&s->current_picture, 0, sizeof(Picture));
1617 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1621 * draws an line from (ex, ey) -> (sx, sy).
1622 * @param w width of the image
1623 * @param h height of the image
1624 * @param stride stride/linesize of the image
1625 * @param color color of the arrow
1627 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1630 sx= clip(sx, 0, w-1);
1631 sy= clip(sy, 0, h-1);
1632 ex= clip(ex, 0, w-1);
1633 ey= clip(ey, 0, h-1);
1635 buf[sy*stride + sx]+= color;
1637 if(ABS(ex - sx) > ABS(ey - sy)){
1642 buf+= sx + sy*stride;
1644 f= ((ey-sy)<<16)/ex;
1645 for(x= 0; x <= ex; x++){
1648 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1649 buf[(y+1)*stride + x]+= (color* fr )>>16;
1656 buf+= sx + sy*stride;
1658 if(ey) f= ((ex-sx)<<16)/ey;
1660 for(y= 0; y <= ey; y++){
1663 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1664 buf[y*stride + x+1]+= (color* fr )>>16;;
1670 * draws an arrow from (ex, ey) -> (sx, sy).
1671 * @param w width of the image
1672 * @param h height of the image
1673 * @param stride stride/linesize of the image
1674 * @param color color of the arrow
1676 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1679 sx= clip(sx, -100, w+100);
1680 sy= clip(sy, -100, h+100);
1681 ex= clip(ex, -100, w+100);
1682 ey= clip(ey, -100, h+100);
1687 if(dx*dx + dy*dy > 3*3){
1690 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1692 //FIXME subpixel accuracy
1693 rx= ROUNDED_DIV(rx*3<<4, length);
1694 ry= ROUNDED_DIV(ry*3<<4, length);
1696 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1697 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1699 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1703 * prints debuging info for the given picture.
1705 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1707 if(!pict || !pict->mb_type) return;
1709 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1712 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1713 switch (pict->pict_type) {
1714 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1715 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1716 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1717 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1718 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1719 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1721 for(y=0; y<s->mb_height; y++){
1722 for(x=0; x<s->mb_width; x++){
1723 if(s->avctx->debug&FF_DEBUG_SKIP){
1724 int count= s->mbskip_table[x + y*s->mb_stride];
1725 if(count>9) count=9;
1726 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1728 if(s->avctx->debug&FF_DEBUG_QP){
1729 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1731 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1732 int mb_type= pict->mb_type[x + y*s->mb_stride];
1733 //Type & MV direction
1735 av_log(s->avctx, AV_LOG_DEBUG, "P");
1736 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1737 av_log(s->avctx, AV_LOG_DEBUG, "A");
1738 else if(IS_INTRA4x4(mb_type))
1739 av_log(s->avctx, AV_LOG_DEBUG, "i");
1740 else if(IS_INTRA16x16(mb_type))
1741 av_log(s->avctx, AV_LOG_DEBUG, "I");
1742 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1743 av_log(s->avctx, AV_LOG_DEBUG, "d");
1744 else if(IS_DIRECT(mb_type))
1745 av_log(s->avctx, AV_LOG_DEBUG, "D");
1746 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1747 av_log(s->avctx, AV_LOG_DEBUG, "g");
1748 else if(IS_GMC(mb_type))
1749 av_log(s->avctx, AV_LOG_DEBUG, "G");
1750 else if(IS_SKIP(mb_type))
1751 av_log(s->avctx, AV_LOG_DEBUG, "S");
1752 else if(!USES_LIST(mb_type, 1))
1753 av_log(s->avctx, AV_LOG_DEBUG, ">");
1754 else if(!USES_LIST(mb_type, 0))
1755 av_log(s->avctx, AV_LOG_DEBUG, "<");
1757 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1758 av_log(s->avctx, AV_LOG_DEBUG, "X");
1763 av_log(s->avctx, AV_LOG_DEBUG, "+");
1764 else if(IS_16X8(mb_type))
1765 av_log(s->avctx, AV_LOG_DEBUG, "-");
1766 else if(IS_8X16(mb_type))
1767 av_log(s->avctx, AV_LOG_DEBUG, "¦");
1768 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1769 av_log(s->avctx, AV_LOG_DEBUG, " ");
1771 av_log(s->avctx, AV_LOG_DEBUG, "?");
1774 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1775 av_log(s->avctx, AV_LOG_DEBUG, "=");
1777 av_log(s->avctx, AV_LOG_DEBUG, " ");
1779 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1781 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1785 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1786 const int shift= 1 + s->quarter_sample;
1790 int h_chroma_shift, v_chroma_shift;
1791 const int width = s->avctx->width;
1792 const int height= s->avctx->height;
1793 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1794 const int mv_stride= (s->mb_width << mv_sample_log2) + 1;
1795 s->low_delay=0; //needed to see the vectors without trashing the buffers
1797 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1799 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1800 pict->data[i]= s->visualization_buffer[i];
1802 pict->type= FF_BUFFER_TYPE_COPY;
1805 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1807 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1808 const int mb_index= mb_x + mb_y*s->mb_stride;
1809 if((s->avctx->debug_mv) && pict->motion_val){
1811 for(type=0; type<3; type++){
1814 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1818 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1822 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1827 if(!USES_LIST(pict->mb_type[mb_index], direction))
1830 if(IS_8X8(pict->mb_type[mb_index])){
1833 int sx= mb_x*16 + 4 + 8*(i&1);
1834 int sy= mb_y*16 + 4 + 8*(i>>1);
1835 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1836 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1837 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1838 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1840 }else if(IS_16X8(pict->mb_type[mb_index])){
1844 int sy=mb_y*16 + 4 + 8*i;
1845 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1846 int mx=(pict->motion_val[direction][xy][0]>>shift);
1847 int my=(pict->motion_val[direction][xy][1]>>shift);
1849 if(IS_INTERLACED(pict->mb_type[mb_index]))
1852 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1854 }else if(IS_8X16(pict->mb_type[mb_index])){
1857 int sx=mb_x*16 + 4 + 8*i;
1859 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1860 int mx=(pict->motion_val[direction][xy][0]>>shift);
1861 int my=(pict->motion_val[direction][xy][1]>>shift);
1863 if(IS_INTERLACED(pict->mb_type[mb_index]))
1866 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1869 int sx= mb_x*16 + 8;
1870 int sy= mb_y*16 + 8;
1871 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1872 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1873 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1874 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1878 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1879 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1882 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1883 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1886 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1887 int mb_type= pict->mb_type[mb_index];
1890 #define COLOR(theta, r)\
1891 u= (int)(128 + r*cos(theta*3.141592/180));\
1892 v= (int)(128 + r*sin(theta*3.141592/180));
1896 if(IS_PCM(mb_type)){
1898 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1900 }else if(IS_INTRA4x4(mb_type)){
1902 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1904 }else if(IS_DIRECT(mb_type)){
1906 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1908 }else if(IS_GMC(mb_type)){
1910 }else if(IS_SKIP(mb_type)){
1912 }else if(!USES_LIST(mb_type, 1)){
1914 }else if(!USES_LIST(mb_type, 0)){
1917 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1921 u*= 0x0101010101010101ULL;
1922 v*= 0x0101010101010101ULL;
1924 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1925 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1929 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1930 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1931 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1933 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1935 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1937 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1938 int dm= 1 << (mv_sample_log2-2);
1940 int sx= mb_x*16 + 8*(i&1);
1941 int sy= mb_y*16 + 8*(i>>1);
1942 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1944 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1945 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1947 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1948 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1949 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1953 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1957 s->mbskip_table[mb_index]=0;
1963 #ifdef CONFIG_ENCODERS
1965 static int get_sae(uint8_t *src, int ref, int stride){
1969 for(y=0; y<16; y++){
1970 for(x=0; x<16; x++){
1971 acc+= ABS(src[x+y*stride] - ref);
1978 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1985 for(y=0; y<h; y+=16){
1986 for(x=0; x<w; x+=16){
1987 int offset= x + y*stride;
1988 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1989 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1990 int sae = get_sae(src + offset, mean, stride);
1992 acc+= sae + 500 < sad;
1999 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2003 const int encoding_delay= s->max_b_frames;
2008 pic_arg->display_picture_number= s->input_picture_number++;
2010 if(pts != AV_NOPTS_VALUE){
2011 if(s->user_specified_pts != AV_NOPTS_VALUE){
2013 int64_t last= s->user_specified_pts;
2016 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pts, s->user_specified_pts);
2020 s->user_specified_pts= pts;
2022 if(s->user_specified_pts != AV_NOPTS_VALUE){
2023 s->user_specified_pts=
2024 pts= s->user_specified_pts + 1;
2025 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pts);
2027 pts= pic_arg->display_picture_number;
2033 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2034 if(pic_arg->linesize[0] != s->linesize) direct=0;
2035 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2036 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2038 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2041 i= ff_find_unused_picture(s, 1);
2043 pic= (AVFrame*)&s->picture[i];
2047 pic->data[i]= pic_arg->data[i];
2048 pic->linesize[i]= pic_arg->linesize[i];
2050 alloc_picture(s, (Picture*)pic, 1);
2053 i= ff_find_unused_picture(s, 0);
2055 pic= (AVFrame*)&s->picture[i];
2058 alloc_picture(s, (Picture*)pic, 0);
2060 if( pic->data[0] + offset == pic_arg->data[0]
2061 && pic->data[1] + offset == pic_arg->data[1]
2062 && pic->data[2] + offset == pic_arg->data[2]){
2065 int h_chroma_shift, v_chroma_shift;
2066 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2069 int src_stride= pic_arg->linesize[i];
2070 int dst_stride= i ? s->uvlinesize : s->linesize;
2071 int h_shift= i ? h_chroma_shift : 0;
2072 int v_shift= i ? v_chroma_shift : 0;
2073 int w= s->width >>h_shift;
2074 int h= s->height>>v_shift;
2075 uint8_t *src= pic_arg->data[i];
2076 uint8_t *dst= pic->data[i] + offset;
2078 if(src_stride==dst_stride)
2079 memcpy(dst, src, src_stride*h);
2082 memcpy(dst, src, w);
2090 copy_picture_attributes(s, pic, pic_arg);
2091 pic->pts= pts; //we set this here to avoid modifiying pic_arg
2094 /* shift buffer entries */
2095 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2096 s->input_picture[i-1]= s->input_picture[i];
2098 s->input_picture[encoding_delay]= (Picture*)pic;
2103 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2108 for(plane=0; plane<3; plane++){
2109 const int stride= p->linesize[plane];
2110 const int bw= plane ? 1 : 2;
2111 for(y=0; y<s->mb_height*bw; y++){
2112 for(x=0; x<s->mb_width*bw; x++){
2113 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);
2115 switch(s->avctx->frame_skip_exp){
2116 case 0: score= FFMAX(score, v); break;
2117 case 1: score+= ABS(v);break;
2118 case 2: score+= v*v;break;
2119 case 3: score64+= ABS(v*v*(int64_t)v);break;
2120 case 4: score64+= v*v*(int64_t)(v*v);break;
2126 if(score) score64= score;
2128 if(score64 < s->avctx->frame_skip_threshold)
2130 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2135 static void select_input_picture(MpegEncContext *s){
2138 for(i=1; i<MAX_PICTURE_COUNT; i++)
2139 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2140 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2142 /* set next picture types & ordering */
2143 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2144 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2145 s->reordered_input_picture[0]= s->input_picture[0];
2146 s->reordered_input_picture[0]->pict_type= I_TYPE;
2147 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2151 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2152 if(skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2153 //av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2155 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2157 s->input_picture[0]->data[i]= NULL;
2158 s->input_picture[0]->type= 0;
2160 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2161 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2163 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2170 if(s->flags&CODEC_FLAG_PASS2){
2171 for(i=0; i<s->max_b_frames+1; i++){
2172 int pict_num= s->input_picture[0]->display_picture_number + i;
2174 if(pict_num >= s->rc_context.num_entries)
2176 if(!s->input_picture[i]){
2177 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2181 s->input_picture[i]->pict_type=
2182 s->rc_context.entry[pict_num].new_pict_type;
2186 if(s->avctx->b_frame_strategy==0){
2187 b_frames= s->max_b_frames;
2188 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2189 }else if(s->avctx->b_frame_strategy==1){
2190 for(i=1; i<s->max_b_frames+1; i++){
2191 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2192 s->input_picture[i]->b_frame_score=
2193 get_intra_count(s, s->input_picture[i ]->data[0],
2194 s->input_picture[i-1]->data[0], s->linesize) + 1;
2197 for(i=0; i<s->max_b_frames; i++){
2198 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2201 b_frames= FFMAX(0, i-1);
2204 for(i=0; i<b_frames+1; i++){
2205 s->input_picture[i]->b_frame_score=0;
2208 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2213 //static int b_count=0;
2214 //b_count+= b_frames;
2215 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2217 for(i= b_frames - 1; i>=0; i--){
2218 int type= s->input_picture[i]->pict_type;
2219 if(type && type != B_TYPE)
2222 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2223 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2226 if(s->picture_in_gop_number + b_frames >= s->gop_size){
2227 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2228 b_frames= s->gop_size - s->picture_in_gop_number - 1;
2230 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2232 s->input_picture[b_frames]->pict_type= I_TYPE;
2236 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2238 && s->input_picture[b_frames]->pict_type== I_TYPE)
2241 s->reordered_input_picture[0]= s->input_picture[b_frames];
2242 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2243 s->reordered_input_picture[0]->pict_type= P_TYPE;
2244 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2245 for(i=0; i<b_frames; i++){
2246 s->reordered_input_picture[i+1]= s->input_picture[i];
2247 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2248 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2253 if(s->reordered_input_picture[0]){
2254 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2256 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2258 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2259 // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2261 int i= ff_find_unused_picture(s, 0);
2262 Picture *pic= &s->picture[i];
2264 /* mark us unused / free shared pic */
2266 s->reordered_input_picture[0]->data[i]= NULL;
2267 s->reordered_input_picture[0]->type= 0;
2269 pic->reference = s->reordered_input_picture[0]->reference;
2271 alloc_picture(s, pic, 0);
2273 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2275 s->current_picture_ptr= pic;
2277 // input is not a shared pix -> reuse buffer for current_pix
2279 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2280 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2282 s->current_picture_ptr= s->reordered_input_picture[0];
2284 s->new_picture.data[i]+=16;
2287 copy_picture(&s->current_picture, s->current_picture_ptr);
2289 s->picture_number= s->new_picture.display_picture_number;
2290 //printf("dpn:%d\n", s->picture_number);
2292 memset(&s->new_picture, 0, sizeof(Picture));
2296 int MPV_encode_picture(AVCodecContext *avctx,
2297 unsigned char *buf, int buf_size, void *data)
2299 MpegEncContext *s = avctx->priv_data;
2300 AVFrame *pic_arg = data;
2301 int i, stuffing_count;
2303 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUVJ420P){
2304 av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2308 for(i=0; i<avctx->thread_count; i++){
2309 int start_y= s->thread_context[i]->start_mb_y;
2310 int end_y= s->thread_context[i]-> end_mb_y;
2311 int h= s->mb_height;
2312 uint8_t *start= buf + buf_size*start_y/h;
2313 uint8_t *end = buf + buf_size* end_y/h;
2315 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2318 s->picture_in_gop_number++;
2320 if(load_input_picture(s, pic_arg) < 0)
2323 select_input_picture(s);
2326 if(s->new_picture.data[0]){
2327 s->pict_type= s->new_picture.pict_type;
2329 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2330 MPV_frame_start(s, avctx);
2332 encode_picture(s, s->picture_number);
2334 avctx->real_pict_num = s->picture_number;
2335 avctx->header_bits = s->header_bits;
2336 avctx->mv_bits = s->mv_bits;
2337 avctx->misc_bits = s->misc_bits;
2338 avctx->i_tex_bits = s->i_tex_bits;
2339 avctx->p_tex_bits = s->p_tex_bits;
2340 avctx->i_count = s->i_count;
2341 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2342 avctx->skip_count = s->skip_count;
2346 if (s->out_format == FMT_MJPEG)
2347 mjpeg_picture_trailer(s);
2349 if(s->flags&CODEC_FLAG_PASS1)
2350 ff_write_pass1_stats(s);
2353 avctx->error[i] += s->current_picture_ptr->error[i];
2356 if(s->flags&CODEC_FLAG_PASS1)
2357 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2358 flush_put_bits(&s->pb);
2359 s->frame_bits = put_bits_count(&s->pb);
2361 stuffing_count= ff_vbv_update(s, s->frame_bits);
2363 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2364 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2368 switch(s->codec_id){
2369 case CODEC_ID_MPEG1VIDEO:
2370 case CODEC_ID_MPEG2VIDEO:
2371 while(stuffing_count--){
2372 put_bits(&s->pb, 8, 0);
2375 case CODEC_ID_MPEG4:
2376 put_bits(&s->pb, 16, 0);
2377 put_bits(&s->pb, 16, 0x1C3);
2378 stuffing_count -= 4;
2379 while(stuffing_count--){
2380 put_bits(&s->pb, 8, 0xFF);
2384 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2386 flush_put_bits(&s->pb);
2387 s->frame_bits = put_bits_count(&s->pb);
2390 /* update mpeg1/2 vbv_delay for CBR */
2391 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2392 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2395 assert(s->repeat_first_field==0);
2397 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2398 assert(vbv_delay < 0xFFFF);
2400 s->vbv_delay_ptr[0] &= 0xF8;
2401 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2402 s->vbv_delay_ptr[1] = vbv_delay>>5;
2403 s->vbv_delay_ptr[2] &= 0x07;
2404 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2406 s->total_bits += s->frame_bits;
2407 avctx->frame_bits = s->frame_bits;
2409 assert((pbBufPtr(&s->pb) == s->pb.buf));
2412 assert((s->frame_bits&7)==0);
2414 return s->frame_bits/8;
2417 #endif //CONFIG_ENCODERS
2419 static inline void gmc1_motion(MpegEncContext *s,
2420 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2421 uint8_t **ref_picture)
2424 int offset, src_x, src_y, linesize, uvlinesize;
2425 int motion_x, motion_y;
2428 motion_x= s->sprite_offset[0][0];
2429 motion_y= s->sprite_offset[0][1];
2430 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2431 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2432 motion_x<<=(3-s->sprite_warping_accuracy);
2433 motion_y<<=(3-s->sprite_warping_accuracy);
2434 src_x = clip(src_x, -16, s->width);
2435 if (src_x == s->width)
2437 src_y = clip(src_y, -16, s->height);
2438 if (src_y == s->height)
2441 linesize = s->linesize;
2442 uvlinesize = s->uvlinesize;
2444 ptr = ref_picture[0] + (src_y * linesize) + src_x;
2446 if(s->flags&CODEC_FLAG_EMU_EDGE){
2447 if( (unsigned)src_x >= s->h_edge_pos - 17
2448 || (unsigned)src_y >= s->v_edge_pos - 17){
2449 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2450 ptr= s->edge_emu_buffer;
2454 if((motion_x|motion_y)&7){
2455 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2456 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2460 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2461 if (s->no_rounding){
2462 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2464 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2468 if(s->flags&CODEC_FLAG_GRAY) return;
2470 motion_x= s->sprite_offset[1][0];
2471 motion_y= s->sprite_offset[1][1];
2472 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2473 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2474 motion_x<<=(3-s->sprite_warping_accuracy);
2475 motion_y<<=(3-s->sprite_warping_accuracy);
2476 src_x = clip(src_x, -8, s->width>>1);
2477 if (src_x == s->width>>1)
2479 src_y = clip(src_y, -8, s->height>>1);
2480 if (src_y == s->height>>1)
2483 offset = (src_y * uvlinesize) + src_x;
2484 ptr = ref_picture[1] + offset;
2485 if(s->flags&CODEC_FLAG_EMU_EDGE){
2486 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2487 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2488 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);
2489 ptr= s->edge_emu_buffer;
2493 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2495 ptr = ref_picture[2] + offset;
2497 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);
2498 ptr= s->edge_emu_buffer;
2500 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2505 static inline void gmc_motion(MpegEncContext *s,
2506 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2507 uint8_t **ref_picture)
2510 int linesize, uvlinesize;
2511 const int a= s->sprite_warping_accuracy;
2514 linesize = s->linesize;
2515 uvlinesize = s->uvlinesize;
2517 ptr = ref_picture[0];
2519 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2520 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2522 s->dsp.gmc(dest_y, ptr, linesize, 16,
2525 s->sprite_delta[0][0], s->sprite_delta[0][1],
2526 s->sprite_delta[1][0], s->sprite_delta[1][1],
2527 a+1, (1<<(2*a+1)) - s->no_rounding,
2528 s->h_edge_pos, s->v_edge_pos);
2529 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2530 ox + s->sprite_delta[0][0]*8,
2531 oy + s->sprite_delta[1][0]*8,
2532 s->sprite_delta[0][0], s->sprite_delta[0][1],
2533 s->sprite_delta[1][0], s->sprite_delta[1][1],
2534 a+1, (1<<(2*a+1)) - s->no_rounding,
2535 s->h_edge_pos, s->v_edge_pos);
2537 if(s->flags&CODEC_FLAG_GRAY) return;
2539 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2540 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2542 ptr = ref_picture[1];
2543 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2546 s->sprite_delta[0][0], s->sprite_delta[0][1],
2547 s->sprite_delta[1][0], s->sprite_delta[1][1],
2548 a+1, (1<<(2*a+1)) - s->no_rounding,
2549 s->h_edge_pos>>1, s->v_edge_pos>>1);
2551 ptr = ref_picture[2];
2552 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2555 s->sprite_delta[0][0], s->sprite_delta[0][1],
2556 s->sprite_delta[1][0], s->sprite_delta[1][1],
2557 a+1, (1<<(2*a+1)) - s->no_rounding,
2558 s->h_edge_pos>>1, s->v_edge_pos>>1);
2562 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2563 * @param buf destination buffer
2564 * @param src source buffer
2565 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2566 * @param block_w width of block
2567 * @param block_h height of block
2568 * @param src_x x coordinate of the top left sample of the block in the source buffer
2569 * @param src_y y coordinate of the top left sample of the block in the source buffer
2570 * @param w width of the source buffer
2571 * @param h height of the source buffer
2573 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2574 int src_x, int src_y, int w, int h){
2576 int start_y, start_x, end_y, end_x;
2579 src+= (h-1-src_y)*linesize;
2581 }else if(src_y<=-block_h){
2582 src+= (1-block_h-src_y)*linesize;
2588 }else if(src_x<=-block_w){
2589 src+= (1-block_w-src_x);
2593 start_y= FFMAX(0, -src_y);
2594 start_x= FFMAX(0, -src_x);
2595 end_y= FFMIN(block_h, h-src_y);
2596 end_x= FFMIN(block_w, w-src_x);
2598 // copy existing part
2599 for(y=start_y; y<end_y; y++){
2600 for(x=start_x; x<end_x; x++){
2601 buf[x + y*linesize]= src[x + y*linesize];
2606 for(y=0; y<start_y; y++){
2607 for(x=start_x; x<end_x; x++){
2608 buf[x + y*linesize]= buf[x + start_y*linesize];
2613 for(y=end_y; y<block_h; y++){
2614 for(x=start_x; x<end_x; x++){
2615 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2619 for(y=0; y<block_h; y++){
2621 for(x=0; x<start_x; x++){
2622 buf[x + y*linesize]= buf[start_x + y*linesize];
2626 for(x=end_x; x<block_w; x++){
2627 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2632 static inline int hpel_motion(MpegEncContext *s,
2633 uint8_t *dest, uint8_t *src,
2634 int field_based, int field_select,
2635 int src_x, int src_y,
2636 int width, int height, int stride,
2637 int h_edge_pos, int v_edge_pos,
2638 int w, int h, op_pixels_func *pix_op,
2639 int motion_x, int motion_y)
2644 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2645 src_x += motion_x >> 1;
2646 src_y += motion_y >> 1;
2648 /* WARNING: do no forget half pels */
2649 src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2652 src_y = clip(src_y, -16, height);
2653 if (src_y == height)
2655 src += src_y * stride + src_x;
2657 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2658 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2659 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2660 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2661 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2662 src= s->edge_emu_buffer;
2668 pix_op[dxy](dest, src, stride, h);
2672 static inline int hpel_motion_lowres(MpegEncContext *s,
2673 uint8_t *dest, uint8_t *src,
2674 int field_based, int field_select,
2675 int src_x, int src_y,
2676 int width, int height, int stride,
2677 int h_edge_pos, int v_edge_pos,
2678 int w, int h, h264_chroma_mc_func *pix_op,
2679 int motion_x, int motion_y)
2681 const int lowres= s->avctx->lowres;
2682 const int s_mask= (2<<lowres)-1;
2686 if(s->quarter_sample){
2691 sx= motion_x & s_mask;
2692 sy= motion_y & s_mask;
2693 src_x += motion_x >> (lowres+1);
2694 src_y += motion_y >> (lowres+1);
2696 src += src_y * stride + src_x;
2698 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
2699 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2700 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2701 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2702 src= s->edge_emu_buffer;
2710 pix_op[lowres](dest, src, stride, h, sx, sy);
2714 /* apply one mpeg motion vector to the three components */
2715 static always_inline void mpeg_motion(MpegEncContext *s,
2716 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2717 int field_based, int bottom_field, int field_select,
2718 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2719 int motion_x, int motion_y, int h)
2721 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2722 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2725 if(s->quarter_sample)
2732 v_edge_pos = s->v_edge_pos >> field_based;
2733 linesize = s->current_picture.linesize[0] << field_based;
2734 uvlinesize = s->current_picture.linesize[1] << field_based;
2736 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2737 src_x = s->mb_x* 16 + (motion_x >> 1);
2738 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2740 if (s->out_format == FMT_H263) {
2741 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2742 mx = (motion_x>>1)|(motion_x&1);
2744 uvdxy = ((my & 1) << 1) | (mx & 1);
2745 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2746 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2748 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2752 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2756 uvsrc_x = s->mb_x*8 + mx;
2757 uvsrc_y = s->mb_y*8 + my;
2759 if(s->chroma_y_shift){
2762 uvdxy = ((my & 1) << 1) | (mx & 1);
2763 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2764 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2766 if(s->chroma_x_shift){
2769 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2770 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2781 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2782 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2783 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2785 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2786 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2787 if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2788 s->codec_id == CODEC_ID_MPEG1VIDEO){
2789 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2792 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2793 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2794 ptr_y = s->edge_emu_buffer;
2795 if(!(s->flags&CODEC_FLAG_GRAY)){
2796 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2797 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2798 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2799 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2800 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2806 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2807 dest_y += s->linesize;
2808 dest_cb+= s->uvlinesize;
2809 dest_cr+= s->uvlinesize;
2813 ptr_y += s->linesize;
2814 ptr_cb+= s->uvlinesize;
2815 ptr_cr+= s->uvlinesize;
2818 pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2820 if(!(s->flags&CODEC_FLAG_GRAY)){
2821 pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2822 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2824 if(s->out_format == FMT_H261){
2825 ff_h261_loop_filter(s);
2829 /* apply one mpeg motion vector to the three components */
2830 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2831 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2832 int field_based, int bottom_field, int field_select,
2833 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2834 int motion_x, int motion_y, int h)
2836 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2837 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2838 const int lowres= s->avctx->lowres;
2839 const int block_s= 8>>lowres;
2840 const int s_mask= (2<<lowres)-1;
2841 const int h_edge_pos = s->h_edge_pos >> lowres;
2842 const int v_edge_pos = s->v_edge_pos >> lowres;
2843 linesize = s->current_picture.linesize[0] << field_based;
2844 uvlinesize = s->current_picture.linesize[1] << field_based;
2846 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2852 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2855 sx= motion_x & s_mask;
2856 sy= motion_y & s_mask;
2857 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
2858 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2860 if (s->out_format == FMT_H263) {
2861 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2862 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2865 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2868 uvsx = (2*mx) & s_mask;
2869 uvsy = (2*my) & s_mask;
2870 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
2871 uvsrc_y = s->mb_y*block_s + (my >> lowres);
2877 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
2878 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2881 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2882 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2883 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2885 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
2886 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2887 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2888 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2889 ptr_y = s->edge_emu_buffer;
2890 if(!(s->flags&CODEC_FLAG_GRAY)){
2891 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2892 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2893 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2894 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2895 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2901 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2902 dest_y += s->linesize;
2903 dest_cb+= s->uvlinesize;
2904 dest_cr+= s->uvlinesize;
2908 ptr_y += s->linesize;
2909 ptr_cb+= s->uvlinesize;
2910 ptr_cr+= s->uvlinesize;
2915 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2917 if(!(s->flags&CODEC_FLAG_GRAY)){
2918 uvsx <<= 2 - lowres;
2919 uvsy <<= 2 - lowres;
2920 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2921 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2923 //FIXME h261 lowres loop filter
2926 //FIXME move to dsputil, avg variant, 16x16 version
2927 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2929 uint8_t * const top = src[1];
2930 uint8_t * const left = src[2];
2931 uint8_t * const mid = src[0];
2932 uint8_t * const right = src[3];
2933 uint8_t * const bottom= src[4];
2934 #define OBMC_FILTER(x, t, l, m, r, b)\
2935 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2936 #define OBMC_FILTER4(x, t, l, m, r, b)\
2937 OBMC_FILTER(x , t, l, m, r, b);\
2938 OBMC_FILTER(x+1 , t, l, m, r, b);\
2939 OBMC_FILTER(x +stride, t, l, m, r, b);\
2940 OBMC_FILTER(x+1+stride, t, l, m, r, b);
2943 OBMC_FILTER (x , 2, 2, 4, 0, 0);
2944 OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2945 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2946 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2947 OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2948 OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2950 OBMC_FILTER (x , 1, 2, 5, 0, 0);
2951 OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2952 OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2953 OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2955 OBMC_FILTER4(x , 1, 2, 5, 0, 0);
2956 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2957 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2958 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2960 OBMC_FILTER4(x , 0, 2, 5, 0, 1);
2961 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2962 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2963 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2965 OBMC_FILTER (x , 0, 2, 5, 0, 1);
2966 OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2967 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2968 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2969 OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2970 OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2972 OBMC_FILTER (x , 0, 2, 4, 0, 2);
2973 OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2974 OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2975 OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2978 /* obmc for 1 8x8 luma block */
2979 static inline void obmc_motion(MpegEncContext *s,
2980 uint8_t *dest, uint8_t *src,
2981 int src_x, int src_y,
2982 op_pixels_func *pix_op,
2983 int16_t mv[5][2]/* mid top left right bottom*/)
2989 assert(s->quarter_sample==0);
2992 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2995 ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2996 hpel_motion(s, ptr[i], src, 0, 0,
2998 s->width, s->height, s->linesize,
2999 s->h_edge_pos, s->v_edge_pos,
3001 mv[i][0], mv[i][1]);
3005 put_obmc(dest, ptr, s->linesize);
3008 static inline void qpel_motion(MpegEncContext *s,
3009 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3010 int field_based, int bottom_field, int field_select,
3011 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3012 qpel_mc_func (*qpix_op)[16],
3013 int motion_x, int motion_y, int h)
3015 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3016 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3018 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3019 src_x = s->mb_x * 16 + (motion_x >> 2);
3020 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3022 v_edge_pos = s->v_edge_pos >> field_based;
3023 linesize = s->linesize << field_based;
3024 uvlinesize = s->uvlinesize << field_based;
3029 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3030 static const int rtab[8]= {0,0,1,1,0,0,0,1};
3031 mx= (motion_x>>1) + rtab[motion_x&7];
3032 my= (motion_y>>1) + rtab[motion_y&7];
3033 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3034 mx= (motion_x>>1)|(motion_x&1);
3035 my= (motion_y>>1)|(motion_y&1);
3043 uvdxy= (mx&1) | ((my&1)<<1);
3047 uvsrc_x = s->mb_x * 8 + mx;
3048 uvsrc_y = s->mb_y * (8 >> field_based) + my;
3050 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3051 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3052 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3054 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3055 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
3056 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3057 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3058 ptr_y= s->edge_emu_buffer;
3059 if(!(s->flags&CODEC_FLAG_GRAY)){
3060 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3061 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3062 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3063 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3064 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3071 qpix_op[0][dxy](dest_y, ptr_y, linesize);
3074 dest_y += s->linesize;
3075 dest_cb+= s->uvlinesize;
3076 dest_cr+= s->uvlinesize;
3080 ptr_y += s->linesize;
3081 ptr_cb += s->uvlinesize;
3082 ptr_cr += s->uvlinesize;
3084 //damn interlaced mode
3085 //FIXME boundary mirroring is not exactly correct here
3086 qpix_op[1][dxy](dest_y , ptr_y , linesize);
3087 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3089 if(!(s->flags&CODEC_FLAG_GRAY)){
3090 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3091 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3095 inline int ff_h263_round_chroma(int x){
3097 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3100 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3105 * h263 chorma 4mv motion compensation.
3107 static inline void chroma_4mv_motion(MpegEncContext *s,
3108 uint8_t *dest_cb, uint8_t *dest_cr,
3109 uint8_t **ref_picture,
3110 op_pixels_func *pix_op,
3112 int dxy, emu=0, src_x, src_y, offset;
3115 /* In case of 8X8, we construct a single chroma motion vector
3116 with a special rounding */
3117 mx= ff_h263_round_chroma(mx);
3118 my= ff_h263_round_chroma(my);
3120 dxy = ((my & 1) << 1) | (mx & 1);
3124 src_x = s->mb_x * 8 + mx;
3125 src_y = s->mb_y * 8 + my;
3126 src_x = clip(src_x, -8, s->width/2);
3127 if (src_x == s->width/2)
3129 src_y = clip(src_y, -8, s->height/2);
3130 if (src_y == s->height/2)
3133 offset = (src_y * (s->uvlinesize)) + src_x;
3134 ptr = ref_picture[1] + offset;
3135 if(s->flags&CODEC_FLAG_EMU_EDGE){
3136 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3137 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3138 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);
3139 ptr= s->edge_emu_buffer;
3143 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3145 ptr = ref_picture[2] + offset;
3147 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);
3148 ptr= s->edge_emu_buffer;
3150 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3153 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3154 uint8_t *dest_cb, uint8_t *dest_cr,
3155 uint8_t **ref_picture,
3156 h264_chroma_mc_func *pix_op,
3158 const int lowres= s->avctx->lowres;
3159 const int block_s= 8>>lowres;
3160 const int s_mask= (2<<lowres)-1;
3161 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3162 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3163 int emu=0, src_x, src_y, offset, sx, sy;
3166 if(s->quarter_sample){
3171 /* In case of 8X8, we construct a single chroma motion vector
3172 with a special rounding */
3173 mx= ff_h263_round_chroma(mx);
3174 my= ff_h263_round_chroma(my);
3178 src_x = s->mb_x*block_s + (mx >> (lowres+1));
3179 src_y = s->mb_y*block_s + (my >> (lowres+1));
3181 offset = src_y * s->uvlinesize + src_x;
3182 ptr = ref_picture[1] + offset;
3183 if(s->flags&CODEC_FLAG_EMU_EDGE){
3184 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3185 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
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;
3193 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3195 ptr = ref_picture[2] + offset;
3197 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3198 ptr= s->edge_emu_buffer;
3200 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3204 * motion compesation of a single macroblock
3206 * @param dest_y luma destination pointer
3207 * @param dest_cb chroma cb/u destination pointer
3208 * @param dest_cr chroma cr/v destination pointer
3209 * @param dir direction (0->forward, 1->backward)
3210 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3211 * @param pic_op halfpel motion compensation function (average or put normally)
3212 * @param pic_op qpel motion compensation function (average or put normally)
3213 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3215 static inline void MPV_motion(MpegEncContext *s,
3216 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3217 int dir, uint8_t **ref_picture,
3218 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3220 int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3222 uint8_t *ptr, *dest;
3227 if(s->obmc && s->pict_type != B_TYPE){
3228 int16_t mv_cache[4][4][2];
3229 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3230 const int mot_stride= s->b8_stride;
3231 const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3233 assert(!s->mb_skipped);
3235 memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy ], sizeof(int16_t)*4);
3236 memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3237 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3239 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3240 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3242 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3245 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3246 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3247 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3249 *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3250 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3253 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3254 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3255 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3257 *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3258 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3264 const int x= (i&1)+1;
3265 const int y= (i>>1)+1;
3267 {mv_cache[y][x ][0], mv_cache[y][x ][1]},
3268 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3269 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3270 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3271 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3273 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3275 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3282 if(!(s->flags&CODEC_FLAG_GRAY))
3283 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3288 switch(s->mv_type) {
3291 if(s->real_sprite_warping_points==1){
3292 gmc1_motion(s, dest_y, dest_cb, dest_cr,
3295 gmc_motion(s, dest_y, dest_cb, dest_cr,
3298 }else if(s->quarter_sample){
3299 qpel_motion(s, dest_y, dest_cb, dest_cr,
3301 ref_picture, pix_op, qpix_op,
3302 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3304 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3305 ref_picture, pix_op,
3306 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3309 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3311 ref_picture, pix_op,
3312 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3318 if(s->quarter_sample){
3320 motion_x = s->mv[dir][i][0];
3321 motion_y = s->mv[dir][i][1];
3323 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3324 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3325 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3327 /* WARNING: do no forget half pels */
3328 src_x = clip(src_x, -16, s->width);
3329 if (src_x == s->width)
3331 src_y = clip(src_y, -16, s->height);
3332 if (src_y == s->height)
3335 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3336 if(s->flags&CODEC_FLAG_EMU_EDGE){
3337 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3338 || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3339 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);
3340 ptr= s->edge_emu_buffer;
3343 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3344 qpix_op[1][dxy](dest, ptr, s->linesize);
3346 mx += s->mv[dir][i][0]/2;
3347 my += s->mv[dir][i][1]/2;
3351 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3352 ref_picture[0], 0, 0,
3353 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3354 s->width, s->height, s->linesize,
3355 s->h_edge_pos, s->v_edge_pos,
3357 s->mv[dir][i][0], s->mv[dir][i][1]);
3359 mx += s->mv[dir][i][0];
3360 my += s->mv[dir][i][1];
3364 if(!(s->flags&CODEC_FLAG_GRAY))
3365 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3368 if (s->picture_structure == PICT_FRAME) {
3369 if(s->quarter_sample){
3371 qpel_motion(s, dest_y, dest_cb, dest_cr,
3372 1, i, s->field_select[dir][i],
3373 ref_picture, pix_op, qpix_op,
3374 s->mv[dir][i][0], s->mv[dir][i][1], 8);
3378 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3379 1, 0, s->field_select[dir][0],
3380 ref_picture, pix_op,
3381 s->mv[dir][0][0], s->mv[dir][0][1], 8);
3383 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3384 1, 1, s->field_select[dir][1],
3385 ref_picture, pix_op,
3386 s->mv[dir][1][0], s->mv[dir][1][1], 8);
3389 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3390 ref_picture= s->current_picture_ptr->data;
3393 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3394 0, 0, s->field_select[dir][0],
3395 ref_picture, pix_op,
3396 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3401 uint8_t ** ref2picture;
3403 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3404 ref2picture= ref_picture;
3406 ref2picture= s->current_picture_ptr->data;
3409 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3410 0, 0, s->field_select[dir][i],
3411 ref2picture, pix_op,
3412 s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3414 dest_y += 16*s->linesize;
3415 dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3416 dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3420 if(s->picture_structure == PICT_FRAME){
3424 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3426 ref_picture, pix_op,
3427 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3429 pix_op = s->dsp.avg_pixels_tab;
3433 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3434 0, 0, s->picture_structure != i+1,
3435 ref_picture, pix_op,
3436 s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3438 // after put we make avg of the same block
3439 pix_op=s->dsp.avg_pixels_tab;
3441 //opposite parity is always in the same frame if this is second field
3442 if(!s->first_field){
3443 ref_picture = s->current_picture_ptr->data;
3453 * motion compesation of a single macroblock
3455 * @param dest_y luma destination pointer
3456 * @param dest_cb chroma cb/u destination pointer
3457 * @param dest_cr chroma cr/v destination pointer
3458 * @param dir direction (0->forward, 1->backward)
3459 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3460 * @param pic_op halfpel motion compensation function (average or put normally)
3461 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3463 static inline void MPV_motion_lowres(MpegEncContext *s,
3464 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,