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 dct_unquantize_h261_intra_c(MpegEncContext *s,
57 DCTELEM *block, int n, int qscale);
58 static void dct_unquantize_h261_inter_c(MpegEncContext *s,
59 DCTELEM *block, int n, int qscale);
60 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
61 #ifdef CONFIG_ENCODERS
62 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
63 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
64 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
65 static int sse_mb(MpegEncContext *s);
66 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
67 #endif //CONFIG_ENCODERS
70 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
71 extern void XVMC_field_end(MpegEncContext *s);
72 extern void XVMC_decode_mb(MpegEncContext *s);
75 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
78 /* enable all paranoid tests for rounding, overflows, etc... */
84 /* for jpeg fast DCT */
87 static const uint16_t aanscales[64] = {
88 /* precomputed values scaled up by 14 bits */
89 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
90 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
91 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
92 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
93 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
94 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
95 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
96 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
99 static const uint8_t h263_chroma_roundtab[16] = {
100 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
101 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
104 static const uint8_t ff_default_chroma_qscale_table[32]={
105 // 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
106 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
109 #ifdef CONFIG_ENCODERS
110 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
111 static uint8_t default_fcode_tab[MAX_MV*2+1];
113 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
115 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
116 const uint16_t *quant_matrix, int bias, int qmin, int qmax)
120 for(qscale=qmin; qscale<=qmax; qscale++){
122 if (dsp->fdct == ff_jpeg_fdct_islow
123 #ifdef FAAN_POSTSCALE
124 || dsp->fdct == ff_faandct
128 const int j= dsp->idct_permutation[i];
129 /* 16 <= qscale * quant_matrix[i] <= 7905 */
130 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
131 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
132 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
134 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
135 (qscale * quant_matrix[j]));
137 } else if (dsp->fdct == fdct_ifast
138 #ifndef FAAN_POSTSCALE
139 || dsp->fdct == ff_faandct
143 const int j= dsp->idct_permutation[i];
144 /* 16 <= qscale * quant_matrix[i] <= 7905 */
145 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
146 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
147 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
149 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
150 (aanscales[i] * qscale * quant_matrix[j]));
154 const int j= dsp->idct_permutation[i];
155 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
156 So 16 <= qscale * quant_matrix[i] <= 7905
157 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
158 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
160 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
161 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
162 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
164 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
165 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
171 static inline void update_qscale(MpegEncContext *s){
172 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
173 s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
175 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
177 #endif //CONFIG_ENCODERS
179 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
183 st->scantable= src_scantable;
187 j = src_scantable[i];
188 st->permutated[i] = permutation[j];
197 j = st->permutated[i];
199 st->raster_end[i]= end;
203 #ifdef CONFIG_ENCODERS
204 void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
210 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
215 #endif //CONFIG_ENCODERS
217 /* init common dct for both encoder and decoder */
218 int DCT_common_init(MpegEncContext *s)
220 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
221 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
222 s->dct_unquantize_h261_intra = dct_unquantize_h261_intra_c;
223 s->dct_unquantize_h261_inter = dct_unquantize_h261_inter_c;
224 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
225 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
226 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
227 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
229 #ifdef CONFIG_ENCODERS
230 s->dct_quantize= dct_quantize_c;
231 s->denoise_dct= denoise_dct_c;
235 MPV_common_init_mmx(s);
238 MPV_common_init_axp(s);
241 MPV_common_init_mlib(s);
244 MPV_common_init_mmi(s);
247 MPV_common_init_armv4l(s);
250 MPV_common_init_ppc(s);
253 #ifdef CONFIG_ENCODERS
254 s->fast_dct_quantize= s->dct_quantize;
256 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
257 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
260 #endif //CONFIG_ENCODERS
262 /* load & permutate scantables
263 note: only wmv uses differnt ones
265 if(s->alternate_scan){
266 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
267 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
269 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
270 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
272 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
273 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
278 static void copy_picture(Picture *dst, Picture *src){
280 dst->type= FF_BUFFER_TYPE_COPY;
283 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
286 dst->pict_type = src->pict_type;
287 dst->quality = src->quality;
288 dst->coded_picture_number = src->coded_picture_number;
289 dst->display_picture_number = src->display_picture_number;
290 // dst->reference = src->reference;
292 dst->interlaced_frame = src->interlaced_frame;
293 dst->top_field_first = src->top_field_first;
295 if(s->avctx->me_threshold){
296 if(!src->motion_val[0])
297 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
299 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
300 if(!src->ref_index[0])
301 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
302 if(src->motion_subsample_log2 != dst->motion_subsample_log2)
303 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesnt match! (%d!=%d)\n",
304 src->motion_subsample_log2, dst->motion_subsample_log2);
306 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
309 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
310 int height= ((16*s->mb_height)>>src->motion_subsample_log2);
312 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
313 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
315 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
316 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
323 * allocates a Picture
324 * The pixels are allocated/set by calling get_buffer() if shared=0
326 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
327 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
328 const int mb_array_size= s->mb_stride*s->mb_height;
329 const int b8_array_size= s->b8_stride*s->mb_height*2;
330 const int b4_array_size= s->b4_stride*s->mb_height*4;
334 assert(pic->data[0]);
335 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
336 pic->type= FF_BUFFER_TYPE_SHARED;
340 assert(!pic->data[0]);
342 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
344 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
345 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
349 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
350 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
354 if(pic->linesize[1] != pic->linesize[2]){
355 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride missmatch)\n");
359 s->linesize = pic->linesize[0];
360 s->uvlinesize= pic->linesize[1];
363 if(pic->qscale_table==NULL){
365 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
366 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
367 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
370 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
371 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
372 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
373 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
374 if(s->out_format == FMT_H264){
376 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+2) * sizeof(int16_t))
377 pic->motion_val[i]= pic->motion_val_base[i]+2;
378 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
380 pic->motion_subsample_log2= 2;
381 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
383 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+2) * sizeof(int16_t))
384 pic->motion_val[i]= pic->motion_val_base[i]+2;
385 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
387 pic->motion_subsample_log2= 3;
389 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
390 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
392 pic->qstride= s->mb_stride;
393 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
396 //it might be nicer if the application would keep track of these but it would require a API change
397 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
398 s->prev_pict_types[0]= s->pict_type;
399 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
400 pic->age= INT_MAX; // skiped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
403 fail: //for the CHECKED_ALLOCZ macro
408 * deallocates a picture
410 static void free_picture(MpegEncContext *s, Picture *pic){
413 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
414 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
417 av_freep(&pic->mb_var);
418 av_freep(&pic->mc_mb_var);
419 av_freep(&pic->mb_mean);
420 av_freep(&pic->mbskip_table);
421 av_freep(&pic->qscale_table);
422 av_freep(&pic->mb_type_base);
423 av_freep(&pic->dct_coeff);
424 av_freep(&pic->pan_scan);
427 av_freep(&pic->motion_val_base[i]);
428 av_freep(&pic->ref_index[i]);
431 if(pic->type == FF_BUFFER_TYPE_SHARED){
440 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
443 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
444 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*17*2); //(width + edge + align)*interlaced*MBsize*tolerance
445 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*17;
447 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
448 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
449 s->rd_scratchpad= s->me.scratchpad;
450 s->b_scratchpad= s->me.scratchpad;
451 s->obmc_scratchpad= s->me.scratchpad + 16;
453 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
454 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
455 if(s->avctx->noise_reduction){
456 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
459 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
460 s->block= s->blocks[0];
463 s->pblocks[i] = (short *)(&s->block[i]);
467 return -1; //free() through MPV_common_end()
470 static void free_duplicate_context(MpegEncContext *s){
473 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
474 av_freep(&s->me.scratchpad);
477 s->obmc_scratchpad= NULL;
479 av_freep(&s->dct_error_sum);
480 av_freep(&s->me.map);
481 av_freep(&s->me.score_map);
482 av_freep(&s->blocks);
486 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
487 #define COPY(a) bak->a= src->a
488 COPY(allocated_edge_emu_buffer);
489 COPY(edge_emu_buffer);
493 COPY(obmc_scratchpad);
500 COPY(me.map_generation);
508 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
511 //FIXME copy only needed parts
513 backup_duplicate_context(&bak, dst);
514 memcpy(dst, src, sizeof(MpegEncContext));
515 backup_duplicate_context(dst, &bak);
517 dst->pblocks[i] = (short *)(&dst->block[i]);
519 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
522 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
523 #define COPY(a) dst->a= src->a
525 COPY(current_picture);
531 COPY(picture_in_gop_number);
532 COPY(gop_picture_number);
533 COPY(frame_pred_frame_dct); //FIXME dont set in encode_header
534 COPY(progressive_frame); //FIXME dont set in encode_header
535 COPY(partitioned_frame); //FIXME dont set in encode_header
540 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
541 * the changed fields will not depend upon the prior state of the MpegEncContext.
543 static void MPV_common_defaults(MpegEncContext *s){
545 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
546 s->chroma_qscale_table= ff_default_chroma_qscale_table;
547 s->progressive_frame= 1;
548 s->progressive_sequence= 1;
549 s->picture_structure= PICT_FRAME;
551 s->coded_picture_number = 0;
552 s->picture_number = 0;
553 s->input_picture_number = 0;
555 s->picture_in_gop_number = 0;
562 * sets the given MpegEncContext to defaults for decoding.
563 * the changed fields will not depend upon the prior state of the MpegEncContext.
565 void MPV_decode_defaults(MpegEncContext *s){
566 MPV_common_defaults(s);
570 * sets the given MpegEncContext to defaults for encoding.
571 * the changed fields will not depend upon the prior state of the MpegEncContext.
574 #ifdef CONFIG_ENCODERS
575 static void MPV_encode_defaults(MpegEncContext *s){
578 MPV_common_defaults(s);
584 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
585 memset(default_mv_penalty, 0, sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1));
586 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
588 for(i=-16; i<16; i++){
589 default_fcode_tab[i + MAX_MV]= 1;
592 s->me.mv_penalty= default_mv_penalty;
593 s->fcode_tab= default_fcode_tab;
595 #endif //CONFIG_ENCODERS
598 * init common structure for both encoder and decoder.
599 * this assumes that some variables like width/height are already set
601 int MPV_common_init(MpegEncContext *s)
603 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
605 if(s->avctx->thread_count > MAX_THREADS || (16*s->avctx->thread_count > s->height && s->height)){
606 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
610 dsputil_init(&s->dsp, s->avctx);
613 s->flags= s->avctx->flags;
614 s->flags2= s->avctx->flags2;
616 s->mb_width = (s->width + 15) / 16;
617 s->mb_height = (s->height + 15) / 16;
618 s->mb_stride = s->mb_width + 1;
619 s->b8_stride = s->mb_width*2 + 1;
620 s->b4_stride = s->mb_width*4 + 1;
621 mb_array_size= s->mb_height * s->mb_stride;
622 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
624 /* set chroma shifts */
625 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
626 &(s->chroma_y_shift) );
628 /* set default edge pos, will be overriden in decode_header if needed */
629 s->h_edge_pos= s->mb_width*16;
630 s->v_edge_pos= s->mb_height*16;
632 s->mb_num = s->mb_width * s->mb_height;
637 s->block_wrap[3]= s->b8_stride;
639 s->block_wrap[5]= s->mb_stride;
641 y_size = s->b8_stride * (2 * s->mb_height + 1);
642 c_size = s->mb_stride * (s->mb_height + 1);
643 yc_size = y_size + 2 * c_size;
645 /* convert fourcc to upper case */
646 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
647 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
648 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
649 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
651 s->avctx->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
652 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
653 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
654 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
656 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
658 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
659 for(y=0; y<s->mb_height; y++){
660 for(x=0; x<s->mb_width; x++){
661 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
664 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
667 /* Allocate MV tables */
668 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
669 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
670 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
671 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
672 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
673 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
674 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
675 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
676 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
677 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
678 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
679 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
681 if(s->msmpeg4_version){
682 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
684 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
686 /* Allocate MB type table */
687 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
689 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
691 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
692 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
693 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
694 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
695 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
696 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
698 if(s->avctx->noise_reduction){
699 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
702 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
704 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
706 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
707 /* interlaced direct mode decoding tables */
712 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
713 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
715 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
716 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
717 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
719 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
722 if (s->out_format == FMT_H263) {
724 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
725 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
726 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
727 s->ac_val[2] = s->ac_val[1] + c_size;
730 CHECKED_ALLOCZ(s->coded_block_base, y_size);
731 s->coded_block= s->coded_block_base + s->b8_stride + 1;
733 /* divx501 bitstream reorder buffer */
734 CHECKED_ALLOCZ(s->bitstream_buffer, BITSTREAM_BUFFER_SIZE);
736 /* cbp, ac_pred, pred_dir */
737 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
738 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
741 if (s->h263_pred || s->h263_plus || !s->encoding) {
743 //MN: we need these for error resilience of intra-frames
744 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
745 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
746 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
747 s->dc_val[2] = s->dc_val[1] + c_size;
748 for(i=0;i<yc_size;i++)
749 s->dc_val_base[i] = 1024;
752 /* which mb is a intra block */
753 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
754 memset(s->mbintra_table, 1, mb_array_size);
756 /* init macroblock skip table */
757 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
758 //Note the +1 is for a quicker mpeg4 slice_end detection
759 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
761 s->parse_context.state= -1;
762 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
763 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
764 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
765 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
768 s->context_initialized = 1;
770 s->thread_context[0]= s;
771 for(i=1; i<s->avctx->thread_count; i++){
772 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
773 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
776 for(i=0; i<s->avctx->thread_count; i++){
777 if(init_duplicate_context(s->thread_context[i], s) < 0)
779 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
780 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
789 /* init common structure for both encoder and decoder */
790 void MPV_common_end(MpegEncContext *s)
794 for(i=0; i<s->avctx->thread_count; i++){
795 free_duplicate_context(s->thread_context[i]);
797 for(i=1; i<s->avctx->thread_count; i++){
798 av_freep(&s->thread_context[i]);
801 av_freep(&s->parse_context.buffer);
802 s->parse_context.buffer_size=0;
804 av_freep(&s->mb_type);
805 av_freep(&s->p_mv_table_base);
806 av_freep(&s->b_forw_mv_table_base);
807 av_freep(&s->b_back_mv_table_base);
808 av_freep(&s->b_bidir_forw_mv_table_base);
809 av_freep(&s->b_bidir_back_mv_table_base);
810 av_freep(&s->b_direct_mv_table_base);
812 s->b_forw_mv_table= NULL;
813 s->b_back_mv_table= NULL;
814 s->b_bidir_forw_mv_table= NULL;
815 s->b_bidir_back_mv_table= NULL;
816 s->b_direct_mv_table= NULL;
820 av_freep(&s->b_field_mv_table_base[i][j][k]);
821 s->b_field_mv_table[i][j][k]=NULL;
823 av_freep(&s->b_field_select_table[i][j]);
824 av_freep(&s->p_field_mv_table_base[i][j]);
825 s->p_field_mv_table[i][j]=NULL;
827 av_freep(&s->p_field_select_table[i]);
830 av_freep(&s->dc_val_base);
831 av_freep(&s->ac_val_base);
832 av_freep(&s->coded_block_base);
833 av_freep(&s->mbintra_table);
834 av_freep(&s->cbp_table);
835 av_freep(&s->pred_dir_table);
837 av_freep(&s->mbskip_table);
838 av_freep(&s->prev_pict_types);
839 av_freep(&s->bitstream_buffer);
840 av_freep(&s->avctx->stats_out);
841 av_freep(&s->ac_stats);
842 av_freep(&s->error_status_table);
843 av_freep(&s->mb_index2xy);
844 av_freep(&s->lambda_table);
845 av_freep(&s->q_intra_matrix);
846 av_freep(&s->q_inter_matrix);
847 av_freep(&s->q_intra_matrix16);
848 av_freep(&s->q_inter_matrix16);
849 av_freep(&s->input_picture);
850 av_freep(&s->reordered_input_picture);
851 av_freep(&s->dct_offset);
854 for(i=0; i<MAX_PICTURE_COUNT; i++){
855 free_picture(s, &s->picture[i]);
858 av_freep(&s->picture);
859 s->context_initialized = 0;
862 s->current_picture_ptr= NULL;
863 s->linesize= s->uvlinesize= 0;
866 av_freep(&s->visualization_buffer[i]);
868 avcodec_default_free_buffers(s->avctx);
871 #ifdef CONFIG_ENCODERS
873 /* init video encoder */
874 int MPV_encode_init(AVCodecContext *avctx)
876 MpegEncContext *s = avctx->priv_data;
878 int chroma_h_shift, chroma_v_shift;
880 MPV_encode_defaults(s);
882 avctx->pix_fmt = PIX_FMT_YUV420P; // FIXME
884 s->bit_rate = avctx->bit_rate;
885 s->width = avctx->width;
886 s->height = avctx->height;
887 if(avctx->gop_size > 600){
888 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
891 s->gop_size = avctx->gop_size;
893 s->flags= avctx->flags;
894 s->flags2= avctx->flags2;
895 s->max_b_frames= avctx->max_b_frames;
896 s->codec_id= avctx->codec->id;
897 s->luma_elim_threshold = avctx->luma_elim_threshold;
898 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
899 s->strict_std_compliance= avctx->strict_std_compliance;
900 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
901 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
902 s->mpeg_quant= avctx->mpeg_quant;
903 s->rtp_mode= !!avctx->rtp_payload_size;
904 s->intra_dc_precision= avctx->intra_dc_precision;
905 s->user_specified_pts = AV_NOPTS_VALUE;
907 if (s->gop_size <= 1) {
914 s->me_method = avctx->me_method;
917 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
919 s->adaptive_quant= ( s->avctx->lumi_masking
920 || s->avctx->dark_masking
921 || s->avctx->temporal_cplx_masking
922 || s->avctx->spatial_cplx_masking
923 || s->avctx->p_masking
924 || (s->flags&CODEC_FLAG_QP_RD))
927 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
928 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
929 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
931 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
932 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
936 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
937 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isnt recommanded!\n");
940 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
941 av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
945 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
946 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
950 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
951 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
952 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
954 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");
957 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
958 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
959 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
963 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
964 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decission\n");
968 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
969 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
973 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
974 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
978 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
979 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
983 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
984 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
988 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
989 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
990 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
994 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
995 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supporetd by codec\n");
999 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1000 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1004 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1005 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1009 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1010 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1014 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1015 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1016 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1017 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1021 if(s->avctx->thread_count > 1)
1024 i= ff_gcd(avctx->frame_rate, avctx->frame_rate_base);
1026 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1027 avctx->frame_rate /= i;
1028 avctx->frame_rate_base /= i;
1032 if(s->codec_id==CODEC_ID_MJPEG){
1033 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1034 s->inter_quant_bias= 0;
1035 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1036 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1037 s->inter_quant_bias= 0;
1039 s->intra_quant_bias=0;
1040 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1043 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1044 s->intra_quant_bias= avctx->intra_quant_bias;
1045 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1046 s->inter_quant_bias= avctx->inter_quant_bias;
1048 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1050 av_reduce(&s->time_increment_resolution, &dummy, s->avctx->frame_rate, s->avctx->frame_rate_base, (1<<16)-1);
1051 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1053 switch(avctx->codec->id) {
1054 case CODEC_ID_MPEG1VIDEO:
1055 s->out_format = FMT_MPEG1;
1056 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1057 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1059 case CODEC_ID_MPEG2VIDEO:
1060 s->out_format = FMT_MPEG1;
1061 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1062 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1065 case CODEC_ID_LJPEG:
1066 case CODEC_ID_MJPEG:
1067 s->out_format = FMT_MJPEG;
1068 s->intra_only = 1; /* force intra only for jpeg */
1069 s->mjpeg_write_tables = 1; /* write all tables */
1070 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1071 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1072 s->mjpeg_vsample[1] = 1;
1073 s->mjpeg_vsample[2] = 1;
1074 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1075 s->mjpeg_hsample[1] = 1;
1076 s->mjpeg_hsample[2] = 1;
1077 if (mjpeg_init(s) < 0)
1084 if (h263_get_picture_format(s->width, s->height) == 7) {
1085 av_log(avctx, AV_LOG_INFO, "Input picture size isn't suitable for h263 codec! try h263+\n");
1088 s->out_format = FMT_H263;
1089 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1093 case CODEC_ID_H263P:
1094 s->out_format = FMT_H263;
1097 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1098 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1099 s->modified_quant= s->h263_aic;
1100 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1101 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1102 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1103 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1104 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1107 /* These are just to be sure */
1112 s->out_format = FMT_H263;
1113 s->h263_flv = 2; /* format = 1; 11-bit codes */
1114 s->unrestricted_mv = 1;
1115 s->rtp_mode=0; /* don't allow GOB */
1120 s->out_format = FMT_H263;
1124 case CODEC_ID_MPEG4:
1125 s->out_format = FMT_H263;
1127 s->unrestricted_mv = 1;
1128 s->low_delay= s->max_b_frames ? 0 : 1;
1129 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1131 case CODEC_ID_MSMPEG4V1:
1132 s->out_format = FMT_H263;
1133 s->h263_msmpeg4 = 1;
1135 s->unrestricted_mv = 1;
1136 s->msmpeg4_version= 1;
1140 case CODEC_ID_MSMPEG4V2:
1141 s->out_format = FMT_H263;
1142 s->h263_msmpeg4 = 1;
1144 s->unrestricted_mv = 1;
1145 s->msmpeg4_version= 2;
1149 case CODEC_ID_MSMPEG4V3:
1150 s->out_format = FMT_H263;
1151 s->h263_msmpeg4 = 1;
1153 s->unrestricted_mv = 1;
1154 s->msmpeg4_version= 3;
1155 s->flipflop_rounding=1;
1160 s->out_format = FMT_H263;
1161 s->h263_msmpeg4 = 1;
1163 s->unrestricted_mv = 1;
1164 s->msmpeg4_version= 4;
1165 s->flipflop_rounding=1;
1170 s->out_format = FMT_H263;
1171 s->h263_msmpeg4 = 1;
1173 s->unrestricted_mv = 1;
1174 s->msmpeg4_version= 5;
1175 s->flipflop_rounding=1;
1184 avctx->has_b_frames= !s->low_delay;
1189 if (MPV_common_init(s) < 0)
1192 if(s->modified_quant)
1193 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1194 s->progressive_frame=
1195 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1196 s->quant_precision=5;
1198 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1200 #ifdef CONFIG_ENCODERS
1202 if (s->out_format == FMT_H263)
1203 h263_encode_init(s);
1204 if(s->msmpeg4_version)
1205 ff_msmpeg4_encode_init(s);
1207 if (s->out_format == FMT_MPEG1)
1208 ff_mpeg1_encode_init(s);
1213 int j= s->dsp.idct_permutation[i];
1215 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1216 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1217 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1218 }else if(s->out_format == FMT_H263){
1219 s->intra_matrix[j] =
1220 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1224 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1225 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1227 if(s->avctx->intra_matrix)
1228 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1229 if(s->avctx->inter_matrix)
1230 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1233 /* precompute matrix */
1234 /* for mjpeg, we do include qscale in the matrix */
1235 if (s->out_format != FMT_MJPEG) {
1236 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1237 s->intra_matrix, s->intra_quant_bias, 1, 31);
1238 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1239 s->inter_matrix, s->inter_quant_bias, 1, 31);
1242 if(ff_rate_control_init(s) < 0)
1248 int MPV_encode_end(AVCodecContext *avctx)
1250 MpegEncContext *s = avctx->priv_data;
1256 ff_rate_control_uninit(s);
1259 if (s->out_format == FMT_MJPEG)
1262 av_freep(&avctx->extradata);
1267 #endif //CONFIG_ENCODERS
1269 void init_rl(RLTable *rl)
1271 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1272 uint8_t index_run[MAX_RUN+1];
1273 int last, run, level, start, end, i;
1275 /* compute max_level[], max_run[] and index_run[] */
1276 for(last=0;last<2;last++) {
1285 memset(max_level, 0, MAX_RUN + 1);
1286 memset(max_run, 0, MAX_LEVEL + 1);
1287 memset(index_run, rl->n, MAX_RUN + 1);
1288 for(i=start;i<end;i++) {
1289 run = rl->table_run[i];
1290 level = rl->table_level[i];
1291 if (index_run[run] == rl->n)
1293 if (level > max_level[run])
1294 max_level[run] = level;
1295 if (run > max_run[level])
1296 max_run[level] = run;
1298 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1299 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1300 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1301 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1302 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1303 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1307 /* draw the edges of width 'w' of an image of size width, height */
1308 //FIXME check that this is ok for mpeg4 interlaced
1309 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1311 uint8_t *ptr, *last_line;
1314 last_line = buf + (height - 1) * wrap;
1316 /* top and bottom */
1317 memcpy(buf - (i + 1) * wrap, buf, width);
1318 memcpy(last_line + (i + 1) * wrap, last_line, width);
1320 /* left and right */
1322 for(i=0;i<height;i++) {
1323 memset(ptr - w, ptr[0], w);
1324 memset(ptr + width, ptr[width-1], w);
1329 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1330 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1331 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1332 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1336 int ff_find_unused_picture(MpegEncContext *s, int shared){
1340 for(i=0; i<MAX_PICTURE_COUNT; i++){
1341 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1344 for(i=0; i<MAX_PICTURE_COUNT; i++){
1345 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1347 for(i=0; i<MAX_PICTURE_COUNT; i++){
1348 if(s->picture[i].data[0]==NULL) return i;
1356 static void update_noise_reduction(MpegEncContext *s){
1359 for(intra=0; intra<2; intra++){
1360 if(s->dct_count[intra] > (1<<16)){
1361 for(i=0; i<64; i++){
1362 s->dct_error_sum[intra][i] >>=1;
1364 s->dct_count[intra] >>= 1;
1367 for(i=0; i<64; i++){
1368 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);
1374 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1376 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1382 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1384 /* mark&release old frames */
1385 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1386 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1388 /* release forgotten pictures */
1389 /* if(mpeg124/h263) */
1391 for(i=0; i<MAX_PICTURE_COUNT; i++){
1392 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1393 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1394 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1401 /* release non refernce frames */
1402 for(i=0; i<MAX_PICTURE_COUNT; i++){
1403 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1404 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1408 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1409 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1411 i= ff_find_unused_picture(s, 0);
1412 pic= (AVFrame*)&s->picture[i];
1415 pic->reference= s->pict_type != B_TYPE && !s->dropable ? 3 : 0;
1417 pic->coded_picture_number= s->coded_picture_number++;
1419 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1422 s->current_picture_ptr= (Picture*)pic;
1423 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1424 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1427 s->current_picture_ptr->pict_type= s->pict_type;
1428 // if(s->flags && CODEC_FLAG_QSCALE)
1429 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1430 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1432 copy_picture(&s->current_picture, s->current_picture_ptr);
1434 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1435 if (s->pict_type != B_TYPE) {
1436 s->last_picture_ptr= s->next_picture_ptr;
1438 s->next_picture_ptr= s->current_picture_ptr;
1440 /* 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,
1441 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1442 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1443 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1444 s->pict_type, s->dropable);*/
1446 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1447 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1449 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1450 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1451 assert(s->pict_type != B_TYPE); //these should have been dropped if we dont have a reference
1455 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1457 if(s->picture_structure!=PICT_FRAME){
1460 if(s->picture_structure == PICT_BOTTOM_FIELD){
1461 s->current_picture.data[i] += s->current_picture.linesize[i];
1463 s->current_picture.linesize[i] *= 2;
1464 s->last_picture.linesize[i] *=2;
1465 s->next_picture.linesize[i] *=2;
1470 s->hurry_up= s->avctx->hurry_up;
1471 s->error_resilience= avctx->error_resilience;
1473 /* set dequantizer, we cant do it during init as it might change for mpeg4
1474 and we cant do it in the header decode as init isnt called for mpeg4 there yet */
1475 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1476 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1477 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1478 }else if(s->out_format == FMT_H263){
1479 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1480 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1481 }else if(s->out_format == FMT_H261){
1482 s->dct_unquantize_intra = s->dct_unquantize_h261_intra;
1483 s->dct_unquantize_inter = s->dct_unquantize_h261_inter;
1485 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1486 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1489 if(s->dct_error_sum){
1490 assert(s->avctx->noise_reduction && s->encoding);
1492 update_noise_reduction(s);
1496 if(s->avctx->xvmc_acceleration)
1497 return XVMC_field_start(s, avctx);
1502 /* generic function for encode/decode called after a frame has been coded/decoded */
1503 void MPV_frame_end(MpegEncContext *s)
1506 /* draw edge for correct motion prediction if outside */
1508 //just to make sure that all data is rendered.
1509 if(s->avctx->xvmc_acceleration){
1513 if(s->unrestricted_mv && s->pict_type != B_TYPE && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1514 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1515 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1516 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1520 s->last_pict_type = s->pict_type;
1521 if(s->pict_type!=B_TYPE){
1522 s->last_non_b_pict_type= s->pict_type;
1525 /* copy back current_picture variables */
1526 for(i=0; i<MAX_PICTURE_COUNT; i++){
1527 if(s->picture[i].data[0] == s->current_picture.data[0]){
1528 s->picture[i]= s->current_picture;
1532 assert(i<MAX_PICTURE_COUNT);
1536 /* release non refernce frames */
1537 for(i=0; i<MAX_PICTURE_COUNT; i++){
1538 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1539 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1543 // clear copies, to avoid confusion
1545 memset(&s->last_picture, 0, sizeof(Picture));
1546 memset(&s->next_picture, 0, sizeof(Picture));
1547 memset(&s->current_picture, 0, sizeof(Picture));
1549 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1553 * draws an line from (ex, ey) -> (sx, sy).
1554 * @param w width of the image
1555 * @param h height of the image
1556 * @param stride stride/linesize of the image
1557 * @param color color of the arrow
1559 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1562 sx= clip(sx, 0, w-1);
1563 sy= clip(sy, 0, h-1);
1564 ex= clip(ex, 0, w-1);
1565 ey= clip(ey, 0, h-1);
1567 buf[sy*stride + sx]+= color;
1569 if(ABS(ex - sx) > ABS(ey - sy)){
1574 buf+= sx + sy*stride;
1576 f= ((ey-sy)<<16)/ex;
1577 for(x= 0; x <= ex; x++){
1580 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1581 buf[(y+1)*stride + x]+= (color* fr )>>16;
1588 buf+= sx + sy*stride;
1590 if(ey) f= ((ex-sx)<<16)/ey;
1592 for(y= 0; y <= ey; y++){
1595 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1596 buf[y*stride + x+1]+= (color* fr )>>16;;
1602 * draws an arrow from (ex, ey) -> (sx, sy).
1603 * @param w width of the image
1604 * @param h height of the image
1605 * @param stride stride/linesize of the image
1606 * @param color color of the arrow
1608 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1611 sx= clip(sx, -100, w+100);
1612 sy= clip(sy, -100, h+100);
1613 ex= clip(ex, -100, w+100);
1614 ey= clip(ey, -100, h+100);
1619 if(dx*dx + dy*dy > 3*3){
1622 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1624 //FIXME subpixel accuracy
1625 rx= ROUNDED_DIV(rx*3<<4, length);
1626 ry= ROUNDED_DIV(ry*3<<4, length);
1628 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1629 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1631 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1635 * prints debuging info for the given picture.
1637 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1639 if(!pict || !pict->mb_type) return;
1641 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1644 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1645 switch (pict->pict_type) {
1646 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1647 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1648 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1649 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1650 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1651 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1653 for(y=0; y<s->mb_height; y++){
1654 for(x=0; x<s->mb_width; x++){
1655 if(s->avctx->debug&FF_DEBUG_SKIP){
1656 int count= s->mbskip_table[x + y*s->mb_stride];
1657 if(count>9) count=9;
1658 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1660 if(s->avctx->debug&FF_DEBUG_QP){
1661 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1663 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1664 int mb_type= pict->mb_type[x + y*s->mb_stride];
1665 //Type & MV direction
1667 av_log(s->avctx, AV_LOG_DEBUG, "P");
1668 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1669 av_log(s->avctx, AV_LOG_DEBUG, "A");
1670 else if(IS_INTRA4x4(mb_type))
1671 av_log(s->avctx, AV_LOG_DEBUG, "i");
1672 else if(IS_INTRA16x16(mb_type))
1673 av_log(s->avctx, AV_LOG_DEBUG, "I");
1674 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1675 av_log(s->avctx, AV_LOG_DEBUG, "d");
1676 else if(IS_DIRECT(mb_type))
1677 av_log(s->avctx, AV_LOG_DEBUG, "D");
1678 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1679 av_log(s->avctx, AV_LOG_DEBUG, "g");
1680 else if(IS_GMC(mb_type))
1681 av_log(s->avctx, AV_LOG_DEBUG, "G");
1682 else if(IS_SKIP(mb_type))
1683 av_log(s->avctx, AV_LOG_DEBUG, "S");
1684 else if(!USES_LIST(mb_type, 1))
1685 av_log(s->avctx, AV_LOG_DEBUG, ">");
1686 else if(!USES_LIST(mb_type, 0))
1687 av_log(s->avctx, AV_LOG_DEBUG, "<");
1689 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1690 av_log(s->avctx, AV_LOG_DEBUG, "X");
1695 av_log(s->avctx, AV_LOG_DEBUG, "+");
1696 else if(IS_16X8(mb_type))
1697 av_log(s->avctx, AV_LOG_DEBUG, "-");
1698 else if(IS_8X16(mb_type))
1699 av_log(s->avctx, AV_LOG_DEBUG, "¦");
1700 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1701 av_log(s->avctx, AV_LOG_DEBUG, " ");
1703 av_log(s->avctx, AV_LOG_DEBUG, "?");
1706 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1707 av_log(s->avctx, AV_LOG_DEBUG, "=");
1709 av_log(s->avctx, AV_LOG_DEBUG, " ");
1711 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1713 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1717 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1718 const int shift= 1 + s->quarter_sample;
1722 int h_chroma_shift, v_chroma_shift;
1723 const int width = s->avctx->width;
1724 const int height= s->avctx->height;
1725 s->low_delay=0; //needed to see the vectors without trashing the buffers
1727 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1729 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1730 pict->data[i]= s->visualization_buffer[i];
1732 pict->type= FF_BUFFER_TYPE_COPY;
1735 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1737 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1738 const int mb_index= mb_x + mb_y*s->mb_stride;
1739 if((s->avctx->debug_mv) && pict->motion_val){
1741 for(type=0; type<3; type++){
1744 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1748 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1752 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1757 if(!USES_LIST(pict->mb_type[mb_index], direction))
1761 if(IS_8X8(pict->mb_type[mb_index])){
1764 int sx= mb_x*16 + 4 + 8*(i&1);
1765 int sy= mb_y*16 + 4 + 8*(i>>1);
1766 int xy= mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*s->b8_stride;
1767 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1768 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1769 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1771 }else if(IS_16X8(pict->mb_type[mb_index])){
1775 int sy=mb_y*16 + 4 + 8*i;
1776 int xy= mb_x*2 + (mb_y*2 + i)*s->b8_stride;
1777 int mx=(pict->motion_val[direction][xy][0]>>shift);
1778 int my=(pict->motion_val[direction][xy][1]>>shift);
1780 if(IS_INTERLACED(pict->mb_type[mb_index]))
1783 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1786 int sx= mb_x*16 + 8;
1787 int sy= mb_y*16 + 8;
1788 int xy= mb_x*2 + mb_y*2*s->b8_stride;
1789 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1790 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1791 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1795 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1796 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1799 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1800 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1803 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1804 int mb_type= pict->mb_type[mb_index];
1807 #define COLOR(theta, r)\
1808 u= (int)(128 + r*cos(theta*3.141592/180));\
1809 v= (int)(128 + r*sin(theta*3.141592/180));
1813 if(IS_PCM(mb_type)){
1815 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1817 }else if(IS_INTRA4x4(mb_type)){
1819 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1821 }else if(IS_DIRECT(mb_type)){
1823 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1825 }else if(IS_GMC(mb_type)){
1827 }else if(IS_SKIP(mb_type)){
1829 }else if(!USES_LIST(mb_type, 1)){
1831 }else if(!USES_LIST(mb_type, 0)){
1834 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1838 u*= 0x0101010101010101ULL;
1839 v*= 0x0101010101010101ULL;
1841 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1842 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1846 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1847 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1848 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1850 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1852 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1855 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1859 s->mbskip_table[mb_index]=0;
1865 #ifdef CONFIG_ENCODERS
1867 static int get_sae(uint8_t *src, int ref, int stride){
1871 for(y=0; y<16; y++){
1872 for(x=0; x<16; x++){
1873 acc+= ABS(src[x+y*stride] - ref);
1880 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
1887 for(y=0; y<h; y+=16){
1888 for(x=0; x<w; x+=16){
1889 int offset= x + y*stride;
1890 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
1891 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
1892 int sae = get_sae(src + offset, mean, stride);
1894 acc+= sae + 500 < sad;
1901 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
1904 const int encoding_delay= s->max_b_frames;
1908 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
1909 if(pic_arg->linesize[0] != s->linesize) direct=0;
1910 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
1911 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
1913 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
1916 i= ff_find_unused_picture(s, 1);
1918 pic= (AVFrame*)&s->picture[i];
1922 pic->data[i]= pic_arg->data[i];
1923 pic->linesize[i]= pic_arg->linesize[i];
1925 alloc_picture(s, (Picture*)pic, 1);
1928 i= ff_find_unused_picture(s, 0);
1930 pic= (AVFrame*)&s->picture[i];
1933 alloc_picture(s, (Picture*)pic, 0);
1935 if( pic->data[0] + offset == pic_arg->data[0]
1936 && pic->data[1] + offset == pic_arg->data[1]
1937 && pic->data[2] + offset == pic_arg->data[2]){
1940 int h_chroma_shift, v_chroma_shift;
1941 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1944 int src_stride= pic_arg->linesize[i];
1945 int dst_stride= i ? s->uvlinesize : s->linesize;
1946 int h_shift= i ? h_chroma_shift : 0;
1947 int v_shift= i ? v_chroma_shift : 0;
1948 int w= s->width >>h_shift;
1949 int h= s->height>>v_shift;
1950 uint8_t *src= pic_arg->data[i];
1951 uint8_t *dst= pic->data[i] + offset;
1953 if(src_stride==dst_stride)
1954 memcpy(dst, src, src_stride*h);
1957 memcpy(dst, src, w);
1965 copy_picture_attributes(s, pic, pic_arg);
1967 pic->display_picture_number= s->input_picture_number++;
1969 if(pic->pts != AV_NOPTS_VALUE){
1970 if(s->user_specified_pts != AV_NOPTS_VALUE){
1971 int64_t time= av_rescale(pic->pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
1972 int64_t last= av_rescale(s->user_specified_pts, s->avctx->frame_rate, s->avctx->frame_rate_base*(int64_t)AV_TIME_BASE);
1975 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%Ld, last=%Ld\n", pic->pts, s->user_specified_pts);
1979 s->user_specified_pts= pic->pts;
1981 if(s->user_specified_pts != AV_NOPTS_VALUE){
1982 s->user_specified_pts=
1983 pic->pts= s->user_specified_pts + AV_TIME_BASE*(int64_t)s->avctx->frame_rate_base / s->avctx->frame_rate;
1984 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%Ld)\n", pic->pts);
1986 pic->pts= av_rescale(pic->display_picture_number*(int64_t)s->avctx->frame_rate_base, AV_TIME_BASE, s->avctx->frame_rate);
1991 /* shift buffer entries */
1992 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
1993 s->input_picture[i-1]= s->input_picture[i];
1995 s->input_picture[encoding_delay]= (Picture*)pic;
2000 static void select_input_picture(MpegEncContext *s){
2003 for(i=1; i<MAX_PICTURE_COUNT; i++)
2004 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2005 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2007 /* set next picture types & ordering */
2008 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2009 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2010 s->reordered_input_picture[0]= s->input_picture[0];
2011 s->reordered_input_picture[0]->pict_type= I_TYPE;
2012 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2016 if(s->flags&CODEC_FLAG_PASS2){
2017 for(i=0; i<s->max_b_frames+1; i++){
2018 int pict_num= s->input_picture[0]->display_picture_number + i;
2019 int pict_type= s->rc_context.entry[pict_num].new_pict_type;
2020 s->input_picture[i]->pict_type= pict_type;
2022 if(i + 1 >= s->rc_context.num_entries) break;
2026 if(s->input_picture[0]->pict_type){
2027 /* user selected pict_type */
2028 for(b_frames=0; b_frames<s->max_b_frames+1; b_frames++){
2029 if(s->input_picture[b_frames]->pict_type!=B_TYPE) break;
2032 if(b_frames > s->max_b_frames){
2033 av_log(s->avctx, AV_LOG_ERROR, "warning, too many bframes in a row\n");
2034 b_frames = s->max_b_frames;
2036 }else if(s->avctx->b_frame_strategy==0){
2037 b_frames= s->max_b_frames;
2038 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2039 }else if(s->avctx->b_frame_strategy==1){
2040 for(i=1; i<s->max_b_frames+1; i++){
2041 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2042 s->input_picture[i]->b_frame_score=
2043 get_intra_count(s, s->input_picture[i ]->data[0],
2044 s->input_picture[i-1]->data[0], s->linesize) + 1;
2047 for(i=0; i<s->max_b_frames; i++){
2048 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/40) break;
2051 b_frames= FFMAX(0, i-1);
2054 for(i=0; i<b_frames+1; i++){
2055 s->input_picture[i]->b_frame_score=0;
2058 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2063 //static int b_count=0;
2064 //b_count+= b_frames;
2065 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2066 if(s->picture_in_gop_number + b_frames >= s->gop_size){
2067 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2069 s->input_picture[b_frames]->pict_type= I_TYPE;
2072 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2074 && s->input_picture[b_frames]->pict_type== I_TYPE)
2077 s->reordered_input_picture[0]= s->input_picture[b_frames];
2078 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2079 s->reordered_input_picture[0]->pict_type= P_TYPE;
2080 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2081 for(i=0; i<b_frames; i++){
2082 s->reordered_input_picture[i+1]= s->input_picture[i];
2083 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2084 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2089 if(s->reordered_input_picture[0]){
2090 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2092 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2094 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2095 // input is a shared pix, so we cant modifiy it -> alloc a new one & ensure that the shared one is reuseable
2097 int i= ff_find_unused_picture(s, 0);
2098 Picture *pic= &s->picture[i];
2100 /* mark us unused / free shared pic */
2102 s->reordered_input_picture[0]->data[i]= NULL;
2103 s->reordered_input_picture[0]->type= 0;
2105 pic->reference = s->reordered_input_picture[0]->reference;
2107 alloc_picture(s, pic, 0);
2109 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2111 s->current_picture_ptr= pic;
2113 // input is not a shared pix -> reuse buffer for current_pix
2115 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2116 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2118 s->current_picture_ptr= s->reordered_input_picture[0];
2120 s->new_picture.data[i]+=16;
2123 copy_picture(&s->current_picture, s->current_picture_ptr);
2125 s->picture_number= s->new_picture.display_picture_number;
2126 //printf("dpn:%d\n", s->picture_number);
2128 memset(&s->new_picture, 0, sizeof(Picture));
2132 int MPV_encode_picture(AVCodecContext *avctx,
2133 unsigned char *buf, int buf_size, void *data)
2135 MpegEncContext *s = avctx->priv_data;
2136 AVFrame *pic_arg = data;
2137 int i, stuffing_count;
2139 if(avctx->pix_fmt != PIX_FMT_YUV420P){
2140 av_log(avctx, AV_LOG_ERROR, "this codec supports only YUV420P\n");
2144 for(i=0; i<avctx->thread_count; i++){
2145 int start_y= s->thread_context[i]->start_mb_y;
2146 int end_y= s->thread_context[i]-> end_mb_y;
2147 int h= s->mb_height;
2148 uint8_t *start= buf + buf_size*start_y/h;
2149 uint8_t *end = buf + buf_size* end_y/h;
2151 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2154 s->picture_in_gop_number++;
2156 if(load_input_picture(s, pic_arg) < 0)
2159 select_input_picture(s);
2162 if(s->new_picture.data[0]){
2163 s->pict_type= s->new_picture.pict_type;
2165 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2166 MPV_frame_start(s, avctx);
2168 encode_picture(s, s->picture_number);
2170 avctx->real_pict_num = s->picture_number;
2171 avctx->header_bits = s->header_bits;
2172 avctx->mv_bits = s->mv_bits;
2173 avctx->misc_bits = s->misc_bits;
2174 avctx->i_tex_bits = s->i_tex_bits;
2175 avctx->p_tex_bits = s->p_tex_bits;
2176 avctx->i_count = s->i_count;
2177 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2178 avctx->skip_count = s->skip_count;
2182 if (s->out_format == FMT_MJPEG)
2183 mjpeg_picture_trailer(s);
2185 if(s->flags&CODEC_FLAG_PASS1)
2186 ff_write_pass1_stats(s);
2189 avctx->error[i] += s->current_picture_ptr->error[i];
2192 flush_put_bits(&s->pb);
2193 s->frame_bits = put_bits_count(&s->pb);
2195 stuffing_count= ff_vbv_update(s, s->frame_bits);
2197 switch(s->codec_id){
2198 case CODEC_ID_MPEG1VIDEO:
2199 case CODEC_ID_MPEG2VIDEO:
2200 while(stuffing_count--){
2201 put_bits(&s->pb, 8, 0);
2204 case CODEC_ID_MPEG4:
2205 put_bits(&s->pb, 16, 0);
2206 put_bits(&s->pb, 16, 0x1C3);
2207 stuffing_count -= 4;
2208 while(stuffing_count--){
2209 put_bits(&s->pb, 8, 0xFF);
2213 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2215 flush_put_bits(&s->pb);
2216 s->frame_bits = put_bits_count(&s->pb);
2219 /* update mpeg1/2 vbv_delay for CBR */
2220 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2221 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2224 assert(s->repeat_first_field==0);
2226 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2227 assert(vbv_delay < 0xFFFF);
2229 s->vbv_delay_ptr[0] &= 0xF8;
2230 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2231 s->vbv_delay_ptr[1] = vbv_delay>>5;
2232 s->vbv_delay_ptr[2] &= 0x07;
2233 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2235 s->total_bits += s->frame_bits;
2236 avctx->frame_bits = s->frame_bits;
2238 assert((pbBufPtr(&s->pb) == s->pb.buf));
2241 assert((s->frame_bits&7)==0);
2243 return s->frame_bits/8;
2246 #endif //CONFIG_ENCODERS
2248 static inline void gmc1_motion(MpegEncContext *s,
2249 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2250 uint8_t **ref_picture)
2253 int offset, src_x, src_y, linesize, uvlinesize;
2254 int motion_x, motion_y;
2257 motion_x= s->sprite_offset[0][0];
2258 motion_y= s->sprite_offset[0][1];
2259 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2260 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2261 motion_x<<=(3-s->sprite_warping_accuracy);
2262 motion_y<<=(3-s->sprite_warping_accuracy);
2263 src_x = clip(src_x, -16, s->width);
2264 if (src_x == s->width)
2266 src_y = clip(src_y, -16, s->height);
2267 if (src_y == s->height)
2270 linesize = s->linesize;
2271 uvlinesize = s->uvlinesize;
2273 ptr = ref_picture[0] + (src_y * linesize) + src_x;
2275 if(s->flags&CODEC_FLAG_EMU_EDGE){
2276 if( (unsigned)src_x >= s->h_edge_pos - 17
2277 || (unsigned)src_y >= s->v_edge_pos - 17){
2278 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2279 ptr= s->edge_emu_buffer;
2283 if((motion_x|motion_y)&7){
2284 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2285 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2289 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2290 if (s->no_rounding){
2291 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2293 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2297 if(s->flags&CODEC_FLAG_GRAY) return;
2299 motion_x= s->sprite_offset[1][0];
2300 motion_y= s->sprite_offset[1][1];
2301 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2302 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2303 motion_x<<=(3-s->sprite_warping_accuracy);
2304 motion_y<<=(3-s->sprite_warping_accuracy);
2305 src_x = clip(src_x, -8, s->width>>1);
2306 if (src_x == s->width>>1)
2308 src_y = clip(src_y, -8, s->height>>1);
2309 if (src_y == s->height>>1)
2312 offset = (src_y * uvlinesize) + src_x;
2313 ptr = ref_picture[1] + offset;
2314 if(s->flags&CODEC_FLAG_EMU_EDGE){
2315 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2316 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2317 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);
2318 ptr= s->edge_emu_buffer;
2322 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2324 ptr = ref_picture[2] + offset;
2326 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);
2327 ptr= s->edge_emu_buffer;
2329 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2334 static inline void gmc_motion(MpegEncContext *s,
2335 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2336 uint8_t **ref_picture)
2339 int linesize, uvlinesize;
2340 const int a= s->sprite_warping_accuracy;
2343 linesize = s->linesize;
2344 uvlinesize = s->uvlinesize;
2346 ptr = ref_picture[0];
2348 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2349 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2351 s->dsp.gmc(dest_y, ptr, linesize, 16,
2354 s->sprite_delta[0][0], s->sprite_delta[0][1],
2355 s->sprite_delta[1][0], s->sprite_delta[1][1],
2356 a+1, (1<<(2*a+1)) - s->no_rounding,
2357 s->h_edge_pos, s->v_edge_pos);
2358 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2359 ox + s->sprite_delta[0][0]*8,
2360 oy + s->sprite_delta[1][0]*8,
2361 s->sprite_delta[0][0], s->sprite_delta[0][1],
2362 s->sprite_delta[1][0], s->sprite_delta[1][1],
2363 a+1, (1<<(2*a+1)) - s->no_rounding,
2364 s->h_edge_pos, s->v_edge_pos);
2366 if(s->flags&CODEC_FLAG_GRAY) return;
2368 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2369 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2371 ptr = ref_picture[1];
2372 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2375 s->sprite_delta[0][0], s->sprite_delta[0][1],
2376 s->sprite_delta[1][0], s->sprite_delta[1][1],
2377 a+1, (1<<(2*a+1)) - s->no_rounding,
2378 s->h_edge_pos>>1, s->v_edge_pos>>1);
2380 ptr = ref_picture[2];
2381 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2384 s->sprite_delta[0][0], s->sprite_delta[0][1],
2385 s->sprite_delta[1][0], s->sprite_delta[1][1],
2386 a+1, (1<<(2*a+1)) - s->no_rounding,
2387 s->h_edge_pos>>1, s->v_edge_pos>>1);
2391 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2392 * @param buf destination buffer
2393 * @param src source buffer
2394 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2395 * @param block_w width of block
2396 * @param block_h height of block
2397 * @param src_x x coordinate of the top left sample of the block in the source buffer
2398 * @param src_y y coordinate of the top left sample of the block in the source buffer
2399 * @param w width of the source buffer
2400 * @param h height of the source buffer
2402 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2403 int src_x, int src_y, int w, int h){
2405 int start_y, start_x, end_y, end_x;
2408 src+= (h-1-src_y)*linesize;
2410 }else if(src_y<=-block_h){
2411 src+= (1-block_h-src_y)*linesize;
2417 }else if(src_x<=-block_w){
2418 src+= (1-block_w-src_x);
2422 start_y= FFMAX(0, -src_y);
2423 start_x= FFMAX(0, -src_x);
2424 end_y= FFMIN(block_h, h-src_y);
2425 end_x= FFMIN(block_w, w-src_x);
2427 // copy existing part
2428 for(y=start_y; y<end_y; y++){
2429 for(x=start_x; x<end_x; x++){
2430 buf[x + y*linesize]= src[x + y*linesize];
2435 for(y=0; y<start_y; y++){
2436 for(x=start_x; x<end_x; x++){
2437 buf[x + y*linesize]= buf[x + start_y*linesize];
2442 for(y=end_y; y<block_h; y++){
2443 for(x=start_x; x<end_x; x++){
2444 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2448 for(y=0; y<block_h; y++){
2450 for(x=0; x<start_x; x++){
2451 buf[x + y*linesize]= buf[start_x + y*linesize];
2455 for(x=end_x; x<block_w; x++){
2456 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2461 static inline int hpel_motion(MpegEncContext *s,
2462 uint8_t *dest, uint8_t *src,
2463 int field_based, int field_select,
2464 int src_x, int src_y,
2465 int width, int height, int stride,
2466 int h_edge_pos, int v_edge_pos,
2467 int w, int h, op_pixels_func *pix_op,
2468 int motion_x, int motion_y)
2473 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2474 src_x += motion_x >> 1;
2475 src_y += motion_y >> 1;
2477 /* WARNING: do no forget half pels */
2478 src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2481 src_y = clip(src_y, -16, height);
2482 if (src_y == height)
2484 src += src_y * stride + src_x;
2486 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2487 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2488 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2489 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2490 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2491 src= s->edge_emu_buffer;
2497 pix_op[dxy](dest, src, stride, h);
2501 /* apply one mpeg motion vector to the three components */
2502 static always_inline void mpeg_motion(MpegEncContext *s,
2503 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2504 int field_based, int bottom_field, int field_select,
2505 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2506 int motion_x, int motion_y, int h)
2508 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2509 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2512 if(s->quarter_sample)
2519 v_edge_pos = s->v_edge_pos >> field_based;
2520 linesize = s->current_picture.linesize[0] << field_based;
2521 uvlinesize = s->current_picture.linesize[1] << field_based;
2523 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2524 src_x = s->mb_x* 16 + (motion_x >> 1);
2525 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2527 if (s->out_format == FMT_H263) {
2528 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2529 mx = (motion_x>>1)|(motion_x&1);
2531 uvdxy = ((my & 1) << 1) | (mx & 1);
2532 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2533 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2535 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2539 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2543 uvsrc_x = s->mb_x*8 + mx;
2544 uvsrc_y = s->mb_y*8 + my;
2546 if(s->chroma_y_shift){
2549 uvdxy = ((my & 1) << 1) | (mx & 1);
2550 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2551 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2553 if(s->chroma_x_shift){
2556 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2557 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2568 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2569 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2570 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2572 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2573 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2574 if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2575 s->codec_id == CODEC_ID_MPEG1VIDEO){
2576 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2579 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2580 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2581 ptr_y = s->edge_emu_buffer;
2582 if(!(s->flags&CODEC_FLAG_GRAY)){
2583 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2584 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2585 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2586 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2587 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2593 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2594 dest_y += s->linesize;
2595 dest_cb+= s->uvlinesize;
2596 dest_cr+= s->uvlinesize;
2600 ptr_y += s->linesize;
2601 ptr_cb+= s->uvlinesize;
2602 ptr_cr+= s->uvlinesize;
2605 pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2607 if(!(s->flags&CODEC_FLAG_GRAY)){
2608 pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2609 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2613 /* apply one mpeg motion vector to the three components */
2614 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
2615 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2616 int field_based, int bottom_field, int field_select,
2617 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
2618 int motion_x, int motion_y, int h)
2620 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2621 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
2622 const int lowres= s->avctx->lowres;
2623 const int block_s= 8>>lowres;
2624 const int s_mask= (2<<lowres)-1;
2625 const int h_edge_pos = s->h_edge_pos >> lowres;
2626 const int v_edge_pos = s->v_edge_pos >> lowres;
2627 linesize = s->current_picture.linesize[0] << field_based;
2628 uvlinesize = s->current_picture.linesize[1] << field_based;
2630 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
2636 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
2639 sx= motion_x & s_mask;
2640 sy= motion_y & s_mask;
2641 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
2642 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
2644 if (s->out_format == FMT_H263) {
2645 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
2646 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
2649 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2652 uvsx = (2*mx) & s_mask;
2653 uvsy = (2*my) & s_mask;
2654 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
2655 uvsrc_y = s->mb_y*block_s + (my >> lowres);
2661 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
2662 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
2665 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2666 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2667 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2669 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
2670 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2671 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2672 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2673 ptr_y = s->edge_emu_buffer;
2674 if(!(s->flags&CODEC_FLAG_GRAY)){
2675 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2676 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2677 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2678 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2679 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
2685 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2686 dest_y += s->linesize;
2687 dest_cb+= s->uvlinesize;
2688 dest_cr+= s->uvlinesize;
2692 ptr_y += s->linesize;
2693 ptr_cb+= s->uvlinesize;
2694 ptr_cr+= s->uvlinesize;
2699 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
2701 if(!(s->flags&CODEC_FLAG_GRAY)){
2702 uvsx <<= 2 - lowres;
2703 uvsy <<= 2 - lowres;
2704 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2705 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2709 //FIXME move to dsputil, avg variant, 16x16 version
2710 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
2712 uint8_t * const top = src[1];
2713 uint8_t * const left = src[2];
2714 uint8_t * const mid = src[0];
2715 uint8_t * const right = src[3];
2716 uint8_t * const bottom= src[4];
2717 #define OBMC_FILTER(x, t, l, m, r, b)\
2718 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
2719 #define OBMC_FILTER4(x, t, l, m, r, b)\
2720 OBMC_FILTER(x , t, l, m, r, b);\
2721 OBMC_FILTER(x+1 , t, l, m, r, b);\
2722 OBMC_FILTER(x +stride, t, l, m, r, b);\
2723 OBMC_FILTER(x+1+stride, t, l, m, r, b);
2726 OBMC_FILTER (x , 2, 2, 4, 0, 0);
2727 OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
2728 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
2729 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
2730 OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
2731 OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
2733 OBMC_FILTER (x , 1, 2, 5, 0, 0);
2734 OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
2735 OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
2736 OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
2738 OBMC_FILTER4(x , 1, 2, 5, 0, 0);
2739 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
2740 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
2741 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
2743 OBMC_FILTER4(x , 0, 2, 5, 0, 1);
2744 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
2745 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
2746 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
2748 OBMC_FILTER (x , 0, 2, 5, 0, 1);
2749 OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
2750 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
2751 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
2752 OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
2753 OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
2755 OBMC_FILTER (x , 0, 2, 4, 0, 2);
2756 OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
2757 OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
2758 OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
2761 /* obmc for 1 8x8 luma block */
2762 static inline void obmc_motion(MpegEncContext *s,
2763 uint8_t *dest, uint8_t *src,
2764 int src_x, int src_y,
2765 op_pixels_func *pix_op,
2766 int16_t mv[5][2]/* mid top left right bottom*/)
2772 assert(s->quarter_sample==0);
2775 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
2778 ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
2779 hpel_motion(s, ptr[i], src, 0, 0,
2781 s->width, s->height, s->linesize,
2782 s->h_edge_pos, s->v_edge_pos,
2784 mv[i][0], mv[i][1]);
2788 put_obmc(dest, ptr, s->linesize);
2791 static inline void qpel_motion(MpegEncContext *s,
2792 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2793 int field_based, int bottom_field, int field_select,
2794 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2795 qpel_mc_func (*qpix_op)[16],
2796 int motion_x, int motion_y, int h)
2798 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2799 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
2801 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
2802 src_x = s->mb_x * 16 + (motion_x >> 2);
2803 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
2805 v_edge_pos = s->v_edge_pos >> field_based;
2806 linesize = s->linesize << field_based;
2807 uvlinesize = s->uvlinesize << field_based;
2812 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
2813 static const int rtab[8]= {0,0,1,1,0,0,0,1};
2814 mx= (motion_x>>1) + rtab[motion_x&7];
2815 my= (motion_y>>1) + rtab[motion_y&7];
2816 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
2817 mx= (motion_x>>1)|(motion_x&1);
2818 my= (motion_y>>1)|(motion_y&1);
2826 uvdxy= (mx&1) | ((my&1)<<1);
2830 uvsrc_x = s->mb_x * 8 + mx;
2831 uvsrc_y = s->mb_y * (8 >> field_based) + my;
2833 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2834 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2835 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2837 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
2838 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
2839 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2840 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2841 ptr_y= s->edge_emu_buffer;
2842 if(!(s->flags&CODEC_FLAG_GRAY)){
2843 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
2844 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
2845 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2846 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
2847 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2854 qpix_op[0][dxy](dest_y, ptr_y, linesize);
2857 dest_y += s->linesize;
2858 dest_cb+= s->uvlinesize;
2859 dest_cr+= s->uvlinesize;
2863 ptr_y += s->linesize;
2864 ptr_cb += s->uvlinesize;
2865 ptr_cr += s->uvlinesize;
2867 //damn interlaced mode
2868 //FIXME boundary mirroring is not exactly correct here
2869 qpix_op[1][dxy](dest_y , ptr_y , linesize);
2870 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
2872 if(!(s->flags&CODEC_FLAG_GRAY)){
2873 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
2874 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
2878 inline int ff_h263_round_chroma(int x){
2880 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2883 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
2888 * h263 chorma 4mv motion compensation.
2890 static inline void chroma_4mv_motion(MpegEncContext *s,
2891 uint8_t *dest_cb, uint8_t *dest_cr,
2892 uint8_t **ref_picture,
2893 op_pixels_func *pix_op,
2895 int dxy, emu=0, src_x, src_y, offset;
2898 /* In case of 8X8, we construct a single chroma motion vector
2899 with a special rounding */
2900 mx= ff_h263_round_chroma(mx);
2901 my= ff_h263_round_chroma(my);
2903 dxy = ((my & 1) << 1) | (mx & 1);
2907 src_x = s->mb_x * 8 + mx;
2908 src_y = s->mb_y * 8 + my;
2909 src_x = clip(src_x, -8, s->width/2);
2910 if (src_x == s->width/2)
2912 src_y = clip(src_y, -8, s->height/2);
2913 if (src_y == s->height/2)
2916 offset = (src_y * (s->uvlinesize)) + src_x;
2917 ptr = ref_picture[1] + offset;
2918 if(s->flags&CODEC_FLAG_EMU_EDGE){
2919 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
2920 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
2921 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);
2922 ptr= s->edge_emu_buffer;
2926 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
2928 ptr = ref_picture[2] + offset;
2930 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);
2931 ptr= s->edge_emu_buffer;
2933 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
2937 * motion compesation of a single macroblock
2939 * @param dest_y luma destination pointer
2940 * @param dest_cb chroma cb/u destination pointer
2941 * @param dest_cr chroma cr/v destination pointer
2942 * @param dir direction (0->forward, 1->backward)
2943 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2944 * @param pic_op halfpel motion compensation function (average or put normally)
2945 * @param pic_op qpel motion compensation function (average or put normally)
2946 * the motion vectors are taken from s->mv and the MV type from s->mv_type
2948 static inline void MPV_motion(MpegEncContext *s,
2949 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2950 int dir, uint8_t **ref_picture,
2951 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
2953 int dxy, mx, my, src_x, src_y, motion_x, motion_y;
2955 uint8_t *ptr, *dest;
2960 if(s->obmc && s->pict_type != B_TYPE){
2961 int16_t mv_cache[4][4][2];
2962 const int xy= s->mb_x + s->mb_y*s->mb_stride;
2963 const int mot_stride= s->b8_stride;
2964 const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
2966 assert(!s->mb_skiped);
2968 memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy ], sizeof(int16_t)*4);
2969 memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2970 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
2972 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
2973 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
2975 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
2978 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
2979 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
2980 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
2982 *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
2983 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
2986 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
2987 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
2988 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
2990 *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
2991 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
2997 const int x= (i&1)+1;
2998 const int y= (i>>1)+1;
3000 {mv_cache[y][x ][0], mv_cache[y][x ][1]},
3001 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3002 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3003 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3004 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3006 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3008 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3015 if(!(s->flags&CODEC_FLAG_GRAY))
3016 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3021 switch(s->mv_type) {
3025 if(s->real_sprite_warping_points==1){
3026 gmc1_motion(s, dest_y, dest_cb, dest_cr,
3029 gmc_motion(s, dest_y, dest_cb, dest_cr,
3032 }else if(s->quarter_sample){
3033 qpel_motion(s, dest_y, dest_cb, dest_cr,
3035 ref_picture, pix_op, qpix_op,
3036 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3038 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3039 ref_picture, pix_op,
3040 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3044 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3046 ref_picture, pix_op,
3047 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3053 if(s->quarter_sample){
3055 motion_x = s->mv[dir][i][0];
3056 motion_y = s->mv[dir][i][1];
3058 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3059 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3060 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3062 /* WARNING: do no forget half pels */
3063 src_x = clip(src_x, -16, s->width);
3064 if (src_x == s->width)
3066 src_y = clip(src_y, -16, s->height);
3067 if (src_y == s->height)
3070 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3071 if(s->flags&CODEC_FLAG_EMU_EDGE){
3072 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3073 || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3074 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);
3075 ptr= s->edge_emu_buffer;
3078 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3079 qpix_op[1][dxy](dest, ptr, s->linesize);
3081 mx += s->mv[dir][i][0]/2;
3082 my += s->mv[dir][i][1]/2;
3086 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3087 ref_picture[0], 0, 0,
3088 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3089 s->width, s->height, s->linesize,
3090 s->h_edge_pos, s->v_edge_pos,
3092 s->mv[dir][i][0], s->mv[dir][i][1]);
3094 mx += s->mv[dir][i][0];
3095 my += s->mv[dir][i][1];
3099 if(!(s->flags&CODEC_FLAG_GRAY))
3100 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3103 if (s->picture_structure == PICT_FRAME) {
3104 if(s->quarter_sample){
3106 qpel_motion(s, dest_y, dest_cb, dest_cr,
3107 1, i, s->field_select[dir][i],
3108 ref_picture, pix_op, qpix_op,
3109 s->mv[dir][i][0], s->mv[dir][i][1], 8);
3113 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3114 1, 0, s->field_select[dir][0],
3115 ref_picture, pix_op,
3116 s->mv[dir][0][0], s->mv[dir][0][1], 8);
3118 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3119 1, 1, s->field_select[dir][1],
3120 ref_picture, pix_op,
3121 s->mv[dir][1][0], s->mv[dir][1][1], 8);
3124 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3125 ref_picture= s->current_picture_ptr->data;
3128 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3129 0, 0, s->field_select[dir][0],
3130 ref_picture, pix_op,
3131 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3136 uint8_t ** ref2picture;
3138 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3139 ref2picture= ref_picture;
3141 ref2picture= s->current_picture_ptr->data;
3144 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3145 0, 0, s->field_select[dir][i],
3146 ref2picture, pix_op,
3147 s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3149 dest_y += 16*s->linesize;
3150 dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3151 dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3155 if(s->picture_structure == PICT_FRAME){
3159 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3161 ref_picture, pix_op,
3162 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3164 pix_op = s->dsp.avg_pixels_tab;
3168 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3169 0, 0, s->picture_structure != i+1,
3170 ref_picture, pix_op,
3171 s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3173 // after put we make avg of the same block
3174 pix_op=s->dsp.avg_pixels_tab;
3176 //opposite parity is always in the same frame if this is second field
3177 if(!s->first_field){
3178 ref_picture = s->current_picture_ptr->data;
3188 * motion compesation of a single macroblock
3190 * @param dest_y luma destination pointer
3191 * @param dest_cb chroma cb/u destination pointer
3192 * @param dest_cr chroma cr/v destination pointer
3193 * @param dir direction (0->forward, 1->backward)
3194 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3195 * @param pic_op halfpel motion compensation function (average or put normally)
3196 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3198 static inline void MPV_motion_lowres(MpegEncContext *s,
3199 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3200 int dir, uint8_t **ref_picture,
3201 h264_chroma_mc_func *pix_op)
3203 int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3205 uint8_t *ptr, *dest;
3206 const int lowres= s->avctx->lowres;
3207 const int block_s= 8>>lowres;
3212 switch(s->mv_type) {
3214 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3216 ref_picture, pix_op,
3217 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3219 /* case MV_TYPE_8X8:
3223 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3224 ref_picture[0], 0, 0,
3225 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3226 s->width, s->height, s->linesize,
3227 s->h_edge_pos, s->v_edge_pos,
3229 s->mv[dir][i][0], s->mv[dir][i][1]);
3231 mx += s->mv[dir][i][0];
3232 my += s->mv[dir][i][1];
3235 if(!(s->flags&CODEC_FLAG_GRAY))
3236 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3239 if (s->picture_structure == PICT_FRAME) {
3241 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3242 1, 0, s->field_select[dir][0],
3243 ref_picture, pix_op,
3244 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3246 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3247 1, 1, s->field_select[dir][1],
3248 ref_picture, pix_op,
3249 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3251 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3252 ref_picture= s->current_picture_ptr->data;
3255 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3256 0, 0, s->field_select[dir][0],
3257 ref_picture, pix_op,
3258 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3263 uint8_t ** ref2picture;
3265 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3266 ref2picture= ref_picture;
3268 ref2picture= s->current_picture_ptr->data;
3271 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3272 0, 0, s->field_select[dir][i],
3273 ref2picture, pix_op,
3274 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3276 dest_y += 2*block_s*s->linesize;
3277 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3278 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3282 if(s->picture_structure == PICT_FRAME){
3286 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3288 ref_picture, pix_op,
3289 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3291 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3295 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3296 0, 0, s->picture_structure != i+1,
3297 ref_picture, pix_op,
3298 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3300 // after put we make avg of the same block
3301 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3303 //opposite parity is always in the same frame if this is second field
3304 if(!s->first_field){
3305 ref_picture = s->current_picture_ptr->data;
3314 /* put block[] to dest[] */
3315 static inline void put_dct(MpegEncContext *s,
3316 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3318 s->dct_unquantize_intra(s, block, i, qscale);
3319 s->dsp.idct_put (dest, line_size, block);
3322 /* add block[] to dest[] */
3323 static inline void add_dct(MpegEncContext *s,
3324 DCTELEM *block, int i, uint8_t *dest, int line_size)
3326 if (s->block_last_index[i] >= 0) {
3327 s->dsp.idct_add (dest, line_size, block);
3331 static inline void add_dequant_dct(MpegEncContext *s,
3332 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3334 if (s->block_last_index[i] >= 0) {
3335 s->dct_unquantize_inter(s, block, i, qscale);
3337 s->dsp.idct_add (dest, line_size, block);
3342 * cleans dc, ac, coded_block for the current non intra MB
3344 void ff_clean_intra_table_entries(MpegEncContext *s)
3346 int wrap = s->b8_stride;
3347 int xy = s->block_index[0];
3350 s->dc_val[0][xy + 1 ] =
3351 s->dc_val[0][xy + wrap] =
3352 s->dc_val[0][xy + 1 + wrap] = 1024;
3354 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
3355 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3356 if (s->msmpeg4_version>=3) {
3357 s->coded_block[xy ] =
3358 s->coded_block[xy + 1 ] =
3359 s->coded_block[xy + wrap] =
3360 s->coded_block[xy + 1 + wrap] = 0;
3363 wrap = s->mb_stride;
3364 xy = s->mb_x + s->mb_y * wrap;
3366 s->dc_val[2][xy] = 1024;
3368 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3369 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3371 s->mbintra_table[xy]= 0;
3374 /* generic function called after a macroblock has been parsed by the
3375 decoder or after it has been encoded by the encoder.
3377 Important variables used:
3378 s->mb_intra : true if intra macroblock
3379 s->mv_dir : motion vector direction
3380 s->mv_type : motion vector type
3381 s->mv : motion vector
3382 s->interlaced_dct : true if interlaced dct used (mpeg2)
3384 static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3387 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3389 if(s->avctx->xvmc_acceleration){
3390 XVMC_decode_mb(s);//xvmc uses pblocks
3398 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3399 /* save DCT coefficients */
3401 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3404 *dct++ = block[i][s->dsp.idct_permutation[j]];
3407 s->current_picture.qscale_table[mb_xy]= s->qscale;
3409 /* update DC predictors for P macroblocks */
3411 if (s->h263_pred || s->h263_aic) {
3412 if(s->mbintra_table[mb_xy])
3413 ff_clean_intra_table_entries(s);
3417 s->last_dc[2] = 128 << s->intra_dc_precision;
3420 else if (s->h263_pred || s->h263_aic)
3421 s->mbintra_table[mb_xy]=1;
3423 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3424 uint8_t *dest_y, *dest_cb, *dest_cr;
3425 int dct_linesize, dct_offset;
3426 op_pixels_func (*op_pix)[4];
3427 qpel_mc_func (*op_qpix)[16];
3428 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3429 const int uvlinesize= s->current_picture.linesize[1];
3430 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3431 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3433 /* avoid copy if macroblock skipped in last frame too */
3434 /* skip only during decoding as we might trash the buffers during encoding a bit */
3436 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3437 const int age= s->current_picture.age;
3443 assert(s->pict_type!=I_TYPE);
3445 (*mbskip_ptr) ++; /* indicate that this time we skiped it */
3446 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3448 /* if previous was skipped too, then nothing to do ! */
3449 if (*mbskip_ptr >= age && s->current_picture.reference){
3452 } else if(!s->current_picture.reference){
3453 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3454 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3456 *mbskip_ptr = 0; /* not skipped */
3460 dct_linesize = linesize << s->interlaced_dct;
3461 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3465 dest_cb= s->dest[1];
3466 dest_cr= s->dest[2];
3468 dest_y = s->b_scratchpad;
3469 dest_cb= s->b_scratchpad+16*linesize;
3470 dest_cr= s->b_scratchpad+32*linesize;
3474 /* motion handling */
3475 /* decoding or more than one mb_type (MC was allready done otherwise) */
3478 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3480 if (s->mv_dir & MV_DIR_FORWARD) {
3481 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3482 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3484 if (s->mv_dir & MV_DIR_BACKWARD) {
3485 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3488 if ((!s->no_rounding) || s->pict_type==B_TYPE){
3489 op_pix = s->dsp.put_pixels_tab;
3490 op_qpix= s->dsp.put_qpel_pixels_tab;
3492 op_pix = s->dsp.put_no_rnd_pixels_tab;
3493 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3495 if (s->mv_dir & MV_DIR_FORWARD) {
3496 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3497 op_pix = s->dsp.avg_pixels_tab;
3498 op_qpix= s->dsp.avg_qpel_pixels_tab;
3500 if (s->mv_dir & MV_DIR_BACKWARD) {
3501 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3506 /* skip dequant / idct if we are really late ;) */
3507 if(s->hurry_up>1) return;
3509 /* add dct residue */
3510 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3511 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3512 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
3513 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
3514 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
3515 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3517 if(!(s->flags&CODEC_FLAG_GRAY)){
3518 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3519 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3521 } else if(s->codec_id != CODEC_ID_WMV2){
3522 add_dct(s, block[0], 0, dest_y , dct_linesize);
3523 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
3524 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
3525 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3527 if(!(s->flags&CODEC_FLAG_GRAY)){
3528 if(s->chroma_y_shift){//Chroma420
3529 add_dct(s, block[4], 4, dest_cb, uvlinesize);
3530 add_dct(s, block[5], 5, dest_cr, uvlinesize);
3533 dct_linesize = uvlinesize << s->interlaced_dct;
3534 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3536 add_dct(s, block[4], 4, dest_cb, dct_linesize);
3537 add_dct(s, block[5], 5, dest_cr, dct_linesize);
3538 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3539 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3540 if(!s->chroma_x_shift){//Chroma444
3541 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
3542 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
3543 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
3544 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
3551 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3555 /* dct only in intra block */
3556 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
3557 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
3558 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
3559 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
3560 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3562 if(!(s->flags&CODEC_FLAG_GRAY)){
3563 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3564 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3567 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
3568 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
3569 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
3570 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3572 if(!(s->flags&CODEC_FLAG_GRAY)){
3573 if(s->chroma_y_shift){
3574 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
3575 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
3578 dct_linesize = uvlinesize << s->interlaced_dct;
3579 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
3581 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
3582 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
3583 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3584 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3585 if(!s->chroma_x_shift){//Chroma444
3586 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
3587 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
3588 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
3589 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
3596 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
3597 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3598 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3603 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
3604 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
3605 else MPV_decode_mb_internal(s, block, 0);
3608 #ifdef CONFIG_ENCODERS
3610 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
3612 static const char tab[64]=
3624 DCTELEM *block= s->block[n];
3625 const int last_index= s->block_last_index[n];
3630 threshold= -threshold;
3634 /* are all which we could set to zero are allready zero? */
3635 if(last_index<=skip_dc - 1) return;
3637 for(i=0; i<=last_index; i++){
3638 const int j = s->intra_scantable.permutated[i];
3639 const int level = ABS(block[j]);
3641 if(skip_dc && i==0) continue;
3650 if(score >= threshold) return;
3651 for(i=skip_dc; i<=last_index; i++){
3652 const int j = s->intra_scantable.permutated[i];
3655 if(block[0]) s->block_last_index[n]= 0;
3656 else s->block_last_index[n]= -1;
3659 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
3662 const int maxlevel= s->max_qcoeff;
3663 const int minlevel= s->min_qcoeff;
3667 i=1; //skip clipping of intra dc
3671 for(;i<=last_index; i++){
3672 const int j= s->intra_scantable.permutated[i];
3673 int level = block[j];
3675 if (level>maxlevel){
3678 }else if(level<minlevel){
3686 if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
3687 av_log(s->avctx, AV_LOG_INFO, "warning, cliping %d dct coefficents to %d..%d\n", overflow, minlevel, maxlevel);
3690 #endif //CONFIG_ENCODERS
3694 * @param h is the normal height, this will be reduced automatically if needed for the last row
3696 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
3697 if (s->avctx->draw_horiz_band) {
3701 if(s->picture_structure != PICT_FRAME){
3704 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
3707 h= FFMIN(h, s->avctx->height - y);
3709 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
3710 src= (AVFrame*)s->current_picture_ptr;
3711 else if(s->last_picture_ptr)
3712 src= (AVFrame*)s->last_picture_ptr;
3716 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
3722 offset[0]= y * s->linesize;;
3724 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
3730 s->avctx->draw_horiz_band(s->avctx, src, offset,
3731 y, s->picture_structure, h);
3735 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3736 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this woulnd be wrong for field pics
3737 const int uvlinesize= s->current_picture.linesize[1];
3738 const int mb_size= 4 - s->avctx->lowres;
3740 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
3741 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
3742 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3743 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3744 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3745 s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3746 //block_index is not used by mpeg2, so it is not affected by chroma_format
3748 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
3749 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3750 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3752 if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3754 s->dest[0] += s->mb_y * linesize << mb_size;
3755 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3756 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3760 #ifdef CONFIG_ENCODERS
3762 static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
3772 for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
3773 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
3774 int v= ptr[x2 + y2*stride];
3780 weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
3785 static void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
3787 int16_t weight[6][64];
3788 DCTELEM orig[6][64];
3789 const int mb_x= s->mb_x;
3790 const int mb_y= s->mb_y;
3793 int dct_offset = s->linesize*8; //default for progressive frames
3794 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3797 for(i=0; i<6; i++) skip_dct[i]=0;
3799 if(s->adaptive_quant){
3800 const int last_qp= s->qscale;
3801 const int mb_xy= mb_x + mb_y*s->mb_stride;
3803 s->lambda= s->lambda_table[mb_xy];
3806 if(!(s->flags&CODEC_FLAG_QP_RD)){
3807 s->dquant= s->qscale - last_qp;
3809 if(s->out_format==FMT_H263){
3810 s->dquant= clip(s->dquant, -2, 2); //FIXME RD
3812 if(s->codec_id==CODEC_ID_MPEG4){
3814 if(s->pict_type == B_TYPE){
3816 s->dquant= (s->dquant/2)*2;
3817 if(s->mv_dir&MV_DIRECT)
3820 if(s->mv_type==MV_TYPE_8X8)
3826 ff_set_qscale(s, last_qp + s->dquant);
3827 }else if(s->flags&CODEC_FLAG_QP_RD)
3828 ff_set_qscale(s, s->qscale + s->dquant);
3830 wrap_y = s->linesize;
3831 wrap_c = s->uvlinesize;
3832 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
3833 ptr_cb = s->new_picture.data[1] + (mb_y * 8 * wrap_c) + mb_x * 8;
3834 ptr_cr = s->new_picture.data[2] + (mb_y * 8 * wrap_c) + mb_x * 8;
3836 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
3837 uint8_t *ebuf= s->edge_emu_buffer + 32;
3838 ff_emulated_edge_mc(ebuf , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width , s->height);
3840 ff_emulated_edge_mc(ebuf+18*wrap_y , ptr_cb, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3841 ptr_cb= ebuf+18*wrap_y;
3842 ff_emulated_edge_mc(ebuf+18*wrap_y+8, ptr_cr, wrap_c, 8, 8, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
3843 ptr_cr= ebuf+18*wrap_y+8;
3847 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3848 int progressive_score, interlaced_score;
3850 s->interlaced_dct=0;
3851 progressive_score= s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y, 8)
3852 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
3854 if(progressive_score > 0){
3855 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y*2, 8)
3856 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y , NULL, wrap_y*2, 8);
3857 if(progressive_score > interlaced_score){
3858 s->interlaced_dct=1;
3866 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
3867 s->dsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
3868 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
3869 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
3871 if(s->flags&CODEC_FLAG_GRAY){
3875 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
3876 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
3879 op_pixels_func (*op_pix)[4];
3880 qpel_mc_func (*op_qpix)[16];
3881 uint8_t *dest_y, *dest_cb, *dest_cr;
3883 dest_y = s->dest[0];
3884 dest_cb = s->dest[1];
3885 dest_cr = s->dest[2];
3887 if ((!s->no_rounding) || s->pict_type==B_TYPE){
3888 op_pix = s->dsp.put_pixels_tab;
3889 op_qpix= s->dsp.put_qpel_pixels_tab;
3891 op_pix = s->dsp.put_no_rnd_pixels_tab;
3892 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3895 if (s->mv_dir & MV_DIR_FORWARD) {
3896 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3897 op_pix = s->dsp.avg_pixels_tab;
3898 op_qpix= s->dsp.avg_qpel_pixels_tab;
3900 if (s->mv_dir & MV_DIR_BACKWARD) {
3901 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3904 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
3905 int progressive_score, interlaced_score;
3907 s->interlaced_dct=0;
3908 progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8)
3909 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
3911 if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
3913 if(progressive_score>0){
3914 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8)
3915 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8);
3917 if(progressive_score > interlaced_score){
3918 s->interlaced_dct=1;
3926 s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y);
3927 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
3928 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y);
3929 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
3931 if(s->flags&CODEC_FLAG_GRAY){
3935 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
3936 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
3938 /* pre quantization */
3939 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
3941 if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
3942 if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
3943 if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
3944 if(s->dsp.sad[1](NULL, ptr_y +dct_offset+ 8, dest_y +dct_offset+ 8, wrap_y, 8) < 20*s->qscale) skip_dct[3]= 1;
3945 if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
3946 if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
3950 if(s->avctx->quantizer_noise_shaping){
3951 if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y , wrap_y);
3952 if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y + 8, wrap_y);
3953 if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset , wrap_y);
3954 if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
3955 if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb , wrap_c);
3956 if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr , wrap_c);
3957 memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*6);
3960 /* DCT & quantize */
3961 assert(s->out_format!=FMT_MJPEG || s->qscale==8);
3966 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
3967 // FIXME we could decide to change to quantizer instead of clipping
3968 // JS: I don't think that would be a good idea it could lower quality instead
3969 // of improve it. Just INTRADC clipping deserves changes in quantizer
3970 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
3972 s->block_last_index[i]= -1;
3974 if(s->avctx->quantizer_noise_shaping){
3977 s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
3982 if(s->luma_elim_threshold && !s->mb_intra)
3984 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
3985 if(s->chroma_elim_threshold && !s->mb_intra)
3987 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
3989 if(s->flags & CODEC_FLAG_CBP_RD){
3991 if(s->block_last_index[i] == -1)
3992 s->coded_score[i]= INT_MAX/256;
3997 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
3998 s->block_last_index[4]=
3999 s->block_last_index[5]= 0;
4001 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4004 //non c quantize code returns incorrect block_last_index FIXME
4005 if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4008 if(s->block_last_index[i]>0){
4009 for(j=63; j>0; j--){
4010 if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4012 s->block_last_index[i]= j;
4017 /* huffman encode */
4018 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4019 case CODEC_ID_MPEG1VIDEO:
4020 case CODEC_ID_MPEG2VIDEO:
4021 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4023 case CODEC_ID_MPEG4:
4024 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4025 case CODEC_ID_MSMPEG4V2:
4026 case CODEC_ID_MSMPEG4V3:
4028 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4030 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4032 case CODEC_ID_H263P:
4035 h263_encode_mb(s, s->block, motion_x, motion_y); break;
4037 case CODEC_ID_MJPEG:
4038 mjpeg_encode_mb(s, s->block); break;
4044 #endif //CONFIG_ENCODERS
4046 void ff_mpeg_flush(AVCodecContext *avctx){
4048 MpegEncContext *s = avctx->priv_data;
4050 if(s==NULL || s->picture==NULL)
4053 for(i=0; i<MAX_PICTURE_COUNT; i++){
4054 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4055 || s->picture[i].type == FF_BUFFER_TYPE_USER))
4056 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4058 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4060 s->parse_context.state= -1;
4061 s->parse_context.frame_start_found= 0;
4062 s->parse_context.overread= 0;
4063 s->parse_context.overread_index= 0;
4064 s->parse_context.index= 0;
4065 s->parse_context.last_index= 0;
4066 s->bitstream_buffer_size=0;
4069 #ifdef CONFIG_ENCODERS
4070 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4072 const uint16_t *srcw= (uint16_t*)src;
4073 int words= length>>4;
4074 int bits= length&15;
4077 if(length==0) return;
4080 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4081 }else if(put_bits_count(pb)&7){
4082 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4084 for(i=0; put_bits_count(pb)&31; i++)
4085 put_bits(pb, 8, src[i]);
4087 memcpy(pbBufPtr(pb), src+i, 2*words-i);
4088 skip_put_bytes(pb, 2*words-i);
4091 put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4094 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4097 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4100 d->mb_skip_run= s->mb_skip_run;
4102 d->last_dc[i]= s->last_dc[i];
4105 d->mv_bits= s->mv_bits;
4106 d->i_tex_bits= s->i_tex_bits;
4107 d->p_tex_bits= s->p_tex_bits;
4108 d->i_count= s->i_count;
4109 d->f_count= s->f_count;
4110 d->b_count= s->b_count;
4111 d->skip_count= s->skip_count;
4112 d->misc_bits= s->misc_bits;
4116 d->qscale= s->qscale;
4117 d->dquant= s->dquant;
4120 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4123 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
4124 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4127 d->mb_skip_run= s->mb_skip_run;
4129 d->last_dc[i]= s->last_dc[i];
4132 d->mv_bits= s->mv_bits;
4133 d->i_tex_bits= s->i_tex_bits;
4134 d->p_tex_bits= s->p_tex_bits;
4135 d->i_count= s->i_count;
4136 d->f_count= s->f_count;
4137 d->b_count= s->b_count;
4138 d->skip_count= s->skip_count;
4139 d->misc_bits= s->misc_bits;
4141 d->mb_intra= s->mb_intra;
4142 d->mb_skiped= s->mb_skiped;
4143 d->mv_type= s->mv_type;
4144 d->mv_dir= s->mv_dir;
4146 if(s->data_partitioning){
4148 d->tex_pb= s->tex_pb;
4152 d->block_last_index[i]= s->block_last_index[i];
4153 d->interlaced_dct= s->interlaced_dct;
4154 d->qscale= s->qscale;
4157 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
4158 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4159 int *dmin, int *next_block, int motion_x, int motion_y)
4162 uint8_t *dest_backup[3];
4164 copy_context_before_encode(s, backup, type);
4166 s->block= s->blocks[*next_block];
4167 s->pb= pb[*next_block];
4168 if(s->data_partitioning){
4169 s->pb2 = pb2 [*next_block];
4170 s->tex_pb= tex_pb[*next_block];
4174 memcpy(dest_backup, s->dest, sizeof(s->dest));
4175 s->dest[0] = s->rd_scratchpad;
4176 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4177 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4178 assert(s->linesize >= 32); //FIXME
4181 encode_mb(s, motion_x, motion_y);
4183 score= put_bits_count(&s->pb);
4184 if(s->data_partitioning){
4185 score+= put_bits_count(&s->pb2);
4186 score+= put_bits_count(&s->tex_pb);
4189 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4190 MPV_decode_mb(s, s->block);
4192 score *= s->lambda2;
4193 score += sse_mb(s) << FF_LAMBDA_SHIFT;
4197 memcpy(s->dest, dest_backup, sizeof(s->dest));
4204 copy_context_after_encode(best, s, type);
4208 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4209 uint32_t *sq = squareTbl + 256;
4214 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
4215 else if(w==8 && h==8)
4216 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4220 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4229 static int sse_mb(MpegEncContext *s){
4233 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4234 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4237 if(s->avctx->mb_cmp == FF_CMP_NSSE){
4238 return s->dsp.nsse[0](s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
4239 +s->dsp.nsse[1](s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
4240 +s->dsp.nsse[1](s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
4242 return s->dsp.sse[0](NULL, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], s->linesize, 16)
4243 +s->dsp.sse[1](NULL, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], s->uvlinesize, 8)
4244 +s->dsp.sse[1](NULL, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], s->uvlinesize, 8);
4247 return sse(s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16, s->dest[0], w, h, s->linesize)
4248 +sse(s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize)
4249 +sse(s, s->new_picture.data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize);
4252 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4253 MpegEncContext *s= arg;
4257 s->me.dia_size= s->avctx->pre_dia_size;
4258 s->first_slice_line=1;
4259 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4260 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4261 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4263 s->first_slice_line=0;
4271 static int estimate_motion_thread(AVCodecContext *c, void *arg){
4272 MpegEncContext *s= arg;
4274 s->me.dia_size= s->avctx->dia_size;
4275 s->first_slice_line=1;
4276 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4277 s->mb_x=0; //for block init below
4278 ff_init_block_index(s);
4279 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4280 s->block_index[0]+=2;
4281 s->block_index[1]+=2;
4282 s->block_index[2]+=2;
4283 s->block_index[3]+=2;
4285 /* compute motion vector & mb_type and store in context */
4286 if(s->pict_type==B_TYPE)
4287 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4289 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4291 s->first_slice_line=0;
4296 static int mb_var_thread(AVCodecContext *c, void *arg){
4297 MpegEncContext *s= arg;
4300 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4301 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4304 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4306 int sum = s->dsp.pix_sum(pix, s->linesize);
4308 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4310 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4311 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4312 s->me.mb_var_sum_temp += varc;
4318 static void write_slice_end(MpegEncContext *s){
4319 if(s->codec_id==CODEC_ID_MPEG4){
4320 if(s->partitioned_frame){
4321 ff_mpeg4_merge_partitions(s);
4324 ff_mpeg4_stuffing(&s->pb);
4325 }else if(s->out_format == FMT_MJPEG){
4326 ff_mjpeg_stuffing(&s->pb);
4329 align_put_bits(&s->pb);
4330 flush_put_bits(&s->pb);
4333 static int encode_thread(AVCodecContext *c, void *arg){
4334 MpegEncContext *s= arg;
4335 int mb_x, mb_y, pdif = 0;
4337 MpegEncContext best_s, backup_s;
4338 uint8_t bit_buf[2][3000];
4339 uint8_t bit_buf2[2][3000];
4340 uint8_t bit_buf_tex[2][3000];
4341 PutBitContext pb[2], pb2[2], tex_pb[2];
4342 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4345 init_put_bits(&pb [i], bit_buf [i], 3000);
4346 init_put_bits(&pb2 [i], bit_buf2 [i], 3000);
4347 init_put_bits(&tex_pb[i], bit_buf_tex[i], 3000);
4350 s->last_bits= put_bits_count(&s->pb);
4361 /* init last dc values */
4362 /* note: quant matrix value (8) is implied here */
4363 s->last_dc[i] = 128 << s->intra_dc_precision;
4365 s->current_picture_ptr->error[i] = 0;
4368 memset(s->last_mv, 0, sizeof(s->last_mv));
4373 switch(s->codec_id){
4375 case CODEC_ID_H263P:
4377 s->gob_index = ff_h263_get_gob_height(s);
4379 case CODEC_ID_MPEG4:
4380 if(s->partitioned_frame)
4381 ff_mpeg4_init_partitions(s);
4388 s->first_slice_line = 1;
4389 s->ptr_lastgob = s->pb.buf;
4390 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4391 // printf("row %d at %X\n", s->mb_y, (int)s);
4395 ff_set_qscale(s, s->qscale);
4396 ff_init_block_index(s);
4398 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4399 const int xy= mb_y*s->mb_stride + mb_x;
4400 int mb_type= s->mb_type[xy];
4406 ff_update_block_index(s);
4408 /* write gob / video packet header */
4411 int current_packet_size, is_gob_start;
4413 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4415 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
4417 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4419 switch(s->codec_id){
4421 case CODEC_ID_H263P:
4422 if(!s->h263_slice_structured)
4423 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4425 case CODEC_ID_MPEG2VIDEO:
4426 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4427 case CODEC_ID_MPEG1VIDEO:
4428 if(s->mb_skip_run) is_gob_start=0;
4433 if(s->start_mb_y != mb_y || mb_x!=0){
4436 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4437 ff_mpeg4_init_partitions(s);
4441 assert((put_bits_count(&s->pb)&7) == 0);
4442 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4444 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4445 int r= put_bits_count(&s->pb)/8 + s->picture_number + s->codec_id + s->mb_x + s->mb_y;
4446 int d= 100 / s->avctx->error_rate;
4448 current_packet_size=0;
4449 #ifndef ALT_BITSTREAM_WRITER
4450 s->pb.buf_ptr= s->ptr_lastgob;
4452 assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4456 if (s->avctx->rtp_callback)
4457 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, 0);
4459 switch(s->codec_id){
4460 case CODEC_ID_MPEG4:
4461 ff_mpeg4_encode_video_packet_header(s);
4462 ff_mpeg4_clean_buffers(s);
4464 case CODEC_ID_MPEG1VIDEO:
4465 case CODEC_ID_MPEG2VIDEO:
4466 ff_mpeg1_encode_slice_header(s);
4467 ff_mpeg1_clean_buffers(s);
4470 case CODEC_ID_H263P:
4471 h263_encode_gob_header(s, mb_y);
4475 if(s->flags&CODEC_FLAG_PASS1){
4476 int bits= put_bits_count(&s->pb);
4477 s->misc_bits+= bits - s->last_bits;
4481 s->ptr_lastgob += current_packet_size;
4482 s->first_slice_line=1;
4483 s->resync_mb_x=mb_x;
4484 s->resync_mb_y=mb_y;
4489 if( (s->resync_mb_x == s->mb_x)
4490 && s->resync_mb_y+1 == s->mb_y){
4491 s->first_slice_line=0;
4495 s->dquant=0; //only for QP_RD
4497 if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
4499 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
4501 copy_context_before_encode(&backup_s, s, -1);
4503 best_s.data_partitioning= s->data_partitioning;
4504 best_s.partitioned_frame= s->partitioned_frame;
4505 if(s->data_partitioning){
4506 backup_s.pb2= s->pb2;
4507 backup_s.tex_pb= s->tex_pb;
4510 if(mb_type&CANDIDATE_MB_TYPE_INTER){
4511 s->mv_dir = MV_DIR_FORWARD;
4512 s->mv_type = MV_TYPE_16X16;
4514 s->mv[0][0][0] = s->p_mv_table[xy][0];
4515 s->mv[0][0][1] = s->p_mv_table[xy][1];
4516 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
4517 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4519 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
4520 s->mv_dir = MV_DIR_FORWARD;
4521 s->mv_type = MV_TYPE_FIELD;
4524 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4525 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4526 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4528 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
4529 &dmin, &next_block, 0, 0);
4531 if(mb_type&CANDIDATE_MB_TYPE_SKIPED){
4532 s->mv_dir = MV_DIR_FORWARD;
4533 s->mv_type = MV_TYPE_16X16;
4537 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPED, pb, pb2, tex_pb,
4538 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4540 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
4541 s->mv_dir = MV_DIR_FORWARD;
4542 s->mv_type = MV_TYPE_8X8;
4545 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4546 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4548 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
4549 &dmin, &next_block, 0, 0);
4551 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
4552 s->mv_dir = MV_DIR_FORWARD;
4553 s->mv_type = MV_TYPE_16X16;
4555 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4556 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4557 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
4558 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
4560 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
4561 s->mv_dir = MV_DIR_BACKWARD;
4562 s->mv_type = MV_TYPE_16X16;
4564 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4565 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4566 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
4567 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
4569 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
4570 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4571 s->mv_type = MV_TYPE_16X16;
4573 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4574 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4575 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4576 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4577 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
4578 &dmin, &next_block, 0, 0);
4580 if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
4581 int mx= s->b_direct_mv_table[xy][0];
4582 int my= s->b_direct_mv_table[xy][1];
4584 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4587 ff_mpeg4_set_direct_mv(s, mx, my);
4589 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
4590 &dmin, &next_block, mx, my);
4592 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
4593 s->mv_dir = MV_DIR_FORWARD;
4594 s->mv_type = MV_TYPE_FIELD;
4597 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4598 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4599 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4601 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
4602 &dmin, &next_block, 0, 0);
4604 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
4605 s->mv_dir = MV_DIR_BACKWARD;
4606 s->mv_type = MV_TYPE_FIELD;
4609 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4610 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4611 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4613 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
4614 &dmin, &next_block, 0, 0);
4616 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
4617 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4618 s->mv_type = MV_TYPE_FIELD;
4620 for(dir=0; dir<2; dir++){
4622 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4623 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4624 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4627 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
4628 &dmin, &next_block, 0, 0);
4630 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
4632 s->mv_type = MV_TYPE_16X16;
4636 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
4637 &dmin, &next_block, 0, 0);
4638 if(s->h263_pred || s->h263_aic){
4640 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
4642 ff_clean_intra_table_entries(s); //old mode?
4646 if(s->flags & CODEC_FLAG_QP_RD){
4647 if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
4648 const int last_qp= backup_s.qscale;
4649 int dquant, dir, qp, dc[6];
4651 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
4653 assert(backup_s.dquant == 0);
4656 s->mv_dir= best_s.mv_dir;
4657 s->mv_type = MV_TYPE_16X16;
4658 s->mb_intra= best_s.mb_intra;
4659 s->mv[0][0][0] = best_s.mv[0][0][0];
4660 s->mv[0][0][1] = best_s.mv[0][0][1];
4661 s->mv[1][0][0] = best_s.mv[1][0][0];
4662 s->mv[1][0][1] = best_s.mv[1][0][1];
4664 dir= s->pict_type == B_TYPE ? 2 : 1;
4665 if(last_qp + dir > s->avctx->qmax) dir= -dir;
4666 for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
4667 qp= last_qp + dquant;
4668 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
4670 backup_s.dquant= dquant;
4671 if(s->mb_intra && s->dc_val[0]){
4673 dc[i]= s->dc_val[0][ s->block_index[i] ];
4674 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
4678 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
4679 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
4680 if(best_s.qscale != qp){
4681 if(s->mb_intra && s->dc_val[0]){
4683 s->dc_val[0][ s->block_index[i] ]= dc[i];
4684 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
4687 if(dir > 0 && dquant==dir){
4695 s->current_picture.qscale_table[xy]= qp;
4699 copy_context_after_encode(s, &best_s, -1);
4701 pb_bits_count= put_bits_count(&s->pb);
4702 flush_put_bits(&s->pb);
4703 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
4706 if(s->data_partitioning){
4707 pb2_bits_count= put_bits_count(&s->pb2);
4708 flush_put_bits(&s->pb2);
4709 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
4710 s->pb2= backup_s.pb2;
4712 tex_pb_bits_count= put_bits_count(&s->tex_pb);
4713 flush_put_bits(&s->tex_pb);
4714 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
4715 s->tex_pb= backup_s.tex_pb;
4717 s->last_bits= put_bits_count(&s->pb);
4720 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4721 ff_h263_update_motion_val(s);
4724 if(next_block==0){ //FIXME 16 vs linesize16
4725 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
4726 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
4727 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
4730 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
4731 MPV_decode_mb(s, s->block);
4733 int motion_x, motion_y;
4734 s->mv_type=MV_TYPE_16X16;
4735 // only one MB-Type possible
4738 case CANDIDATE_MB_TYPE_INTRA:
4741 motion_x= s->mv[0][0][0] = 0;
4742 motion_y= s->mv[0][0][1] = 0;
4744 case CANDIDATE_MB_TYPE_INTER:
4745 s->mv_dir = MV_DIR_FORWARD;
4747 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
4748 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
4750 case CANDIDATE_MB_TYPE_INTER_I:
4751 s->mv_dir = MV_DIR_FORWARD;
4752 s->mv_type = MV_TYPE_FIELD;
4755 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
4756 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
4757 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
4759 motion_x = motion_y = 0;
4761 case CANDIDATE_MB_TYPE_INTER4V:
4762 s->mv_dir = MV_DIR_FORWARD;
4763 s->mv_type = MV_TYPE_8X8;
4766 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
4767 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
4769 motion_x= motion_y= 0;
4771 case CANDIDATE_MB_TYPE_DIRECT:
4772 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
4774 motion_x=s->b_direct_mv_table[xy][0];
4775 motion_y=s->b_direct_mv_table[xy][1];
4777 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
4780 case CANDIDATE_MB_TYPE_BIDIR:
4781 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4785 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
4786 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
4787 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
4788 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
4790 case CANDIDATE_MB_TYPE_BACKWARD:
4791 s->mv_dir = MV_DIR_BACKWARD;
4793 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
4794 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
4796 case CANDIDATE_MB_TYPE_FORWARD:
4797 s->mv_dir = MV_DIR_FORWARD;
4799 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
4800 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
4801 // printf(" %d %d ", motion_x, motion_y);
4803 case CANDIDATE_MB_TYPE_FORWARD_I:
4804 s->mv_dir = MV_DIR_FORWARD;
4805 s->mv_type = MV_TYPE_FIELD;
4808 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
4809 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
4810 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
4812 motion_x=motion_y=0;
4814 case CANDIDATE_MB_TYPE_BACKWARD_I:
4815 s->mv_dir = MV_DIR_BACKWARD;
4816 s->mv_type = MV_TYPE_FIELD;
4819 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
4820 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
4821 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
4823 motion_x=motion_y=0;
4825 case CANDIDATE_MB_TYPE_BIDIR_I:
4826 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
4827 s->mv_type = MV_TYPE_FIELD;
4829 for(dir=0; dir<2; dir++){
4831 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
4832 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
4833 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
4836 motion_x=motion_y=0;
4839 motion_x=motion_y=0; //gcc warning fix
4840 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
4843 encode_mb(s, motion_x, motion_y);
4845 // RAL: Update last macrobloc type
4846 s->last_mv_dir = s->mv_dir;
4849 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
4850 ff_h263_update_motion_val(s);
4853 MPV_decode_mb(s, s->block);
4856 /* clean the MV table in IPS frames for direct mode in B frames */
4857 if(s->mb_intra /* && I,P,S_TYPE */){
4858 s->p_mv_table[xy][0]=0;
4859 s->p_mv_table[xy][1]=0;
4862 if(s->flags&CODEC_FLAG_PSNR){
4866 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4867 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4869 s->current_picture_ptr->error[0] += sse(
4870 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
4871 s->dest[0], w, h, s->linesize);
4872 s->current_picture_ptr->error[1] += sse(
4873 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
4874 s->dest[1], w>>1, h>>1, s->uvlinesize);
4875 s->current_picture_ptr->error[2] += sse(
4876 s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
4877 s->dest[2], w>>1, h>>1, s->uvlinesize);
4880 ff_h263_loop_filter(s);
4881 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
4886 //not beautifull here but we must write it before flushing so it has to be here
4887 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
4888 msmpeg4_encode_ext_header(s);
4893 /* Send the last GOB if RTP */
4894 if (s->avctx->rtp_callback) {
4895 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
4896 /* Call the RTP callback to send the last GOB */
4898 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, 0);
4904 #define MERGE(field) dst->field += src->field; src->field=0
4905 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
4906 MERGE(me.scene_change_score);
4907 MERGE(me.mc_mb_var_sum_temp);
4908 MERGE(me.mb_var_sum_temp);
4911 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
4914 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
4915 MERGE(dct_count[1]);
4925 MERGE(padding_bug_score);
4927 if(dst->avctx->noise_reduction){
4928 for(i=0; i<64; i++){
4929 MERGE(dct_error_sum[0][i]);
4930 MERGE(dct_error_sum[1][i]);
4934 assert(put_bits_count(&src->pb) % 8 ==0);
4935 assert(put_bits_count(&dst->pb) % 8 ==0);
4936 ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
4937 flush_put_bits(&dst->pb);
4940 static void encode_picture(MpegEncContext *s, int picture_number)
4945 s->picture_number = picture_number;
4947 /* Reset the average MB variance */
4948 s->me.mb_var_sum_temp =
4949 s->me.mc_mb_var_sum_temp = 0;
4952 /* we need to initialize some time vars before we can encode b-frames */
4953 // RAL: Condition added for MPEG1VIDEO
4954 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
4955 ff_set_mpeg4_time(s, s->picture_number); //FIXME rename and use has_b_frames or similar
4958 s->me.scene_change_score=0;
4960 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
4962 if(s->pict_type==I_TYPE){
4963 if(s->msmpeg4_version >= 3) s->no_rounding=1;
4964 else s->no_rounding=0;
4965 }else if(s->pict_type!=B_TYPE){
4966 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
4967 s->no_rounding ^= 1;
4970 s->mb_intra=0; //for the rate distoration & bit compare functions
4971 for(i=1; i<s->avctx->thread_count; i++){
4972 ff_update_duplicate_context(s->thread_context[i], s);
4977 /* Estimate motion for every MB */
4978 if(s->pict_type != I_TYPE){
4979 if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){
4980 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
4981 s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
4985 s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
4986 }else /* if(s->pict_type == I_TYPE) */{
4988 for(i=0; i<s->mb_stride*s->mb_height; i++)
4989 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
4991 if(!s->fixed_qscale){
4992 /* finding spatial complexity for I-frame rate control */
4993 s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
4996 for(i=1; i<s->avctx->thread_count; i++){
4997 merge_context_after_me(s, s->thread_context[i]);
4999 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
5000 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
5003 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
5004 s->pict_type= I_TYPE;
5005 for(i=0; i<s->mb_stride*s->mb_height; i++)
5006 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
5007 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
5011 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
5012 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
5014 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5016 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
5017 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
5018 s->f_code= FFMAX(s->f_code, FFMAX(a,b));
5021 ff_fix_long_p_mvs(s);
5022 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
5023 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5027 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
5028 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
5033 if(s->pict_type==B_TYPE){
5036 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
5037 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5038 s->f_code = FFMAX(a, b);
5040 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
5041 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5042 s->b_code = FFMAX(a, b);
5044 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
5045 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
5046 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5047 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5048 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5050 for(dir=0; dir<2; dir++){
5053 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
5054 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
5055 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
5056 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
5064 if (!s->fixed_qscale)
5065 s->current_picture.quality = ff_rate_estimate_qscale(s); //FIXME pic_ptr
5067 if(s->adaptive_quant){
5069 switch(s->codec_id){
5070 case CODEC_ID_MPEG4:
5071 ff_clean_mpeg4_qscales(s);
5074 case CODEC_ID_H263P:
5076 ff_clean_h263_qscales(s);
5081 s->lambda= s->lambda_table[0];
5084 s->lambda= s->current_picture.quality;
5085 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
5088 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE))
5089 s->qscale= 3; //reduce cliping problems
5091 if (s->out_format == FMT_MJPEG) {
5092 /* for mjpeg, we do include qscale in the matrix */
5093 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
5095 int j= s->dsp.idct_permutation[i];
5097 s->intra_matrix[j] = CLAMP_TO_8BIT((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
5099 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
5100 s->intra_matrix, s->intra_quant_bias, 8, 8);
5104 //FIXME var duplication
5105 s->current_picture_ptr->key_frame=
5106 s->current_picture.key_frame= s->pict_type == I_TYPE; //FIXME pic_ptr
5107 s->current_picture_ptr->pict_type=
5108 s->current_picture.pict_type= s->pict_type;
5110 if(s->current_picture.key_frame)
5111 s->picture_in_gop_number=0;
5113 s->last_bits= put_bits_count(&s->pb);
5114 switch(s->out_format) {
5116 mjpeg_picture_header(s);
5120 if (s->codec_id == CODEC_ID_WMV2)
5121 ff_wmv2_encode_picture_header(s, picture_number);
5122 else if (s->h263_msmpeg4)
5123 msmpeg4_encode_picture_header(s, picture_number);
5124 else if (s->h263_pred)
5125 mpeg4_encode_picture_header(s, picture_number);
5126 else if (s->codec_id == CODEC_ID_RV10)
5127 rv10_encode_picture_header(s, picture_number);
5128 else if (s->codec_id == CODEC_ID_FLV1)
5129 ff_flv_encode_picture_header(s, picture_number);
5131 h263_encode_picture_header(s, picture_number);
5135 mpeg1_encode_picture_header(s, picture_number);
5142 bits= put_bits_count(&s->pb);
5143 s->header_bits= bits - s->last_bits;
5145 for(i=1; i<s->avctx->thread_count; i++){
5146 update_duplicate_context_after_me(s->thread_context[i], s);
5148 s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5149 for(i=1; i<s->avctx->thread_count; i++){
5150 merge_context_after_encode(s, s->thread_context[i]);
5155 #endif //CONFIG_ENCODERS
5157 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
5158 const int intra= s->mb_intra;
5161 s->dct_count[intra]++;
5163 for(i=0; i<64; i++){
5164 int level= block[i];
5168 s->dct_error_sum[intra][i] += level;
5169 level -= s->dct_offset[intra][i];
5170 if(level<0) level=0;
5172 s->dct_error_sum[intra][i] -= level;
5173 level += s->dct_offset[intra][i];
5174 if(level>0) level=0;
5181 #ifdef CONFIG_ENCODERS
5183 static int dct_quantize_trellis_c(MpegEncContext *s,
5184 DCTELEM *block, int n,
5185 int qscale, int *overflow){
5187 const uint8_t *scantable= s->intra_scantable.scantable;
5188 const uint8_t *perm_scantable= s->intra_scantable.permutated;
5190 unsigned int threshold1, threshold2;
5202 int coeff_count[64];
5203 int qmul, qadd, start_i, last_non_zero, i, dc;
5204 const int esc_length= s->ac_esc_length;
5206 uint8_t * last_length;
5207 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
5209 s->dsp.fdct (block);
5211 if(s->dct_error_sum)
5212 s->denoise_dct(s, block);
5214 qadd= ((qscale-1)|1)*8;
5225 /* For AIC we skip quant/dequant of INTRADC */
5230 /* note: block[0] is assumed to be positive */
5231 block[0] = (block[0] + (q >> 1)) / q;
5234 qmat = s->q_intra_matrix[qscale];
5235 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
5236 bias= 1<<(QMAT_SHIFT-1);
5237 length = s->intra_ac_vlc_length;
5238 last_length= s->intra_ac_vlc_last_length;
5242 qmat = s->q_inter_matrix[qscale];
5243 length = s->inter_ac_vlc_length;
5244 last_length= s->inter_ac_vlc_last_length;
5248 threshold1= (1<<QMAT_SHIFT) - bias - 1;
5249 threshold2= (threshold1<<1);
5251 for(i=63; i>=start_i; i--) {
5252 const int j = scantable[i];
5253 int level = block[j] * qmat[j];
5255 if(((unsigned)(level+threshold1))>threshold2){
5261 for(i=start_i; i<=last_non_zero; i++) {
5262 const int j = scantable[i];
5263 int level = block[j] * qmat[j];
5265 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
5266 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
5267 if(((unsigned)(level+threshold1))>threshold2){
5269 level= (bias + level)>>QMAT_SHIFT;
5271 coeff[1][i]= level-1;
5272 // coeff[2][k]= level-2;
5274 level= (bias - level)>>QMAT_SHIFT;
5275 coeff[0][i]= -level;
5276 coeff[1][i]= -level+1;
5277 // coeff[2][k]= -level+2;
5279 coeff_count[i]= FFMIN(level, 2);
5280 assert(coeff_count[i]);
5283 coeff[0][i]= (level>>31)|1;
5288 *overflow= s->max_qcoeff < max; //overflow might have happend
5290 if(last_non_zero < start_i){
5291 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
5292 return last_non_zero;
5295 score_tab[start_i]= 0;
5296 survivor[0]= start_i;
5299 for(i=start_i; i<=last_non_zero; i++){
5301 const int dct_coeff= ABS(block[ scantable[i] ]);
5302 const int zero_distoration= dct_coeff*dct_coeff;
5303 int best_score=256*256*256*120;
5304 for(level_index=0; level_index < coeff_count[i]; level_index++){
5306 int level= coeff[level_index][i];
5307 const int alevel= ABS(level);
5312 if(s->out_format == FMT_H263){
5313 unquant_coeff= alevel*qmul + qadd;
5315 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
5317 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
5318 unquant_coeff = (unquant_coeff - 1) | 1;
5320 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
5321 unquant_coeff = (unquant_coeff - 1) | 1;
5326 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration;
5328 if((level&(~127)) == 0){
5329 for(j=survivor_count-1; j>=0; j--){
5330 int run= i - survivor[j];
5331 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5332 score += score_tab[i-run];
5334 if(score < best_score){
5337 level_tab[i+1]= level-64;
5341 if(s->out_format == FMT_H263){
5342 for(j=survivor_count-1; j>=0; j--){
5343 int run= i - survivor[j];
5344 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5345 score += score_tab[i-run];
5346 if(score < last_score){
5349 last_level= level-64;
5355 distoration += esc_length*lambda;
5356 for(j=survivor_count-1; j>=0; j--){
5357 int run= i - survivor[j];
5358 int score= distoration + score_tab[i-run];
5360 if(score < best_score){
5363 level_tab[i+1]= level-64;
5367 if(s->out_format == FMT_H263){
5368 for(j=survivor_count-1; j>=0; j--){
5369 int run= i - survivor[j];
5370 int score= distoration + score_tab[i-run];
5371 if(score < last_score){
5374 last_level= level-64;
5382 score_tab[i+1]= best_score;
5384 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
5385 if(last_non_zero <= 27){
5386 for(; survivor_count; survivor_count--){
5387 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
5391 for(; survivor_count; survivor_count--){
5392 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
5397 survivor[ survivor_count++ ]= i+1;
5400 if(s->out_format != FMT_H263){
5401 last_score= 256*256*256*120;
5402 for(i= survivor[0]; i<=last_non_zero + 1; i++){
5403 int score= score_tab[i];
5404 if(i) score += lambda*2; //FIXME exacter?
5406 if(score < last_score){
5409 last_level= level_tab[i];
5410 last_run= run_tab[i];
5415 s->coded_score[n] = last_score;
5418 last_non_zero= last_i - 1;
5419 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
5421 if(last_non_zero < start_i)
5422 return last_non_zero;
5424 if(last_non_zero == 0 && start_i == 0){
5426 int best_score= dc * dc;
5428 for(i=0; i<coeff_count[0]; i++){
5429 int level= coeff[i][0];
5430 int alevel= ABS(level);
5431 int unquant_coeff, score, distortion;
5433 if(s->out_format == FMT_H263){
5434 unquant_coeff= (alevel*qmul + qadd)>>3;
5436 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
5437 unquant_coeff = (unquant_coeff - 1) | 1;
5439 unquant_coeff = (unquant_coeff + 4) >> 3;
5440 unquant_coeff<<= 3 + 3;
5442 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
5444 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
5445 else score= distortion + esc_length*lambda;
5447 if(score < best_score){
5449 best_level= level - 64;
5452 block[0]= best_level;
5453 s->coded_score[n] = best_score - dc*dc;
5454 if(best_level == 0) return -1;
5455 else return last_non_zero;
5461 block[ perm_scantable[last_non_zero] ]= last_level;
5464 for(; i>start_i; i -= run_tab[i] + 1){
5465 block[ perm_scantable[i-1] ]= level_tab[i];
5468 return last_non_zero;
5471 //#define REFINE_STATS 1
5472 static int16_t basis[64][64];
5474 static void build_basis(uint8_t *perm){
5481 double s= 0.25*(1<<BASIS_SHIFT);
5483 int perm_index= perm[index];
5484 if(i==0) s*= sqrt(0.5);
5485 if(j==0) s*= sqrt(0.5);
5486 basis[perm_index][8*x + y]= lrintf(s * cos((M_PI/8.0)*i*(x+0.5)) * cos((M_PI/8.0)*j*(y+0.5)));
5493 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
5494 DCTELEM *block, int16_t *weight, DCTELEM *orig,
5499 const uint8_t *scantable= s->intra_scantable.scantable;
5500 const uint8_t *perm_scantable= s->intra_scantable.permutated;
5501 // unsigned int threshold1, threshold2;
5506 int qmul, qadd, start_i, last_non_zero, i, dc;
5508 uint8_t * last_length;
5510 int rle_index, run, q, sum;
5513 static int after_last=0;
5514 static int to_zero=0;
5515 static int from_zero=0;
5518 static int messed_sign=0;
5521 if(basis[0][0] == 0)
5522 build_basis(s->dsp.idct_permutation);
5533 /* For AIC we skip quant/dequant of INTRADC */
5537 q <<= RECON_SHIFT-3;
5538 /* note: block[0] is assumed to be positive */
5540 // block[0] = (block[0] + (q >> 1)) / q;
5542 qmat = s->q_intra_matrix[qscale];
5543 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
5544 // bias= 1<<(QMAT_SHIFT-1);
5545 length = s->intra_ac_vlc_length;
5546 last_length= s->intra_ac_vlc_last_length;
5550 qmat = s->q_inter_matrix[qscale];
5551 length = s->inter_ac_vlc_length;
5552 last_length= s->inter_ac_vlc_last_length;
5554 last_non_zero = s->block_last_index[n];
5559 dc += (1<<(RECON_SHIFT-1));
5560 for(i=0; i<64; i++){
5561 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly insteadof copying to rem[]
5564 STOP_TIMER("memset rem[]")}
5567 for(i=0; i<64; i++){
5572 w= ABS(weight[i]) + qns*one;
5573 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
5576 // w=weight[i] = (63*qns + (w/2)) / w;
5582 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
5588 for(i=start_i; i<=last_non_zero; i++){
5589 int j= perm_scantable[i];
5590 const int level= block[j];
5594 if(level<0) coeff= qmul*level - qadd;
5595 else coeff= qmul*level + qadd;
5596 run_tab[rle_index++]=run;
5599 s->dsp.add_8x8basis(rem, basis[j], coeff);
5605 if(last_non_zero>0){
5606 STOP_TIMER("init rem[]")
5613 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
5616 int run2, best_unquant_change=0, analyze_gradient;
5620 analyze_gradient = last_non_zero > 2 || s->avctx->quantizer_noise_shaping >= 3;
5622 if(analyze_gradient){
5626 for(i=0; i<64; i++){
5629 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
5632 STOP_TIMER("rem*w*w")}
5642 const int level= block[0];
5643 int change, old_coeff;
5645 assert(s->mb_intra);
5649 for(change=-1; change<=1; change+=2){
5650 int new_level= level + change;
5651 int score, new_coeff;
5653 new_coeff= q*new_level;
5654 if(new_coeff >= 2048 || new_coeff < 0)
5657 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
5658 if(score<best_score){
5661 best_change= change;
5662 best_unquant_change= new_coeff - old_coeff;
5669 run2= run_tab[rle_index++];
5673 for(i=start_i; i<64; i++){
5674 int j= perm_scantable[i];
5675 const int level= block[j];
5676 int change, old_coeff;
5678 if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
5682 if(level<0) old_coeff= qmul*level - qadd;
5683 else old_coeff= qmul*level + qadd;
5684 run2= run_tab[rle_index++]; //FIXME ! maybe after last
5688 assert(run2>=0 || i >= last_non_zero );
5691 for(change=-1; change<=1; change+=2){
5692 int new_level= level + change;
5693 int score, new_coeff, unquant_change;
5696 if(s->avctx->quantizer_noise_shaping < 2 && ABS(new_level) > ABS(level))
5700 if(new_level<0) new_coeff= qmul*new_level - qadd;
5701 else new_coeff= qmul*new_level + qadd;
5702 if(new_coeff >= 2048 || new_coeff <= -2048)
5704 //FIXME check for overflow
5707 if(level < 63 && level > -63){
5708 if(i < last_non_zero)
5709 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
5710 - length[UNI_AC_ENC_INDEX(run, level+64)];
5712 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
5713 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
5716 assert(ABS(new_level)==1);
5718 if(analyze_gradient){
5719 int g= d1[ scantable[i] ];
5720 if(g && (g^new_level) >= 0)
5724 if(i < last_non_zero){
5725 int next_i= i + run2 + 1;
5726 int next_level= block[ perm_scantable[next_i] ] + 64;
5728 if(next_level&(~127))
5731 if(next_i < last_non_zero)
5732 score += length[UNI_AC_ENC_INDEX(run, 65)]
5733 + length[UNI_AC_ENC_INDEX(run2, next_level)]
5734 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
5736 score += length[UNI_AC_ENC_INDEX(run, 65)]
5737 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
5738 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
5740 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
5742 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
5743 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
5749 assert(ABS(level)==1);
5751 if(i < last_non_zero){
5752 int next_i= i + run2 + 1;
5753 int next_level= block[ perm_scantable[next_i] ] + 64;
5755 if(next_level&(~127))
5758 if(next_i < last_non_zero)
5759 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
5760 - length[UNI_AC_ENC_INDEX(run2, next_level)]
5761 - length[UNI_AC_ENC_INDEX(run, 65)];
5763 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
5764 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
5765 - length[UNI_AC_ENC_INDEX(run, 65)];
5767 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
5769 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
5770 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
5777 unquant_change= new_coeff - old_coeff;
5778 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
5780 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
5781 if(score<best_score){
5784 best_change= change;
5785 best_unquant_change= unquant_change;
5789 prev_level= level + 64;
5790 if(prev_level&(~127))
5799 STOP_TIMER("iterative step")}
5803 int j= perm_scantable[ best_coeff ];
5805 block[j] += best_change;
5807 if(best_coeff > last_non_zero){
5808 last_non_zero= best_coeff;
5816 if(block[j] - best_change){
5817 if(ABS(block[j]) > ABS(block[j] - best_change)){
5829 for(; last_non_zero>=start_i; last_non_zero--){
5830 if(block[perm_scantable[last_non_zero]])
5836 if(256*256*256*64 % count == 0){
5837 printf("after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
5842 for(i=start_i; i<=last_non_zero; i++){
5843 int j= perm_scantable[i];
5844 const int level= block[j];
5847 run_tab[rle_index++]=run;
5854 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
5860 if(last_non_zero>0){
5861 STOP_TIMER("iterative search")
5866 return last_non_zero;
5869 static int dct_quantize_c(MpegEncContext *s,
5870 DCTELEM *block, int n,
5871 int qscale, int *overflow)
5873 int i, j, level, last_non_zero, q, start_i;
5875 const uint8_t *scantable= s->intra_scantable.scantable;
5878 unsigned int threshold1, threshold2;
5880 s->dsp.fdct (block);
5882 if(s->dct_error_sum)
5883 s->denoise_dct(s, block);
5893 /* For AIC we skip quant/dequant of INTRADC */
5896 /* note: block[0] is assumed to be positive */
5897 block[0] = (block[0] + (q >> 1)) / q;
5900 qmat = s->q_intra_matrix[qscale];
5901 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
5905 qmat = s->q_inter_matrix[qscale];
5906 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
5908 threshold1= (1<<QMAT_SHIFT) - bias - 1;
5909 threshold2= (threshold1<<1);
5910 for(i=63;i>=start_i;i--) {
5912 level = block[j] * qmat[j];
5914 if(((unsigned)(level+threshold1))>threshold2){
5921 for(i=start_i; i<=last_non_zero; i++) {
5923 level = block[j] * qmat[j];
5925 // if( bias+level >= (1<<QMAT_SHIFT)
5926 // || bias-level >= (1<<QMAT_SHIFT)){
5927 if(((unsigned)(level+threshold1))>threshold2){
5929 level= (bias + level)>>QMAT_SHIFT;
5932 level= (bias - level)>>QMAT_SHIFT;
5940 *overflow= s->max_qcoeff < max; //overflow might have happend
5942 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
5943 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
5944 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
5946 return last_non_zero;
5949 #endif //CONFIG_ENCODERS
5951 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
5952 DCTELEM *block, int n, int qscale)
5954 int i, level, nCoeffs;
5955 const uint16_t *quant_matrix;
5957 nCoeffs= s->block_last_index[n];
5960 block[0] = block[0] * s->y_dc_scale;
5962 block[0] = block[0] * s->c_dc_scale;
5963 /* XXX: only mpeg1 */
5964 quant_matrix = s->intra_matrix;
5965 for(i=1;i<=nCoeffs;i++) {
5966 int j= s->intra_scantable.permutated[i];
5971 level = (int)(level * qscale * quant_matrix[j]) >> 3;
5972 level = (level - 1) | 1;
5975 level = (int)(level * qscale * quant_matrix[j]) >> 3;
5976 level = (level - 1) | 1;
5983 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
5984 DCTELEM *block, int n, int qscale)
5986 int i, level, nCoeffs;
5987 const uint16_t *quant_matrix;
5989 nCoeffs= s->block_last_index[n];
5991 quant_matrix = s->inter_matrix;
5992 for(i=0; i<=nCoeffs; i++) {
5993 int j= s->intra_scantable.permutated[i];
5998 level = (((level << 1) + 1) * qscale *
5999 ((int) (quant_matrix[j]))) >> 4;
6000 level = (level - 1) | 1;
6003 level = (((level << 1) + 1) * qscale *
6004 ((int) (quant_matrix[j]))) >> 4;
6005 level = (level - 1) | 1;
6012 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
6013 DCTELEM *block, int n, int qscale)
6015 int i, level, nCoeffs;
6016 const uint16_t *quant_matrix;
6018 if(s->alternate_scan) nCoeffs= 63;
6019 else nCoeffs= s->block_last_index[n];
6022 block[0] = block[0] * s->y_dc_scale;
6024 block[0] = block[0] * s->c_dc_scale;
6025 quant_matrix = s->intra_matrix;
6026 for(i=1;i<=nCoeffs;i++) {
6027 int j= s->intra_scantable.permutated[i];
6032 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6035 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6042 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
6043 DCTELEM *block, int n, int qscale)
6045 int i, level, nCoeffs;
6046 const uint16_t *quant_matrix;
6049 if(s->alternate_scan) nCoeffs= 63;
6050 else nCoeffs= s->block_last_index[n];
6052 quant_matrix = s->inter_matrix;
6053 for(i=0; i<=nCoeffs; i++) {
6054 int j= s->intra_scantable.permutated[i];
6059 level = (((level << 1) + 1) * qscale *
6060 ((int) (quant_matrix[j]))) >> 4;
6063 level = (((level << 1) + 1) * qscale *
6064 ((int) (quant_matrix[j]))) >> 4;
6073 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
6074 DCTELEM *block, int n, int qscale)
6076 int i, level, qmul, qadd;
6079 assert(s->block_last_index[n]>=0);
6085 block[0] = block[0] * s->y_dc_scale;
6087 block[0] = block[0] * s->c_dc_scale;
6088 qadd = (qscale - 1) | 1;
6095 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6097 for(i=1; i<=nCoeffs; i++) {
6101 level = level * qmul - qadd;
6103 level = level * qmul + qadd;
6110 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
6111 DCTELEM *block, int n, int qscale)
6113 int i, level, qmul, qadd;
6116 assert(s->block_last_index[n]>=0);
6118 qadd = (qscale - 1) | 1;
6121 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6123 for(i=0; i<=nCoeffs; i++) {
6127 level = level * qmul - qadd;
6129 level = level * qmul + qadd;
6136 static void dct_unquantize_h261_intra_c(MpegEncContext *s,
6137 DCTELEM *block, int n, int qscale)
6142 assert(s->block_last_index[n]>=0);
6145 block[0] = block[0] * s->y_dc_scale;
6147 block[0] = block[0] * s->c_dc_scale;
6148 even = (qscale & 1)^1;
6149 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6151 for(i=1; i<=nCoeffs; i++){
6155 level = qscale * ((level << 1) - 1) + even;
6157 level = qscale * ((level << 1) + 1) - even;
6164 static void dct_unquantize_h261_inter_c(MpegEncContext *s,
6165 DCTELEM *block, int n, int qscale)
6170 assert(s->block_last_index[n]>=0);
6172 even = (qscale & 1)^1;
6174 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6176 for(i=0; i<=nCoeffs; i++){
6180 level = qscale * ((level << 1) - 1) + even;
6182 level = qscale * ((level << 1) + 1) - even;
6189 static const AVOption mpeg4_options[] =
6191 AVOPTION_CODEC_INT("bitrate", "desired video bitrate", bit_rate, 4, 240000000, 800000),
6192 AVOPTION_CODEC_INT("ratetol", "number of bits the bitstream is allowed to diverge from the reference"
6193 "the reference can be CBR (for CBR pass1) or VBR (for pass2)",
6194 bit_rate_tolerance, 4, 240000000, 8000),
6195 AVOPTION_CODEC_INT("qmin", "minimum quantizer", qmin, 1, 31, 2),
6196 AVOPTION_CODEC_INT("qmax", "maximum quantizer", qmax, 1, 31, 31),
6197 AVOPTION_CODEC_STRING("rc_eq", "rate control equation",
6198 rc_eq, "tex^qComp,option1,options2", 0),
6199 AVOPTION_CODEC_INT("rc_minrate", "rate control minimum bitrate",
6200 rc_min_rate, 4, 24000000, 0),
6201 AVOPTION_CODEC_INT("rc_maxrate", "rate control maximum bitrate",
6202 rc_max_rate, 4, 24000000, 0),
6203 AVOPTION_CODEC_DOUBLE("rc_buf_aggresivity", "rate control buffer aggresivity",
6204 rc_buffer_aggressivity, 4, 24000000, 0),
6205 AVOPTION_CODEC_DOUBLE("rc_initial_cplx", "initial complexity for pass1 ratecontrol",
6206 rc_initial_cplx, 0., 9999999., 0),
6207 AVOPTION_CODEC_DOUBLE("i_quant_factor", "qscale factor between p and i frames",
6208 i_quant_factor, 0., 0., 0),
6209 AVOPTION_CODEC_DOUBLE("i_quant_offset", "qscale offset between p and i frames",
6210 i_quant_factor, -999999., 999999., 0),
6211 AVOPTION_CODEC_INT("dct_algo", "dct alghorithm",
6212 dct_algo, 0, 5, 0), // fixme - "Auto,FastInt,Int,MMX,MLib,Altivec"
6213 AVOPTION_CODEC_DOUBLE("lumi_masking", "luminance masking",
6214 lumi_masking, 0., 999999., 0),
6215 AVOPTION_CODEC_DOUBLE("temporal_cplx_masking", "temporary complexity masking",
6216 temporal_cplx_masking, 0., 999999., 0),
6217 AVOPTION_CODEC_DOUBLE("spatial_cplx_masking", "spatial complexity masking",
6218 spatial_cplx_masking, 0., 999999., 0),
6219 AVOPTION_CODEC_DOUBLE("p_masking", "p block masking",
6220 p_masking, 0., 999999., 0),
6221 AVOPTION_CODEC_DOUBLE("dark_masking", "darkness masking",
6222 dark_masking, 0., 999999., 0),
6223 AVOPTION_CODEC_INT("idct_algo", "idct alghorithm",
6224 idct_algo, 0, 8, 0), // fixme - "Auto,Int,Simple,SimpleMMX,LibMPEG2MMX,PS2,MLib,ARM,Altivec"
6226 AVOPTION_CODEC_INT("mb_qmin", "minimum MB quantizer",
6228 AVOPTION_CODEC_INT("mb_qmax", "maximum MB quantizer",
6231 AVOPTION_CODEC_INT("me_cmp", "ME compare function",
6232 me_cmp, 0, 24000000, 0),
6233 AVOPTION_CODEC_INT("me_sub_cmp", "subpixel ME compare function",
6234 me_sub_cmp, 0, 24000000, 0),
6237 AVOPTION_CODEC_INT("dia_size", "ME diamond size & shape",
6238 dia_size, 0, 24000000, 0),
6239 AVOPTION_CODEC_INT("last_predictor_count", "amount of previous MV predictors",
6240 last_predictor_count, 0, 24000000, 0),
6242 AVOPTION_CODEC_INT("pre_me", "pre pass for ME",
6243 pre_me, 0, 24000000, 0),
6244 AVOPTION_CODEC_INT("me_pre_cmp", "ME pre pass compare function",
6245 me_pre_cmp, 0, 24000000, 0),
6247 AVOPTION_CODEC_INT("me_range", "maximum ME search range",
6248 me_range, 0, 24000000, 0),
6249 AVOPTION_CODEC_INT("pre_dia_size", "ME pre pass diamod size & shape",
6250 pre_dia_size, 0, 24000000, 0),
6251 AVOPTION_CODEC_INT("me_subpel_quality", "subpel ME quality",
6252 me_subpel_quality, 0, 24000000, 0),
6253 AVOPTION_CODEC_INT("me_range", "maximum ME search range",
6254 me_range, 0, 24000000, 0),
6255 AVOPTION_CODEC_FLAG("psnr", "calculate PSNR of compressed frames",
6256 flags, CODEC_FLAG_PSNR, 0),
6257 AVOPTION_CODEC_RCOVERRIDE("rc_override", "ratecontrol override (=startframe,endframe,qscale,quality_factor)",
6259 AVOPTION_SUB(avoptions_common),
6263 #ifdef CONFIG_ENCODERS
6265 AVCodec h263_encoder = {
6269 sizeof(MpegEncContext),
6275 AVCodec h263p_encoder = {
6279 sizeof(MpegEncContext),
6285 AVCodec flv_encoder = {
6289 sizeof(MpegEncContext),
6295 AVCodec rv10_encoder = {
6299 sizeof(MpegEncContext),
6305 AVCodec mpeg4_encoder = {
6309 sizeof(MpegEncContext),
6313 .options = mpeg4_options,
6314 .capabilities= CODEC_CAP_DELAY,
6317 AVCodec msmpeg4v1_encoder = {
6321 sizeof(MpegEncContext),
6325 .options = mpeg4_options,
6328 AVCodec msmpeg4v2_encoder = {
6332 sizeof(MpegEncContext),
6336 .options = mpeg4_options,
6339 AVCodec msmpeg4v3_encoder = {
6343 sizeof(MpegEncContext),
6347 .options = mpeg4_options,
6350 AVCodec wmv1_encoder = {
6354 sizeof(MpegEncContext),
6358 .options = mpeg4_options,
6363 AVCodec mjpeg_encoder = {
6367 sizeof(MpegEncContext),
6373 #endif //CONFIG_ENCODERS