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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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 "libvo/fastmemcpy.h"
41 #ifdef CONFIG_ENCODERS
42 static int 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_intra_bitexact(MpegEncContext *s,
51 DCTELEM *block, int n, int qscale);
52 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
53 DCTELEM *block, int n, int qscale);
54 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
55 DCTELEM *block, int n, int qscale);
56 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
57 DCTELEM *block, int n, int qscale);
58 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w);
59 #ifdef CONFIG_ENCODERS
60 static int dct_quantize_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
61 static int dct_quantize_trellis_c(MpegEncContext *s, DCTELEM *block, int n, int qscale, int *overflow);
62 static int dct_quantize_refine(MpegEncContext *s, DCTELEM *block, int16_t *weight, DCTELEM *orig, int n, int qscale);
63 static int sse_mb(MpegEncContext *s);
64 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block);
65 #endif //CONFIG_ENCODERS
68 extern int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx);
69 extern void XVMC_field_end(MpegEncContext *s);
70 extern void XVMC_decode_mb(MpegEncContext *s);
73 void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w)= draw_edges_c;
76 /* enable all paranoid tests for rounding, overflows, etc... */
82 /* for jpeg fast DCT */
85 static const uint16_t aanscales[64] = {
86 /* precomputed values scaled up by 14 bits */
87 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
88 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
89 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
90 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
91 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
92 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
93 8867 , 12299, 11585, 10426, 8867, 6967, 4799, 2446,
94 4520 , 6270, 5906, 5315, 4520, 3552, 2446, 1247
97 static const uint8_t h263_chroma_roundtab[16] = {
98 // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
99 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
102 static const uint8_t ff_default_chroma_qscale_table[32]={
103 // 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
104 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
107 #ifdef CONFIG_ENCODERS
108 static uint8_t (*default_mv_penalty)[MAX_MV*2+1]=NULL;
109 static uint8_t default_fcode_tab[MAX_MV*2+1];
111 enum PixelFormat ff_yuv420p_list[2]= {PIX_FMT_YUV420P, -1};
113 static void convert_matrix(DSPContext *dsp, int (*qmat)[64], uint16_t (*qmat16)[2][64],
114 const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
119 for(qscale=qmin; qscale<=qmax; qscale++){
121 if (dsp->fdct == ff_jpeg_fdct_islow
122 #ifdef FAAN_POSTSCALE
123 || dsp->fdct == ff_faandct
127 const int j= dsp->idct_permutation[i];
128 /* 16 <= qscale * quant_matrix[i] <= 7905 */
129 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
130 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
131 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
133 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) /
134 (qscale * quant_matrix[j]));
136 } else if (dsp->fdct == fdct_ifast
137 #ifndef FAAN_POSTSCALE
138 || dsp->fdct == ff_faandct
142 const int j= dsp->idct_permutation[i];
143 /* 16 <= qscale * quant_matrix[i] <= 7905 */
144 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
145 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
146 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
148 qmat[qscale][i] = (int)((uint64_t_C(1) << (QMAT_SHIFT + 14)) /
149 (aanscales[i] * qscale * quant_matrix[j]));
153 const int j= dsp->idct_permutation[i];
154 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
155 So 16 <= qscale * quant_matrix[i] <= 7905
156 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
157 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
159 qmat[qscale][i] = (int)((uint64_t_C(1) << QMAT_SHIFT) / (qscale * quant_matrix[j]));
160 // qmat [qscale][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[i]);
161 qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / (qscale * quant_matrix[j]);
163 if(qmat16[qscale][0][i]==0 || qmat16[qscale][0][i]==128*256) qmat16[qscale][0][i]=128*256-1;
164 qmat16[qscale][1][i]= ROUNDED_DIV(bias<<(16-QUANT_BIAS_SHIFT), qmat16[qscale][0][i]);
168 for(i=intra; i<64; i++){
170 if (dsp->fdct == fdct_ifast
171 #ifndef FAAN_POSTSCALE
172 || dsp->fdct == ff_faandct
175 max= (8191LL*aanscales[i]) >> 14;
177 while(((max * qmat[qscale][i]) >> shift) > INT_MAX){
183 av_log(NULL, AV_LOG_INFO, "Warning, QMAT_SHIFT is larger then %d, overflows possible\n", QMAT_SHIFT - shift);
187 static inline void update_qscale(MpegEncContext *s){
188 s->qscale= (s->lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
189 s->qscale= clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
191 s->lambda2= (s->lambda*s->lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
193 #endif //CONFIG_ENCODERS
195 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
199 st->scantable= src_scantable;
203 j = src_scantable[i];
204 st->permutated[i] = permutation[j];
213 j = st->permutated[i];
215 st->raster_end[i]= end;
219 #ifdef CONFIG_ENCODERS
220 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix){
226 put_bits(pb, 8, matrix[ ff_zigzag_direct[i] ]);
231 #endif //CONFIG_ENCODERS
233 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
241 uint32_t tmp= *state << 8;
242 *state= tmp + *(p++);
243 if(tmp == 0x100 || p==end)
248 if (p[-1] > 1 ) p+= 3;
249 else if(p[-2] ) p+= 2;
250 else if(p[-3]|(p[-1]-1)) p++;
258 *state= be2me_32(unaligned32(p));
263 /* init common dct for both encoder and decoder */
264 int DCT_common_init(MpegEncContext *s)
266 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
267 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
268 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
269 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
270 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
271 if(s->flags & CODEC_FLAG_BITEXACT)
272 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
273 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
275 #ifdef CONFIG_ENCODERS
276 s->dct_quantize= dct_quantize_c;
277 s->denoise_dct= denoise_dct_c;
278 #endif //CONFIG_ENCODERS
281 MPV_common_init_mmx(s);
284 MPV_common_init_axp(s);
287 MPV_common_init_mlib(s);
290 MPV_common_init_mmi(s);
293 MPV_common_init_armv4l(s);
296 MPV_common_init_ppc(s);
299 #ifdef CONFIG_ENCODERS
300 s->fast_dct_quantize= s->dct_quantize;
302 if(s->flags&CODEC_FLAG_TRELLIS_QUANT){
303 s->dct_quantize= dct_quantize_trellis_c; //move before MPV_common_init_*
306 #endif //CONFIG_ENCODERS
308 /* load & permutate scantables
309 note: only wmv uses different ones
311 if(s->alternate_scan){
312 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
313 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
315 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
316 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
318 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
319 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
324 static void copy_picture(Picture *dst, Picture *src){
326 dst->type= FF_BUFFER_TYPE_COPY;
329 #ifdef CONFIG_ENCODERS
330 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
333 dst->pict_type = src->pict_type;
334 dst->quality = src->quality;
335 dst->coded_picture_number = src->coded_picture_number;
336 dst->display_picture_number = src->display_picture_number;
337 // dst->reference = src->reference;
339 dst->interlaced_frame = src->interlaced_frame;
340 dst->top_field_first = src->top_field_first;
342 if(s->avctx->me_threshold){
343 if(!src->motion_val[0])
344 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
346 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
347 if(!src->ref_index[0])
348 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
349 if(src->motion_subsample_log2 != dst->motion_subsample_log2)
350 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
351 src->motion_subsample_log2, dst->motion_subsample_log2);
353 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
356 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
357 int height= ((16*s->mb_height)>>src->motion_subsample_log2);
359 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
360 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
362 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
363 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
371 * allocates a Picture
372 * The pixels are allocated/set by calling get_buffer() if shared=0
374 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
375 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
376 const int mb_array_size= s->mb_stride*s->mb_height;
377 const int b8_array_size= s->b8_stride*s->mb_height*2;
378 const int b4_array_size= s->b4_stride*s->mb_height*4;
382 assert(pic->data[0]);
383 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
384 pic->type= FF_BUFFER_TYPE_SHARED;
388 assert(!pic->data[0]);
390 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
392 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
393 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
397 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
398 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
402 if(pic->linesize[1] != pic->linesize[2]){
403 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
407 s->linesize = pic->linesize[0];
408 s->uvlinesize= pic->linesize[1];
411 if(pic->qscale_table==NULL){
413 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
414 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
415 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
418 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
419 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
420 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
421 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
422 if(s->out_format == FMT_H264){
424 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t))
425 pic->motion_val[i]= pic->motion_val_base[i]+4;
426 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
428 pic->motion_subsample_log2= 2;
429 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
431 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
432 pic->motion_val[i]= pic->motion_val_base[i]+4;
433 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
435 pic->motion_subsample_log2= 3;
437 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
438 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
440 pic->qstride= s->mb_stride;
441 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
444 //it might be nicer if the application would keep track of these but it would require a API change
445 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
446 s->prev_pict_types[0]= s->pict_type;
447 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
448 pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
451 fail: //for the CHECKED_ALLOCZ macro
456 * deallocates a picture
458 static void free_picture(MpegEncContext *s, Picture *pic){
461 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
462 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
465 av_freep(&pic->mb_var);
466 av_freep(&pic->mc_mb_var);
467 av_freep(&pic->mb_mean);
468 av_freep(&pic->mbskip_table);
469 av_freep(&pic->qscale_table);
470 av_freep(&pic->mb_type_base);
471 av_freep(&pic->dct_coeff);
472 av_freep(&pic->pan_scan);
475 av_freep(&pic->motion_val_base[i]);
476 av_freep(&pic->ref_index[i]);
479 if(pic->type == FF_BUFFER_TYPE_SHARED){
488 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
491 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
492 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
493 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
495 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
496 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
497 s->rd_scratchpad= s->me.scratchpad;
498 s->b_scratchpad= s->me.scratchpad;
499 s->obmc_scratchpad= s->me.scratchpad + 16;
501 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
502 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
503 if(s->avctx->noise_reduction){
504 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
507 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
508 s->block= s->blocks[0];
511 s->pblocks[i] = (short *)(&s->block[i]);
515 return -1; //free() through MPV_common_end()
518 static void free_duplicate_context(MpegEncContext *s){
521 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
522 av_freep(&s->me.scratchpad);
525 s->obmc_scratchpad= NULL;
527 av_freep(&s->dct_error_sum);
528 av_freep(&s->me.map);
529 av_freep(&s->me.score_map);
530 av_freep(&s->blocks);
534 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
535 #define COPY(a) bak->a= src->a
536 COPY(allocated_edge_emu_buffer);
537 COPY(edge_emu_buffer);
541 COPY(obmc_scratchpad);
548 COPY(me.map_generation);
556 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
559 //FIXME copy only needed parts
561 backup_duplicate_context(&bak, dst);
562 memcpy(dst, src, sizeof(MpegEncContext));
563 backup_duplicate_context(dst, &bak);
565 dst->pblocks[i] = (short *)(&dst->block[i]);
567 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
570 #ifdef CONFIG_ENCODERS
571 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
572 #define COPY(a) dst->a= src->a
574 COPY(current_picture);
580 COPY(picture_in_gop_number);
581 COPY(gop_picture_number);
582 COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
583 COPY(progressive_frame); //FIXME don't set in encode_header
584 COPY(partitioned_frame); //FIXME don't set in encode_header
590 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
591 * the changed fields will not depend upon the prior state of the MpegEncContext.
593 static void MPV_common_defaults(MpegEncContext *s){
595 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
596 s->chroma_qscale_table= ff_default_chroma_qscale_table;
597 s->progressive_frame= 1;
598 s->progressive_sequence= 1;
599 s->picture_structure= PICT_FRAME;
601 s->coded_picture_number = 0;
602 s->picture_number = 0;
603 s->input_picture_number = 0;
605 s->picture_in_gop_number = 0;
612 * sets the given MpegEncContext to defaults for decoding.
613 * the changed fields will not depend upon the prior state of the MpegEncContext.
615 void MPV_decode_defaults(MpegEncContext *s){
616 MPV_common_defaults(s);
620 * sets the given MpegEncContext to defaults for encoding.
621 * the changed fields will not depend upon the prior state of the MpegEncContext.
624 #ifdef CONFIG_ENCODERS
625 static void MPV_encode_defaults(MpegEncContext *s){
628 MPV_common_defaults(s);
634 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
635 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
637 for(i=-16; i<16; i++){
638 default_fcode_tab[i + MAX_MV]= 1;
641 s->me.mv_penalty= default_mv_penalty;
642 s->fcode_tab= default_fcode_tab;
644 #endif //CONFIG_ENCODERS
647 * init common structure for both encoder and decoder.
648 * this assumes that some variables like width/height are already set
650 int MPV_common_init(MpegEncContext *s)
652 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
654 s->mb_height = (s->height + 15) / 16;
656 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
657 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
661 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
664 dsputil_init(&s->dsp, s->avctx);
667 s->flags= s->avctx->flags;
668 s->flags2= s->avctx->flags2;
670 s->mb_width = (s->width + 15) / 16;
671 s->mb_stride = s->mb_width + 1;
672 s->b8_stride = s->mb_width*2 + 1;
673 s->b4_stride = s->mb_width*4 + 1;
674 mb_array_size= s->mb_height * s->mb_stride;
675 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
677 /* set chroma shifts */
678 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
679 &(s->chroma_y_shift) );
681 /* set default edge pos, will be overriden in decode_header if needed */
682 s->h_edge_pos= s->mb_width*16;
683 s->v_edge_pos= s->mb_height*16;
685 s->mb_num = s->mb_width * s->mb_height;
690 s->block_wrap[3]= s->b8_stride;
692 s->block_wrap[5]= s->mb_stride;
694 y_size = s->b8_stride * (2 * s->mb_height + 1);
695 c_size = s->mb_stride * (s->mb_height + 1);
696 yc_size = y_size + 2 * c_size;
698 /* convert fourcc to upper case */
699 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
700 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
701 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
702 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
704 s->avctx->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
705 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
706 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
707 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
709 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
711 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
712 for(y=0; y<s->mb_height; y++){
713 for(x=0; x<s->mb_width; x++){
714 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
717 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
720 /* Allocate MV tables */
721 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
722 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
723 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
724 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
725 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
726 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
727 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
728 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
729 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
730 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
731 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
732 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
734 if(s->msmpeg4_version){
735 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
737 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
739 /* Allocate MB type table */
740 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
742 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
744 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
745 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
746 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
747 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
748 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
749 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
751 if(s->avctx->noise_reduction){
752 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
755 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
757 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
759 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
760 /* interlaced direct mode decoding tables */
765 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
766 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
768 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
769 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
770 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
772 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
775 if (s->out_format == FMT_H263) {
777 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
778 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
779 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
780 s->ac_val[2] = s->ac_val[1] + c_size;
783 CHECKED_ALLOCZ(s->coded_block_base, y_size);
784 s->coded_block= s->coded_block_base + s->b8_stride + 1;
786 /* cbp, ac_pred, pred_dir */
787 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
788 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
791 if (s->h263_pred || s->h263_plus || !s->encoding) {
793 //MN: we need these for error resilience of intra-frames
794 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
795 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
796 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
797 s->dc_val[2] = s->dc_val[1] + c_size;
798 for(i=0;i<yc_size;i++)
799 s->dc_val_base[i] = 1024;
802 /* which mb is a intra block */
803 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
804 memset(s->mbintra_table, 1, mb_array_size);
806 /* init macroblock skip table */
807 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
808 //Note the +1 is for a quicker mpeg4 slice_end detection
809 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
811 s->parse_context.state= -1;
812 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
813 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
814 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
815 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
818 s->context_initialized = 1;
820 s->thread_context[0]= s;
821 for(i=1; i<s->avctx->thread_count; i++){
822 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
823 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
826 for(i=0; i<s->avctx->thread_count; i++){
827 if(init_duplicate_context(s->thread_context[i], s) < 0)
829 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
830 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
839 /* init common structure for both encoder and decoder */
840 void MPV_common_end(MpegEncContext *s)
844 for(i=0; i<s->avctx->thread_count; i++){
845 free_duplicate_context(s->thread_context[i]);
847 for(i=1; i<s->avctx->thread_count; i++){
848 av_freep(&s->thread_context[i]);
851 av_freep(&s->parse_context.buffer);
852 s->parse_context.buffer_size=0;
854 av_freep(&s->mb_type);
855 av_freep(&s->p_mv_table_base);
856 av_freep(&s->b_forw_mv_table_base);
857 av_freep(&s->b_back_mv_table_base);
858 av_freep(&s->b_bidir_forw_mv_table_base);
859 av_freep(&s->b_bidir_back_mv_table_base);
860 av_freep(&s->b_direct_mv_table_base);
862 s->b_forw_mv_table= NULL;
863 s->b_back_mv_table= NULL;
864 s->b_bidir_forw_mv_table= NULL;
865 s->b_bidir_back_mv_table= NULL;
866 s->b_direct_mv_table= NULL;
870 av_freep(&s->b_field_mv_table_base[i][j][k]);
871 s->b_field_mv_table[i][j][k]=NULL;
873 av_freep(&s->b_field_select_table[i][j]);
874 av_freep(&s->p_field_mv_table_base[i][j]);
875 s->p_field_mv_table[i][j]=NULL;
877 av_freep(&s->p_field_select_table[i]);
880 av_freep(&s->dc_val_base);
881 av_freep(&s->ac_val_base);
882 av_freep(&s->coded_block_base);
883 av_freep(&s->mbintra_table);
884 av_freep(&s->cbp_table);
885 av_freep(&s->pred_dir_table);
887 av_freep(&s->mbskip_table);
888 av_freep(&s->prev_pict_types);
889 av_freep(&s->bitstream_buffer);
890 s->allocated_bitstream_buffer_size=0;
892 av_freep(&s->avctx->stats_out);
893 av_freep(&s->ac_stats);
894 av_freep(&s->error_status_table);
895 av_freep(&s->mb_index2xy);
896 av_freep(&s->lambda_table);
897 av_freep(&s->q_intra_matrix);
898 av_freep(&s->q_inter_matrix);
899 av_freep(&s->q_intra_matrix16);
900 av_freep(&s->q_inter_matrix16);
901 av_freep(&s->input_picture);
902 av_freep(&s->reordered_input_picture);
903 av_freep(&s->dct_offset);
906 for(i=0; i<MAX_PICTURE_COUNT; i++){
907 free_picture(s, &s->picture[i]);
910 av_freep(&s->picture);
911 s->context_initialized = 0;
914 s->current_picture_ptr= NULL;
915 s->linesize= s->uvlinesize= 0;
918 av_freep(&s->visualization_buffer[i]);
920 avcodec_default_free_buffers(s->avctx);
923 #ifdef CONFIG_ENCODERS
925 /* init video encoder */
926 int MPV_encode_init(AVCodecContext *avctx)
928 MpegEncContext *s = avctx->priv_data;
930 int chroma_h_shift, chroma_v_shift;
932 MPV_encode_defaults(s);
934 switch (avctx->codec_id) {
935 case CODEC_ID_MPEG2VIDEO:
936 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){
937 av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n");
943 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && (avctx->pix_fmt != PIX_FMT_YUV420P || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){
944 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
949 if(avctx->pix_fmt != PIX_FMT_YUV420P){
950 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
955 switch (avctx->pix_fmt) {
956 case PIX_FMT_YUVJ422P:
957 case PIX_FMT_YUV422P:
958 s->chroma_format = CHROMA_422;
960 case PIX_FMT_YUVJ420P:
961 case PIX_FMT_YUV420P:
963 s->chroma_format = CHROMA_420;
967 s->bit_rate = avctx->bit_rate;
968 s->width = avctx->width;
969 s->height = avctx->height;
970 if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
971 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
974 s->gop_size = avctx->gop_size;
976 s->flags= avctx->flags;
977 s->flags2= avctx->flags2;
978 s->max_b_frames= avctx->max_b_frames;
979 s->codec_id= avctx->codec->id;
980 s->luma_elim_threshold = avctx->luma_elim_threshold;
981 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
982 s->strict_std_compliance= avctx->strict_std_compliance;
983 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
984 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
985 s->mpeg_quant= avctx->mpeg_quant;
986 s->rtp_mode= !!avctx->rtp_payload_size;
987 s->intra_dc_precision= avctx->intra_dc_precision;
988 s->user_specified_pts = AV_NOPTS_VALUE;
990 if (s->gop_size <= 1) {
997 s->me_method = avctx->me_method;
1000 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
1002 s->adaptive_quant= ( s->avctx->lumi_masking
1003 || s->avctx->dark_masking
1004 || s->avctx->temporal_cplx_masking
1005 || s->avctx->spatial_cplx_masking
1006 || s->avctx->p_masking
1007 || s->avctx->border_masking
1008 || (s->flags&CODEC_FLAG_QP_RD))
1009 && !s->fixed_qscale;
1011 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
1012 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
1013 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
1014 s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
1016 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
1017 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
1021 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
1022 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
1025 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
1026 av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
1030 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
1031 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
1035 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
1036 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
1037 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
1039 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");
1042 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
1043 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
1044 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
1048 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
1049 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
1053 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
1054 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
1058 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1059 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1063 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1064 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1068 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1069 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1073 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1074 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1075 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1079 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1080 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1084 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1085 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1089 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1090 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1094 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1095 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1099 if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){
1100 av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n");
1104 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1105 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1106 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1107 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1111 if(s->avctx->thread_count > 1)
1114 if(!avctx->time_base.den || !avctx->time_base.num){
1115 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1119 i= (INT_MAX/2+128)>>8;
1120 if(avctx->me_threshold >= i){
1121 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1124 if(avctx->mb_threshold >= i){
1125 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1129 if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1130 av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
1131 avctx->b_frame_strategy = 0;
1134 i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1136 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1137 avctx->time_base.den /= i;
1138 avctx->time_base.num /= i;
1142 if(s->codec_id==CODEC_ID_MJPEG){
1143 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1144 s->inter_quant_bias= 0;
1145 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1146 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1147 s->inter_quant_bias= 0;
1149 s->intra_quant_bias=0;
1150 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1153 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1154 s->intra_quant_bias= avctx->intra_quant_bias;
1155 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1156 s->inter_quant_bias= avctx->inter_quant_bias;
1158 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1160 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1161 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1164 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1166 switch(avctx->codec->id) {
1167 case CODEC_ID_MPEG1VIDEO:
1168 s->out_format = FMT_MPEG1;
1169 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1170 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1172 case CODEC_ID_MPEG2VIDEO:
1173 s->out_format = FMT_MPEG1;
1174 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1175 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1178 case CODEC_ID_LJPEG:
1179 case CODEC_ID_JPEGLS:
1180 case CODEC_ID_MJPEG:
1181 s->out_format = FMT_MJPEG;
1182 s->intra_only = 1; /* force intra only for jpeg */
1183 s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1184 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1185 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1186 s->mjpeg_vsample[1] = 1;
1187 s->mjpeg_vsample[2] = 1;
1188 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1189 s->mjpeg_hsample[1] = 1;
1190 s->mjpeg_hsample[2] = 1;
1191 if (mjpeg_init(s) < 0)
1197 s->out_format = FMT_H261;
1202 if (h263_get_picture_format(s->width, s->height) == 7) {
1203 av_log(avctx, AV_LOG_INFO, "The specified picture size of %dx%d is not valid for the H.263 codec.\nValid sizes are 128x96, 176x144, 352x288, 704x576, and 1408x1152. Try H.263+.\n", s->width, s->height);
1206 s->out_format = FMT_H263;
1207 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1211 case CODEC_ID_H263P:
1212 s->out_format = FMT_H263;
1215 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1216 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1217 s->modified_quant= s->h263_aic;
1218 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1219 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1220 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1221 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1222 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1225 /* These are just to be sure */
1230 s->out_format = FMT_H263;
1231 s->h263_flv = 2; /* format = 1; 11-bit codes */
1232 s->unrestricted_mv = 1;
1233 s->rtp_mode=0; /* don't allow GOB */
1238 s->out_format = FMT_H263;
1243 s->out_format = FMT_H263;
1246 s->modified_quant=1;
1250 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1252 case CODEC_ID_MPEG4:
1253 s->out_format = FMT_H263;
1255 s->unrestricted_mv = 1;
1256 s->low_delay= s->max_b_frames ? 0 : 1;
1257 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1259 case CODEC_ID_MSMPEG4V1:
1260 s->out_format = FMT_H263;
1261 s->h263_msmpeg4 = 1;
1263 s->unrestricted_mv = 1;
1264 s->msmpeg4_version= 1;
1268 case CODEC_ID_MSMPEG4V2:
1269 s->out_format = FMT_H263;
1270 s->h263_msmpeg4 = 1;
1272 s->unrestricted_mv = 1;
1273 s->msmpeg4_version= 2;
1277 case CODEC_ID_MSMPEG4V3:
1278 s->out_format = FMT_H263;
1279 s->h263_msmpeg4 = 1;
1281 s->unrestricted_mv = 1;
1282 s->msmpeg4_version= 3;
1283 s->flipflop_rounding=1;
1288 s->out_format = FMT_H263;
1289 s->h263_msmpeg4 = 1;
1291 s->unrestricted_mv = 1;
1292 s->msmpeg4_version= 4;
1293 s->flipflop_rounding=1;
1298 s->out_format = FMT_H263;
1299 s->h263_msmpeg4 = 1;
1301 s->unrestricted_mv = 1;
1302 s->msmpeg4_version= 5;
1303 s->flipflop_rounding=1;
1311 avctx->has_b_frames= !s->low_delay;
1316 if (MPV_common_init(s) < 0)
1319 if(s->modified_quant)
1320 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1321 s->progressive_frame=
1322 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1323 s->quant_precision=5;
1325 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1326 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1328 #ifdef CONFIG_H261_ENCODER
1329 if (s->out_format == FMT_H261)
1330 ff_h261_encode_init(s);
1332 if (s->out_format == FMT_H263)
1333 h263_encode_init(s);
1334 if(s->msmpeg4_version)
1335 ff_msmpeg4_encode_init(s);
1336 if (s->out_format == FMT_MPEG1)
1337 ff_mpeg1_encode_init(s);
1341 int j= s->dsp.idct_permutation[i];
1342 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1343 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1344 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1345 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1346 s->intra_matrix[j] =
1347 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1350 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1351 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1353 if(s->avctx->intra_matrix)
1354 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1355 if(s->avctx->inter_matrix)
1356 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1359 /* precompute matrix */
1360 /* for mjpeg, we do include qscale in the matrix */
1361 if (s->out_format != FMT_MJPEG) {
1362 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1363 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1364 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1365 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1368 if(ff_rate_control_init(s) < 0)
1374 int MPV_encode_end(AVCodecContext *avctx)
1376 MpegEncContext *s = avctx->priv_data;
1378 ff_rate_control_uninit(s);
1381 if (s->out_format == FMT_MJPEG)
1384 av_freep(&avctx->extradata);
1389 #endif //CONFIG_ENCODERS
1391 void init_rl(RLTable *rl, int use_static)
1393 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1394 uint8_t index_run[MAX_RUN+1];
1395 int last, run, level, start, end, i;
1397 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1398 if(use_static && rl->max_level[0])
1401 /* compute max_level[], max_run[] and index_run[] */
1402 for(last=0;last<2;last++) {
1411 memset(max_level, 0, MAX_RUN + 1);
1412 memset(max_run, 0, MAX_LEVEL + 1);
1413 memset(index_run, rl->n, MAX_RUN + 1);
1414 for(i=start;i<end;i++) {
1415 run = rl->table_run[i];
1416 level = rl->table_level[i];
1417 if (index_run[run] == rl->n)
1419 if (level > max_level[run])
1420 max_level[run] = level;
1421 if (run > max_run[level])
1422 max_run[level] = run;
1425 rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1427 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1428 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1430 rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1432 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1433 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1435 rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1437 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1438 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1442 /* draw the edges of width 'w' of an image of size width, height */
1443 //FIXME check that this is ok for mpeg4 interlaced
1444 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1446 uint8_t *ptr, *last_line;
1449 last_line = buf + (height - 1) * wrap;
1451 /* top and bottom */
1452 memcpy(buf - (i + 1) * wrap, buf, width);
1453 memcpy(last_line + (i + 1) * wrap, last_line, width);
1455 /* left and right */
1457 for(i=0;i<height;i++) {
1458 memset(ptr - w, ptr[0], w);
1459 memset(ptr + width, ptr[width-1], w);
1464 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1465 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1466 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1467 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1471 int ff_find_unused_picture(MpegEncContext *s, int shared){
1475 for(i=0; i<MAX_PICTURE_COUNT; i++){
1476 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1479 for(i=0; i<MAX_PICTURE_COUNT; i++){
1480 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1482 for(i=0; i<MAX_PICTURE_COUNT; i++){
1483 if(s->picture[i].data[0]==NULL) return i;
1491 static void update_noise_reduction(MpegEncContext *s){
1494 for(intra=0; intra<2; intra++){
1495 if(s->dct_count[intra] > (1<<16)){
1496 for(i=0; i<64; i++){
1497 s->dct_error_sum[intra][i] >>=1;
1499 s->dct_count[intra] >>= 1;
1502 for(i=0; i<64; i++){
1503 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);
1509 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1511 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1517 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1519 /* mark&release old frames */
1520 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1521 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1523 /* release forgotten pictures */
1524 /* if(mpeg124/h263) */
1526 for(i=0; i<MAX_PICTURE_COUNT; i++){
1527 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1528 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1529 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1536 /* release non reference 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 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1544 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1546 i= ff_find_unused_picture(s, 0);
1547 pic= (AVFrame*)&s->picture[i];
1550 pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1551 && !s->dropable ? 3 : 0;
1553 pic->coded_picture_number= s->coded_picture_number++;
1555 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1558 s->current_picture_ptr= (Picture*)pic;
1559 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1560 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1563 s->current_picture_ptr->pict_type= s->pict_type;
1564 // if(s->flags && CODEC_FLAG_QSCALE)
1565 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1566 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1568 copy_picture(&s->current_picture, s->current_picture_ptr);
1570 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1571 if (s->pict_type != B_TYPE) {
1572 s->last_picture_ptr= s->next_picture_ptr;
1574 s->next_picture_ptr= s->current_picture_ptr;
1576 /* 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,
1577 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1578 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1579 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1580 s->pict_type, s->dropable);*/
1582 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1583 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1585 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1586 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1587 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1591 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1593 if(s->picture_structure!=PICT_FRAME){
1596 if(s->picture_structure == PICT_BOTTOM_FIELD){
1597 s->current_picture.data[i] += s->current_picture.linesize[i];
1599 s->current_picture.linesize[i] *= 2;
1600 s->last_picture.linesize[i] *=2;
1601 s->next_picture.linesize[i] *=2;
1606 s->hurry_up= s->avctx->hurry_up;
1607 s->error_resilience= avctx->error_resilience;
1609 /* set dequantizer, we can't do it during init as it might change for mpeg4
1610 and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1611 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1612 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1613 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1614 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1615 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1616 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1618 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1619 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1622 if(s->dct_error_sum){
1623 assert(s->avctx->noise_reduction && s->encoding);
1625 update_noise_reduction(s);
1629 if(s->avctx->xvmc_acceleration)
1630 return XVMC_field_start(s, avctx);
1635 /* generic function for encode/decode called after a frame has been coded/decoded */
1636 void MPV_frame_end(MpegEncContext *s)
1639 /* draw edge for correct motion prediction if outside */
1641 //just to make sure that all data is rendered.
1642 if(s->avctx->xvmc_acceleration){
1646 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1647 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1648 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1649 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1653 s->last_pict_type = s->pict_type;
1654 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1655 if(s->pict_type!=B_TYPE){
1656 s->last_non_b_pict_type= s->pict_type;
1659 /* copy back current_picture variables */
1660 for(i=0; i<MAX_PICTURE_COUNT; i++){
1661 if(s->picture[i].data[0] == s->current_picture.data[0]){
1662 s->picture[i]= s->current_picture;
1666 assert(i<MAX_PICTURE_COUNT);
1670 /* release non-reference frames */
1671 for(i=0; i<MAX_PICTURE_COUNT; i++){
1672 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1673 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1677 // clear copies, to avoid confusion
1679 memset(&s->last_picture, 0, sizeof(Picture));
1680 memset(&s->next_picture, 0, sizeof(Picture));
1681 memset(&s->current_picture, 0, sizeof(Picture));
1683 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1687 * draws an line from (ex, ey) -> (sx, sy).
1688 * @param w width of the image
1689 * @param h height of the image
1690 * @param stride stride/linesize of the image
1691 * @param color color of the arrow
1693 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1696 sx= clip(sx, 0, w-1);
1697 sy= clip(sy, 0, h-1);
1698 ex= clip(ex, 0, w-1);
1699 ey= clip(ey, 0, h-1);
1701 buf[sy*stride + sx]+= color;
1703 if(ABS(ex - sx) > ABS(ey - sy)){
1708 buf+= sx + sy*stride;
1710 f= ((ey-sy)<<16)/ex;
1711 for(x= 0; x <= ex; x++){
1714 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1715 buf[(y+1)*stride + x]+= (color* fr )>>16;
1722 buf+= sx + sy*stride;
1724 if(ey) f= ((ex-sx)<<16)/ey;
1726 for(y= 0; y <= ey; y++){
1729 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1730 buf[y*stride + x+1]+= (color* fr )>>16;;
1736 * draws an arrow from (ex, ey) -> (sx, sy).
1737 * @param w width of the image
1738 * @param h height of the image
1739 * @param stride stride/linesize of the image
1740 * @param color color of the arrow
1742 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1745 sx= clip(sx, -100, w+100);
1746 sy= clip(sy, -100, h+100);
1747 ex= clip(ex, -100, w+100);
1748 ey= clip(ey, -100, h+100);
1753 if(dx*dx + dy*dy > 3*3){
1756 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1758 //FIXME subpixel accuracy
1759 rx= ROUNDED_DIV(rx*3<<4, length);
1760 ry= ROUNDED_DIV(ry*3<<4, length);
1762 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1763 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1765 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1769 * prints debuging info for the given picture.
1771 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1773 if(!pict || !pict->mb_type) return;
1775 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1778 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1779 switch (pict->pict_type) {
1780 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1781 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1782 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1783 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1784 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1785 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1787 for(y=0; y<s->mb_height; y++){
1788 for(x=0; x<s->mb_width; x++){
1789 if(s->avctx->debug&FF_DEBUG_SKIP){
1790 int count= s->mbskip_table[x + y*s->mb_stride];
1791 if(count>9) count=9;
1792 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1794 if(s->avctx->debug&FF_DEBUG_QP){
1795 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1797 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1798 int mb_type= pict->mb_type[x + y*s->mb_stride];
1799 //Type & MV direction
1801 av_log(s->avctx, AV_LOG_DEBUG, "P");
1802 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1803 av_log(s->avctx, AV_LOG_DEBUG, "A");
1804 else if(IS_INTRA4x4(mb_type))
1805 av_log(s->avctx, AV_LOG_DEBUG, "i");
1806 else if(IS_INTRA16x16(mb_type))
1807 av_log(s->avctx, AV_LOG_DEBUG, "I");
1808 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1809 av_log(s->avctx, AV_LOG_DEBUG, "d");
1810 else if(IS_DIRECT(mb_type))
1811 av_log(s->avctx, AV_LOG_DEBUG, "D");
1812 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1813 av_log(s->avctx, AV_LOG_DEBUG, "g");
1814 else if(IS_GMC(mb_type))
1815 av_log(s->avctx, AV_LOG_DEBUG, "G");
1816 else if(IS_SKIP(mb_type))
1817 av_log(s->avctx, AV_LOG_DEBUG, "S");
1818 else if(!USES_LIST(mb_type, 1))
1819 av_log(s->avctx, AV_LOG_DEBUG, ">");
1820 else if(!USES_LIST(mb_type, 0))
1821 av_log(s->avctx, AV_LOG_DEBUG, "<");
1823 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1824 av_log(s->avctx, AV_LOG_DEBUG, "X");
1829 av_log(s->avctx, AV_LOG_DEBUG, "+");
1830 else if(IS_16X8(mb_type))
1831 av_log(s->avctx, AV_LOG_DEBUG, "-");
1832 else if(IS_8X16(mb_type))
1833 av_log(s->avctx, AV_LOG_DEBUG, "|");
1834 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1835 av_log(s->avctx, AV_LOG_DEBUG, " ");
1837 av_log(s->avctx, AV_LOG_DEBUG, "?");
1840 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1841 av_log(s->avctx, AV_LOG_DEBUG, "=");
1843 av_log(s->avctx, AV_LOG_DEBUG, " ");
1845 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1847 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1851 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1852 const int shift= 1 + s->quarter_sample;
1856 int h_chroma_shift, v_chroma_shift;
1857 const int width = s->avctx->width;
1858 const int height= s->avctx->height;
1859 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1860 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1861 s->low_delay=0; //needed to see the vectors without trashing the buffers
1863 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1865 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1866 pict->data[i]= s->visualization_buffer[i];
1868 pict->type= FF_BUFFER_TYPE_COPY;
1871 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1873 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1874 const int mb_index= mb_x + mb_y*s->mb_stride;
1875 if((s->avctx->debug_mv) && pict->motion_val){
1877 for(type=0; type<3; type++){
1880 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1884 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1888 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1893 if(!USES_LIST(pict->mb_type[mb_index], direction))
1896 if(IS_8X8(pict->mb_type[mb_index])){
1899 int sx= mb_x*16 + 4 + 8*(i&1);
1900 int sy= mb_y*16 + 4 + 8*(i>>1);
1901 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1902 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1903 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1904 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1906 }else if(IS_16X8(pict->mb_type[mb_index])){
1910 int sy=mb_y*16 + 4 + 8*i;
1911 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1912 int mx=(pict->motion_val[direction][xy][0]>>shift);
1913 int my=(pict->motion_val[direction][xy][1]>>shift);
1915 if(IS_INTERLACED(pict->mb_type[mb_index]))
1918 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1920 }else if(IS_8X16(pict->mb_type[mb_index])){
1923 int sx=mb_x*16 + 4 + 8*i;
1925 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1926 int mx=(pict->motion_val[direction][xy][0]>>shift);
1927 int my=(pict->motion_val[direction][xy][1]>>shift);
1929 if(IS_INTERLACED(pict->mb_type[mb_index]))
1932 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1935 int sx= mb_x*16 + 8;
1936 int sy= mb_y*16 + 8;
1937 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1938 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1939 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1940 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1944 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1945 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1948 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1949 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1952 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1953 int mb_type= pict->mb_type[mb_index];
1956 #define COLOR(theta, r)\
1957 u= (int)(128 + r*cos(theta*3.141592/180));\
1958 v= (int)(128 + r*sin(theta*3.141592/180));
1962 if(IS_PCM(mb_type)){
1964 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1966 }else if(IS_INTRA4x4(mb_type)){
1968 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1970 }else if(IS_DIRECT(mb_type)){
1972 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1974 }else if(IS_GMC(mb_type)){
1976 }else if(IS_SKIP(mb_type)){
1978 }else if(!USES_LIST(mb_type, 1)){
1980 }else if(!USES_LIST(mb_type, 0)){
1983 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1987 u*= 0x0101010101010101ULL;
1988 v*= 0x0101010101010101ULL;
1990 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1991 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1995 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1996 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1997 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1999 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
2001 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
2003 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
2004 int dm= 1 << (mv_sample_log2-2);
2006 int sx= mb_x*16 + 8*(i&1);
2007 int sy= mb_y*16 + 8*(i>>1);
2008 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
2010 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
2011 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
2013 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
2014 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
2015 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
2019 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
2023 s->mbskip_table[mb_index]=0;
2029 #ifdef CONFIG_ENCODERS
2031 static int get_sae(uint8_t *src, int ref, int stride){
2035 for(y=0; y<16; y++){
2036 for(x=0; x<16; x++){
2037 acc+= ABS(src[x+y*stride] - ref);
2044 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2051 for(y=0; y<h; y+=16){
2052 for(x=0; x<w; x+=16){
2053 int offset= x + y*stride;
2054 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
2055 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
2056 int sae = get_sae(src + offset, mean, stride);
2058 acc+= sae + 500 < sad;
2065 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2069 const int encoding_delay= s->max_b_frames;
2074 pic_arg->display_picture_number= s->input_picture_number++;
2076 if(pts != AV_NOPTS_VALUE){
2077 if(s->user_specified_pts != AV_NOPTS_VALUE){
2079 int64_t last= s->user_specified_pts;
2082 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2086 s->user_specified_pts= pts;
2088 if(s->user_specified_pts != AV_NOPTS_VALUE){
2089 s->user_specified_pts=
2090 pts= s->user_specified_pts + 1;
2091 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2093 pts= pic_arg->display_picture_number;
2099 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2100 if(pic_arg->linesize[0] != s->linesize) direct=0;
2101 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2102 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2104 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2107 i= ff_find_unused_picture(s, 1);
2109 pic= (AVFrame*)&s->picture[i];
2113 pic->data[i]= pic_arg->data[i];
2114 pic->linesize[i]= pic_arg->linesize[i];
2116 alloc_picture(s, (Picture*)pic, 1);
2118 i= ff_find_unused_picture(s, 0);
2120 pic= (AVFrame*)&s->picture[i];
2123 alloc_picture(s, (Picture*)pic, 0);
2125 if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
2126 && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
2127 && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
2130 int h_chroma_shift, v_chroma_shift;
2131 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2134 int src_stride= pic_arg->linesize[i];
2135 int dst_stride= i ? s->uvlinesize : s->linesize;
2136 int h_shift= i ? h_chroma_shift : 0;
2137 int v_shift= i ? v_chroma_shift : 0;
2138 int w= s->width >>h_shift;
2139 int h= s->height>>v_shift;
2140 uint8_t *src= pic_arg->data[i];
2141 uint8_t *dst= pic->data[i] + INPLACE_OFFSET;
2143 if(src_stride==dst_stride)
2144 memcpy(dst, src, src_stride*h);
2147 memcpy(dst, src, w);
2155 copy_picture_attributes(s, pic, pic_arg);
2156 pic->pts= pts; //we set this here to avoid modifiying pic_arg
2159 /* shift buffer entries */
2160 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2161 s->input_picture[i-1]= s->input_picture[i];
2163 s->input_picture[encoding_delay]= (Picture*)pic;
2168 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2173 for(plane=0; plane<3; plane++){
2174 const int stride= p->linesize[plane];
2175 const int bw= plane ? 1 : 2;
2176 for(y=0; y<s->mb_height*bw; y++){
2177 for(x=0; x<s->mb_width*bw; x++){
2178 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2179 int v= s->dsp.frame_skip_cmp[1](s, p->data[plane] + 8*(x + y*stride)+off, ref->data[plane] + 8*(x + y*stride), stride, 8);
2181 switch(s->avctx->frame_skip_exp){
2182 case 0: score= FFMAX(score, v); break;
2183 case 1: score+= ABS(v);break;
2184 case 2: score+= v*v;break;
2185 case 3: score64+= ABS(v*v*(int64_t)v);break;
2186 case 4: score64+= v*v*(int64_t)(v*v);break;
2192 if(score) score64= score;
2194 if(score64 < s->avctx->frame_skip_threshold)
2196 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2201 static int estimate_best_b_count(MpegEncContext *s){
2202 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2203 AVCodecContext *c= avcodec_alloc_context();
2204 AVFrame input[FF_MAX_B_FRAMES+2];
2205 const int scale= s->avctx->brd_scale;
2206 int i, j, out_size, p_lambda, b_lambda, lambda2;
2207 int outbuf_size= s->width * s->height; //FIXME
2208 uint8_t *outbuf= av_malloc(outbuf_size);
2209 int64_t best_rd= INT64_MAX;
2210 int best_b_count= -1;
2212 assert(scale>=0 && scale <=3);
2215 p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
2216 b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
2217 if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
2218 lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
2220 c->width = s->width >> scale;
2221 c->height= s->height>> scale;
2222 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2223 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2224 c->mb_decision= s->avctx->mb_decision;
2225 c->me_cmp= s->avctx->me_cmp;
2226 c->mb_cmp= s->avctx->mb_cmp;
2227 c->me_sub_cmp= s->avctx->me_sub_cmp;
2228 c->pix_fmt = PIX_FMT_YUV420P;
2229 c->time_base= s->avctx->time_base;
2230 c->max_b_frames= s->max_b_frames;
2232 if (avcodec_open(c, codec) < 0)
2235 for(i=0; i<s->max_b_frames+2; i++){
2236 int ysize= c->width*c->height;
2237 int csize= (c->width/2)*(c->height/2);
2238 Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
2241 pre_input= *pre_input_ptr;
2243 if(pre_input.type != FF_BUFFER_TYPE_SHARED && i){
2244 pre_input.data[0]+=INPLACE_OFFSET;
2245 pre_input.data[1]+=INPLACE_OFFSET;
2246 pre_input.data[2]+=INPLACE_OFFSET;
2249 avcodec_get_frame_defaults(&input[i]);
2250 input[i].data[0]= av_malloc(ysize + 2*csize);
2251 input[i].data[1]= input[i].data[0] + ysize;
2252 input[i].data[2]= input[i].data[1] + csize;
2253 input[i].linesize[0]= c->width;
2254 input[i].linesize[1]=
2255 input[i].linesize[2]= c->width/2;
2257 if(!i || s->input_picture[i-1]){
2258 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
2259 s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1], pre_input.data[1], pre_input.linesize[1], c->width>>1, c->height>>1);
2260 s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2], pre_input.data[2], pre_input.linesize[2], c->width>>1, c->height>>1);
2264 for(j=0; j<s->max_b_frames+1; j++){
2267 if(!s->input_picture[j])
2270 c->error[0]= c->error[1]= c->error[2]= 0;
2272 input[0].pict_type= I_TYPE;
2273 input[0].quality= 1 * FF_QP2LAMBDA;
2274 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2275 // rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2277 for(i=0; i<s->max_b_frames+1; i++){
2278 int is_p= i % (j+1) == j || i==s->max_b_frames;
2280 input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2281 input[i+1].quality= is_p ? p_lambda : b_lambda;
2282 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2283 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2286 /* get the delayed frames */
2288 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2289 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2292 rd += c->error[0] + c->error[1] + c->error[2];
2304 for(i=0; i<s->max_b_frames+2; i++){
2305 av_freep(&input[i].data[0]);
2308 return best_b_count;
2311 static void select_input_picture(MpegEncContext *s){
2314 for(i=1; i<MAX_PICTURE_COUNT; i++)
2315 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2316 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2318 /* set next picture type & ordering */
2319 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2320 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2321 s->reordered_input_picture[0]= s->input_picture[0];
2322 s->reordered_input_picture[0]->pict_type= I_TYPE;
2323 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2327 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2328 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2329 //FIXME check that te gop check above is +-1 correct
2330 //av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2332 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2334 s->input_picture[0]->data[i]= NULL;
2335 s->input_picture[0]->type= 0;
2337 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2338 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2340 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2344 ff_vbv_update(s, 0);
2350 if(s->flags&CODEC_FLAG_PASS2){
2351 for(i=0; i<s->max_b_frames+1; i++){
2352 int pict_num= s->input_picture[0]->display_picture_number + i;
2354 if(pict_num >= s->rc_context.num_entries)
2356 if(!s->input_picture[i]){
2357 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2361 s->input_picture[i]->pict_type=
2362 s->rc_context.entry[pict_num].new_pict_type;
2366 if(s->avctx->b_frame_strategy==0){
2367 b_frames= s->max_b_frames;
2368 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2369 }else if(s->avctx->b_frame_strategy==1){
2370 for(i=1; i<s->max_b_frames+1; i++){
2371 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2372 s->input_picture[i]->b_frame_score=
2373 get_intra_count(s, s->input_picture[i ]->data[0],
2374 s->input_picture[i-1]->data[0], s->linesize) + 1;
2377 for(i=0; i<s->max_b_frames+1; i++){
2378 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
2381 b_frames= FFMAX(0, i-1);
2384 for(i=0; i<b_frames+1; i++){
2385 s->input_picture[i]->b_frame_score=0;
2387 }else if(s->avctx->b_frame_strategy==2){
2388 b_frames= estimate_best_b_count(s);
2390 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2395 //static int b_count=0;
2396 //b_count+= b_frames;
2397 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2399 for(i= b_frames - 1; i>=0; i--){
2400 int type= s->input_picture[i]->pict_type;
2401 if(type && type != B_TYPE)
2404 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2405 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2408 if(s->picture_in_gop_number + b_frames >= s->gop_size){
2409 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2410 b_frames= s->gop_size - s->picture_in_gop_number - 1;
2412 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2414 s->input_picture[b_frames]->pict_type= I_TYPE;
2418 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2420 && s->input_picture[b_frames]->pict_type== I_TYPE)
2423 s->reordered_input_picture[0]= s->input_picture[b_frames];
2424 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2425 s->reordered_input_picture[0]->pict_type= P_TYPE;
2426 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2427 for(i=0; i<b_frames; i++){
2428 s->reordered_input_picture[i+1]= s->input_picture[i];
2429 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2430 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2435 if(s->reordered_input_picture[0]){
2436 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2438 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2440 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2441 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
2443 int i= ff_find_unused_picture(s, 0);
2444 Picture *pic= &s->picture[i];
2446 /* mark us unused / free shared pic */
2448 s->reordered_input_picture[0]->data[i]= NULL;
2449 s->reordered_input_picture[0]->type= 0;
2451 pic->reference = s->reordered_input_picture[0]->reference;
2453 alloc_picture(s, pic, 0);
2455 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2457 s->current_picture_ptr= pic;
2459 // input is not a shared pix -> reuse buffer for current_pix
2461 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2462 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2464 s->current_picture_ptr= s->reordered_input_picture[0];
2466 s->new_picture.data[i]+= INPLACE_OFFSET;
2469 copy_picture(&s->current_picture, s->current_picture_ptr);
2471 s->picture_number= s->new_picture.display_picture_number;
2472 //printf("dpn:%d\n", s->picture_number);
2474 memset(&s->new_picture, 0, sizeof(Picture));
2478 int MPV_encode_picture(AVCodecContext *avctx,
2479 unsigned char *buf, int buf_size, void *data)
2481 MpegEncContext *s = avctx->priv_data;
2482 AVFrame *pic_arg = data;
2483 int i, stuffing_count;
2485 for(i=0; i<avctx->thread_count; i++){
2486 int start_y= s->thread_context[i]->start_mb_y;
2487 int end_y= s->thread_context[i]-> end_mb_y;
2488 int h= s->mb_height;
2489 uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2490 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h);
2492 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2495 s->picture_in_gop_number++;
2497 if(load_input_picture(s, pic_arg) < 0)
2500 select_input_picture(s);
2503 if(s->new_picture.data[0]){
2504 s->pict_type= s->new_picture.pict_type;
2506 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2507 MPV_frame_start(s, avctx);
2509 if (encode_picture(s, s->picture_number) < 0)
2512 avctx->real_pict_num = s->picture_number;
2513 avctx->header_bits = s->header_bits;
2514 avctx->mv_bits = s->mv_bits;
2515 avctx->misc_bits = s->misc_bits;
2516 avctx->i_tex_bits = s->i_tex_bits;
2517 avctx->p_tex_bits = s->p_tex_bits;
2518 avctx->i_count = s->i_count;
2519 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2520 avctx->skip_count = s->skip_count;
2524 if (s->out_format == FMT_MJPEG)
2525 mjpeg_picture_trailer(s);
2527 if(s->flags&CODEC_FLAG_PASS1)
2528 ff_write_pass1_stats(s);
2531 s->current_picture_ptr->error[i]= s->current_picture.error[i];
2532 avctx->error[i] += s->current_picture_ptr->error[i];
2535 if(s->flags&CODEC_FLAG_PASS1)
2536 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2537 flush_put_bits(&s->pb);
2538 s->frame_bits = put_bits_count(&s->pb);
2540 stuffing_count= ff_vbv_update(s, s->frame_bits);
2542 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2543 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2547 switch(s->codec_id){
2548 case CODEC_ID_MPEG1VIDEO:
2549 case CODEC_ID_MPEG2VIDEO:
2550 while(stuffing_count--){
2551 put_bits(&s->pb, 8, 0);
2554 case CODEC_ID_MPEG4:
2555 put_bits(&s->pb, 16, 0);
2556 put_bits(&s->pb, 16, 0x1C3);
2557 stuffing_count -= 4;
2558 while(stuffing_count--){
2559 put_bits(&s->pb, 8, 0xFF);
2563 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2565 flush_put_bits(&s->pb);
2566 s->frame_bits = put_bits_count(&s->pb);
2569 /* update mpeg1/2 vbv_delay for CBR */
2570 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2571 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2574 assert(s->repeat_first_field==0);
2576 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2577 assert(vbv_delay < 0xFFFF);
2579 s->vbv_delay_ptr[0] &= 0xF8;
2580 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2581 s->vbv_delay_ptr[1] = vbv_delay>>5;
2582 s->vbv_delay_ptr[2] &= 0x07;
2583 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2585 s->total_bits += s->frame_bits;
2586 avctx->frame_bits = s->frame_bits;
2588 assert((pbBufPtr(&s->pb) == s->pb.buf));
2591 assert((s->frame_bits&7)==0);
2593 return s->frame_bits/8;
2596 #endif //CONFIG_ENCODERS
2598 static inline void gmc1_motion(MpegEncContext *s,
2599 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2600 uint8_t **ref_picture)
2603 int offset, src_x, src_y, linesize, uvlinesize;
2604 int motion_x, motion_y;
2607 motion_x= s->sprite_offset[0][0];
2608 motion_y= s->sprite_offset[0][1];
2609 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2610 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2611 motion_x<<=(3-s->sprite_warping_accuracy);
2612 motion_y<<=(3-s->sprite_warping_accuracy);
2613 src_x = clip(src_x, -16, s->width);
2614 if (src_x == s->width)
2616 src_y = clip(src_y, -16, s->height);
2617 if (src_y == s->height)
2620 linesize = s->linesize;
2621 uvlinesize = s->uvlinesize;
2623 ptr = ref_picture[0] + (src_y * linesize) + src_x;
2625 if(s->flags&CODEC_FLAG_EMU_EDGE){
2626 if( (unsigned)src_x >= s->h_edge_pos - 17
2627 || (unsigned)src_y >= s->v_edge_pos - 17){
2628 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2629 ptr= s->edge_emu_buffer;
2633 if((motion_x|motion_y)&7){
2634 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2635 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2639 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2640 if (s->no_rounding){
2641 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2643 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2647 if(s->flags&CODEC_FLAG_GRAY) return;
2649 motion_x= s->sprite_offset[1][0];
2650 motion_y= s->sprite_offset[1][1];
2651 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2652 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2653 motion_x<<=(3-s->sprite_warping_accuracy);
2654 motion_y<<=(3-s->sprite_warping_accuracy);
2655 src_x = clip(src_x, -8, s->width>>1);
2656 if (src_x == s->width>>1)
2658 src_y = clip(src_y, -8, s->height>>1);
2659 if (src_y == s->height>>1)
2662 offset = (src_y * uvlinesize) + src_x;
2663 ptr = ref_picture[1] + offset;
2664 if(s->flags&CODEC_FLAG_EMU_EDGE){
2665 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2666 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2667 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);
2668 ptr= s->edge_emu_buffer;
2672 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2674 ptr = ref_picture[2] + offset;
2676 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);
2677 ptr= s->edge_emu_buffer;
2679 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2684 static inline void gmc_motion(MpegEncContext *s,
2685 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2686 uint8_t **ref_picture)
2689 int linesize, uvlinesize;
2690 const int a= s->sprite_warping_accuracy;
2693 linesize = s->linesize;
2694 uvlinesize = s->uvlinesize;
2696 ptr = ref_picture[0];
2698 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2699 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2701 s->dsp.gmc(dest_y, ptr, linesize, 16,
2704 s->sprite_delta[0][0], s->sprite_delta[0][1],
2705 s->sprite_delta[1][0], s->sprite_delta[1][1],
2706 a+1, (1<<(2*a+1)) - s->no_rounding,
2707 s->h_edge_pos, s->v_edge_pos);
2708 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2709 ox + s->sprite_delta[0][0]*8,
2710 oy + s->sprite_delta[1][0]*8,
2711 s->sprite_delta[0][0], s->sprite_delta[0][1],
2712 s->sprite_delta[1][0], s->sprite_delta[1][1],
2713 a+1, (1<<(2*a+1)) - s->no_rounding,
2714 s->h_edge_pos, s->v_edge_pos);
2716 if(s->flags&CODEC_FLAG_GRAY) return;
2718 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2719 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2721 ptr = ref_picture[1];
2722 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2725 s->sprite_delta[0][0], s->sprite_delta[0][1],
2726 s->sprite_delta[1][0], s->sprite_delta[1][1],
2727 a+1, (1<<(2*a+1)) - s->no_rounding,
2728 s->h_edge_pos>>1, s->v_edge_pos>>1);
2730 ptr = ref_picture[2];
2731 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2734 s->sprite_delta[0][0], s->sprite_delta[0][1],
2735 s->sprite_delta[1][0], s->sprite_delta[1][1],
2736 a+1, (1<<(2*a+1)) - s->no_rounding,
2737 s->h_edge_pos>>1, s->v_edge_pos>>1);
2741 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2742 * @param buf destination buffer
2743 * @param src source buffer
2744 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2745 * @param block_w width of block
2746 * @param block_h height of block
2747 * @param src_x x coordinate of the top left sample of the block in the source buffer
2748 * @param src_y y coordinate of the top left sample of the block in the source buffer
2749 * @param w width of the source buffer
2750 * @param h height of the source buffer
2752 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2753 int src_x, int src_y, int w, int h){
2755 int start_y, start_x, end_y, end_x;
2758 src+= (h-1-src_y)*linesize;
2760 }else if(src_y<=-block_h){
2761 src+= (1-block_h-src_y)*linesize;
2767 }else if(src_x<=-block_w){
2768 src+= (1-block_w-src_x);
2772 start_y= FFMAX(0, -src_y);
2773 start_x= FFMAX(0, -src_x);
2774 end_y= FFMIN(block_h, h-src_y);
2775 end_x= FFMIN(block_w, w-src_x);
2777 // copy existing part
2778 for(y=start_y; y<end_y; y++){
2779 for(x=start_x; x<end_x; x++){
2780 buf[x + y*linesize]= src[x + y*linesize];
2785 for(y=0; y<start_y; y++){
2786 for(x=start_x; x<end_x; x++){
2787 buf[x + y*linesize]= buf[x + start_y*linesize];
2792 for(y=end_y; y<block_h; y++){
2793 for(x=start_x; x<end_x; x++){
2794 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2798 for(y=0; y<block_h; y++){
2800 for(x=0; x<start_x; x++){
2801 buf[x + y*linesize]= buf[start_x + y*linesize];
2805 for(x=end_x; x<block_w; x++){
2806 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2811 static inline int hpel_motion(MpegEncContext *s,
2812 uint8_t *dest, uint8_t *src,
2813 int field_based, int field_select,
2814 int src_x, int src_y,
2815 int width, int height, int stride,
2816 int h_edge_pos, int v_edge_pos,
2817 int w, int h, op_pixels_func *pix_op,
2818 int motion_x, int motion_y)
2823 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2824 src_x += motion_x >> 1;
2825 src_y += motion_y >> 1;
2827 /* WARNING: do no forget half pels */
2828 src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2831 src_y = clip(src_y, -16, height);
2832 if (src_y == height)
2834 src += src_y * stride + src_x;
2836 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2837 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2838 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2839 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2840 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2841 src= s->edge_emu_buffer;
2847 pix_op[dxy](dest, src, stride, h);
2851 static inline int hpel_motion_lowres(MpegEncContext *s,
2852 uint8_t *dest, uint8_t *src,
2853 int field_based, int field_select,
2854 int src_x, int src_y,
2855 int width, int height, int stride,
2856 int h_edge_pos, int v_edge_pos,
2857 int w, int h, h264_chroma_mc_func *pix_op,
2858 int motion_x, int motion_y)
2860 const int lowres= s->avctx->lowres;
2861 const int s_mask= (2<<lowres)-1;
2865 if(s->quarter_sample){
2870 sx= motion_x & s_mask;
2871 sy= motion_y & s_mask;
2872 src_x += motion_x >> (lowres+1);
2873 src_y += motion_y >> (lowres+1);
2875 src += src_y * stride + src_x;
2877 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
2878 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2879 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2880 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2881 src= s->edge_emu_buffer;
2889 pix_op[lowres](dest, src, stride, h, sx, sy);
2893 /* apply one mpeg motion vector to the three components */
2894 static always_inline void mpeg_motion(MpegEncContext *s,
2895 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2896 int field_based, int bottom_field, int field_select,
2897 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2898 int motion_x, int motion_y, int h)
2900 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2901 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2904 if(s->quarter_sample)
2911 v_edge_pos = s->v_edge_pos >> field_based;
2912 linesize = s->current_picture.linesize[0] << field_based;
2913 uvlinesize = s->current_picture.linesize[1] << field_based;
2915 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2916 src_x = s->mb_x* 16 + (motion_x >> 1);
2917 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2919 if (s->out_format == FMT_H263) {
2920 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2921 mx = (motion_x>>1)|(motion_x&1);
2923 uvdxy = ((my & 1) << 1) | (mx & 1);
2924 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2925 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2927 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2931 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2935 uvsrc_x = s->mb_x*8 + mx;
2936 uvsrc_y = s->mb_y*8 + my;
2938 if(s->chroma_y_shift){
2941 uvdxy = ((my & 1) << 1) | (mx & 1);
2942 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2943 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2945 if(s->chroma_x_shift){
2948 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2949 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2960 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2961 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2962 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2964 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2965 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2966 if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2967 s->codec_id == CODEC_ID_MPEG1VIDEO){
2968 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2971 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2972 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2973 ptr_y = s->edge_emu_buffer;
2974 if(!(s->flags&CODEC_FLAG_GRAY)){
2975 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2976 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2977 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2978 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2979 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2985 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2986 dest_y += s->linesize;
2987 dest_cb+= s->uvlinesize;
2988 dest_cr+= s->uvlinesize;
2992 ptr_y += s->linesize;
2993 ptr_cb+= s->uvlinesize;
2994 ptr_cr+= s->uvlinesize;
2997 pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2999 if(!(s->flags&CODEC_FLAG_GRAY)){
3000 pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
3001 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
3003 #if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
3004 if(s->out_format == FMT_H261){
3005 ff_h261_loop_filter(s);
3010 /* apply one mpeg motion vector to the three components */
3011 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
3012 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3013 int field_based, int bottom_field, int field_select,
3014 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
3015 int motion_x, int motion_y, int h)
3017 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3018 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
3019 const int lowres= s->avctx->lowres;
3020 const int block_s= 8>>lowres;
3021 const int s_mask= (2<<lowres)-1;
3022 const int h_edge_pos = s->h_edge_pos >> lowres;
3023 const int v_edge_pos = s->v_edge_pos >> lowres;
3024 linesize = s->current_picture.linesize[0] << field_based;
3025 uvlinesize = s->current_picture.linesize[1] << field_based;
3027 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
3033 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3036 sx= motion_x & s_mask;
3037 sy= motion_y & s_mask;
3038 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
3039 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3041 if (s->out_format == FMT_H263) {
3042 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
3043 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
3046 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
3049 uvsx = (2*mx) & s_mask;
3050 uvsy = (2*my) & s_mask;
3051 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
3052 uvsrc_y = s->mb_y*block_s + (my >> lowres);
3058 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
3059 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
3062 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3063 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3064 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3066 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
3067 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
3068 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3069 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3070 ptr_y = s->edge_emu_buffer;
3071 if(!(s->flags&CODEC_FLAG_GRAY)){
3072 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3073 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
3074 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3075 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3076 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3082 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3083 dest_y += s->linesize;
3084 dest_cb+= s->uvlinesize;
3085 dest_cr+= s->uvlinesize;
3089 ptr_y += s->linesize;
3090 ptr_cb+= s->uvlinesize;
3091 ptr_cr+= s->uvlinesize;
3096 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3098 if(!(s->flags&CODEC_FLAG_GRAY)){
3099 uvsx <<= 2 - lowres;
3100 uvsy <<= 2 - lowres;
3101 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3102 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3104 //FIXME h261 lowres loop filter
3107 //FIXME move to dsputil, avg variant, 16x16 version
3108 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
3110 uint8_t * const top = src[1];
3111 uint8_t * const left = src[2];
3112 uint8_t * const mid = src[0];
3113 uint8_t * const right = src[3];
3114 uint8_t * const bottom= src[4];
3115 #define OBMC_FILTER(x, t, l, m, r, b)\
3116 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
3117 #define OBMC_FILTER4(x, t, l, m, r, b)\
3118 OBMC_FILTER(x , t, l, m, r, b);\
3119 OBMC_FILTER(x+1 , t, l, m, r, b);\
3120 OBMC_FILTER(x +stride, t, l, m, r, b);\
3121 OBMC_FILTER(x+1+stride, t, l, m, r, b);
3124 OBMC_FILTER (x , 2, 2, 4, 0, 0);
3125 OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3126 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3127 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3128 OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3129 OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3131 OBMC_FILTER (x , 1, 2, 5, 0, 0);
3132 OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3133 OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3134 OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3136 OBMC_FILTER4(x , 1, 2, 5, 0, 0);
3137 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3138 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3139 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3141 OBMC_FILTER4(x , 0, 2, 5, 0, 1);
3142 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3143 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3144 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3146 OBMC_FILTER (x , 0, 2, 5, 0, 1);
3147 OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3148 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3149 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3150 OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3151 OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3153 OBMC_FILTER (x , 0, 2, 4, 0, 2);
3154 OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3155 OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3156 OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3159 /* obmc for 1 8x8 luma block */
3160 static inline void obmc_motion(MpegEncContext *s,
3161 uint8_t *dest, uint8_t *src,
3162 int src_x, int src_y,
3163 op_pixels_func *pix_op,
3164 int16_t mv[5][2]/* mid top left right bottom*/)
3170 assert(s->quarter_sample==0);
3173 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3176 ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3177 hpel_motion(s, ptr[i], src, 0, 0,
3179 s->width, s->height, s->linesize,
3180 s->h_edge_pos, s->v_edge_pos,
3182 mv[i][0], mv[i][1]);
3186 put_obmc(dest, ptr, s->linesize);
3189 static inline void qpel_motion(MpegEncContext *s,
3190 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3191 int field_based, int bottom_field, int field_select,
3192 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3193 qpel_mc_func (*qpix_op)[16],
3194 int motion_x, int motion_y, int h)
3196 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3197 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3199 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3200 src_x = s->mb_x * 16 + (motion_x >> 2);
3201 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3203 v_edge_pos = s->v_edge_pos >> field_based;
3204 linesize = s->linesize << field_based;
3205 uvlinesize = s->uvlinesize << field_based;
3210 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3211 static const int rtab[8]= {0,0,1,1,0,0,0,1};
3212 mx= (motion_x>>1) + rtab[motion_x&7];
3213 my= (motion_y>>1) + rtab[motion_y&7];
3214 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3215 mx= (motion_x>>1)|(motion_x&1);
3216 my= (motion_y>>1)|(motion_y&1);
3224 uvdxy= (mx&1) | ((my&1)<<1);
3228 uvsrc_x = s->mb_x * 8 + mx;
3229 uvsrc_y = s->mb_y * (8 >> field_based) + my;
3231 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3232 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3233 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3235 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3236 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
3237 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3238 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3239 ptr_y= s->edge_emu_buffer;
3240 if(!(s->flags&CODEC_FLAG_GRAY)){
3241 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3242 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3243 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3244 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3245 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3252 qpix_op[0][dxy](dest_y, ptr_y, linesize);
3255 dest_y += s->linesize;
3256 dest_cb+= s->uvlinesize;
3257 dest_cr+= s->uvlinesize;
3261 ptr_y += s->linesize;
3262 ptr_cb += s->uvlinesize;
3263 ptr_cr += s->uvlinesize;
3265 //damn interlaced mode
3266 //FIXME boundary mirroring is not exactly correct here
3267 qpix_op[1][dxy](dest_y , ptr_y , linesize);
3268 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3270 if(!(s->flags&CODEC_FLAG_GRAY)){
3271 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3272 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3276 inline int ff_h263_round_chroma(int x){
3278 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3281 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3286 * h263 chorma 4mv motion compensation.
3288 static inline void chroma_4mv_motion(MpegEncContext *s,
3289 uint8_t *dest_cb, uint8_t *dest_cr,
3290 uint8_t **ref_picture,
3291 op_pixels_func *pix_op,
3293 int dxy, emu=0, src_x, src_y, offset;
3296 /* In case of 8X8, we construct a single chroma motion vector
3297 with a special rounding */
3298 mx= ff_h263_round_chroma(mx);
3299 my= ff_h263_round_chroma(my);
3301 dxy = ((my & 1) << 1) | (mx & 1);
3305 src_x = s->mb_x * 8 + mx;
3306 src_y = s->mb_y * 8 + my;
3307 src_x = clip(src_x, -8, s->width/2);
3308 if (src_x == s->width/2)
3310 src_y = clip(src_y, -8, s->height/2);
3311 if (src_y == s->height/2)
3314 offset = (src_y * (s->uvlinesize)) + src_x;
3315 ptr = ref_picture[1] + offset;
3316 if(s->flags&CODEC_FLAG_EMU_EDGE){
3317 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3318 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3319 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);
3320 ptr= s->edge_emu_buffer;
3324 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3326 ptr = ref_picture[2] + offset;
3328 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);
3329 ptr= s->edge_emu_buffer;
3331 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3334 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3335 uint8_t *dest_cb, uint8_t *dest_cr,
3336 uint8_t **ref_picture,
3337 h264_chroma_mc_func *pix_op,
3339 const int lowres= s->avctx->lowres;
3340 const int block_s= 8>>lowres;
3341 const int s_mask= (2<<lowres)-1;
3342 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3343 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3344 int emu=0, src_x, src_y, offset, sx, sy;
3347 if(s->quarter_sample){
3352 /* In case of 8X8, we construct a single chroma motion vector
3353 with a special rounding */
3354 mx= ff_h263_round_chroma(mx);
3355 my= ff_h263_round_chroma(my);
3359 src_x = s->mb_x*block_s + (mx >> (lowres+1));
3360 src_y = s->mb_y*block_s + (my >> (lowres+1));
3362 offset = src_y * s->uvlinesize + src_x;
3363 ptr = ref_picture[1] + offset;
3364 if(s->flags&CODEC_FLAG_EMU_EDGE){
3365 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3366 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3367 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3368 ptr= s->edge_emu_buffer;
3374 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3376 ptr = ref_picture[2] + offset;
3378 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3379 ptr= s->edge_emu_buffer;
3381 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3384 static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir){
3385 /* fetch pixels for estimated mv 4 macroblocks ahead
3386 * optimized for 64byte cache lines */
3387 const int shift = s->quarter_sample ? 2 : 1;
3388 const int mx= (s->mv[dir][0][0]>>shift) + 16*s->mb_x + 8;
3389 const int my= (s->mv[dir][0][1]>>shift) + 16*s->mb_y;
3390 int off= mx + (my + (s->mb_x&3)*4)*s->linesize + 64;
3391 s->dsp.prefetch(pix[0]+off, s->linesize, 4);
3392 off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
3393 s->dsp.prefetch(pix[1]+off, pix[2]-pix[1], 2);
3397 * motion compensation of a single macroblock
3399 * @param dest_y luma destination pointer
3400 * @param dest_cb chroma cb/u destination pointer
3401 * @param dest_cr chroma cr/v destination pointer
3402 * @param dir direction (0->forward, 1->backward)
3403 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3404 * @param pic_op halfpel motion compensation function (average or put normally)
3405 * @param pic_op qpel motion compensation function (average or put normally)
3406 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3408 static inline void MPV_motion(MpegEncContext *s,
3409 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3410 int dir, uint8_t **ref_picture,
3411 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3413 int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3415 uint8_t *ptr, *dest;
3420 prefetch_motion(s, ref_picture, dir);
3422 if(s->obmc && s->pict_type != B_TYPE){
3423 int16_t mv_cache[4][4][2];
3424 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3425 const int mot_stride= s->b8_stride;
3426 const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3428 assert(!s->mb_skipped);
3430 memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy ], sizeof(int16_t)*4);
3431 memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3432 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3434 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3435 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3437 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3440 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3441 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3442 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3444 *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3445 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3448 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3449 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3450 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3452 *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3453 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3459 const int x= (i&1)+1;
3460 const int y= (i>>1)+1;
3462 {mv_cache[y][x ][0], mv_cache[y][x ][1]},
3463 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3464 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3465 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3466 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3468 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3470 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3477 if(!(s->flags&CODEC_FLAG_GRAY))
3478 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3483 switch(s->mv_type) {
3486 if(s->real_sprite_warping_points==1){
3487 gmc1_motion(s, dest_y, dest_cb, dest_cr,
3490 gmc_motion(s, dest_y, dest_cb, dest_cr,
3493 }else if(s->quarter_sample){
3494 qpel_motion(s, dest_y, dest_cb, dest_cr,
3496 ref_picture, pix_op, qpix_op,
3497 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3499 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3500 ref_picture, pix_op,
3501 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3504 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3506 ref_picture, pix_op,
3507 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3513 if(s->quarter_sample){
3515 motion_x = s->mv[dir][i][0];
3516 motion_y = s->mv[dir][i][1];
3518 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3519 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3520 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3522 /* WARNING: do no forget half pels */
3523 src_x = clip(src_x, -16, s->width);
3524 if (src_x == s->width)
3526 src_y = clip(src_y, -16, s->height);
3527 if (src_y == s->height)
3530 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3531 if(s->flags&CODEC_FLAG_EMU_EDGE){
3532 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3533 || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3534 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);
3535 ptr= s->edge_emu_buffer;
3538 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3539 qpix_op[1][dxy](dest, ptr, s->linesize);
3541 mx += s->mv[dir][i][0]/2;
3542 my += s->mv[dir][i][1]/2;
3546 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3547 ref_picture[0], 0, 0,
3548 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3549 s->width, s->height, s->linesize,
3550 s->h_edge_pos, s->v_edge_pos,
3552 s->mv[dir][i][0], s->mv[dir][i][1]);
3554 mx += s->mv[dir][i][0];
3555 my += s->mv[dir][i][1];
3559 if(!(s->flags&CODEC_FLAG_GRAY))
3560 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3563 if (s->picture_structure == PICT_FRAME) {
3564 if(s->quarter_sample){
3566 qpel_motion(s, dest_y, dest_cb, dest_cr,
3567 1, i, s->field_select[dir][i],
3568 ref_picture, pix_op, qpix_op,
3569 s->mv[dir][i][0], s->mv[dir][i][1], 8);
3573 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3574 1, 0, s->field_select[dir][0],
3575 ref_picture, pix_op,
3576 s->mv[dir][0][0], s->mv[dir][0][1], 8);
3578 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3579 1, 1, s->field_select[dir][1],
3580 ref_picture, pix_op,
3581 s->mv[dir][1][0], s->mv[dir][1][1], 8);
3584 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3585 ref_picture= s->current_picture_ptr->data;
3588 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3589 0, 0, s->field_select[dir][0],
3590 ref_picture, pix_op,
3591 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3596 uint8_t ** ref2picture;
3598 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3599 ref2picture= ref_picture;
3601 ref2picture= s->current_picture_ptr->data;
3604 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3605 0, 0, s->field_select[dir][i],
3606 ref2picture, pix_op,
3607 s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3609 dest_y += 16*s->linesize;
3610 dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3611 dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3615 if(s->picture_structure == PICT_FRAME){
3619 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3621 ref_picture, pix_op,
3622 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3624 pix_op = s->dsp.avg_pixels_tab;
3628 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3629 0, 0, s->picture_structure != i+1,
3630 ref_picture, pix_op,
3631 s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3633 // after put we make avg of the same block
3634 pix_op=s->dsp.avg_pixels_tab;
3636 //opposite parity is always in the same frame if this is second field
3637 if(!s->first_field){
3638 ref_picture = s->current_picture_ptr->data;
3648 * motion compensation of a single macroblock
3650 * @param dest_y luma destination pointer
3651 * @param dest_cb chroma cb/u destination pointer
3652 * @param dest_cr chroma cr/v destination pointer
3653 * @param dir direction (0->forward, 1->backward)
3654 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3655 * @param pic_op halfpel motion compensation function (average or put normally)
3656 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3658 static inline void MPV_motion_lowres(MpegEncContext *s,
3659 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3660 int dir, uint8_t **ref_picture,
3661 h264_chroma_mc_func *pix_op)
3665 const int lowres= s->avctx->lowres;
3666 const int block_s= 8>>lowres;
3671 switch(s->mv_type) {
3673 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3675 ref_picture, pix_op,
3676 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3682 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3683 ref_picture[0], 0, 0,
3684 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3685 s->width, s->height, s->linesize,
3686 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3687 block_s, block_s, pix_op,
3688 s->mv[dir][i][0], s->mv[dir][i][1]);
3690 mx += s->mv[dir][i][0];
3691 my += s->mv[dir][i][1];
3694 if(!(s->flags&CODEC_FLAG_GRAY))
3695 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3698 if (s->picture_structure == PICT_FRAME) {
3700 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3701 1, 0, s->field_select[dir][0],
3702 ref_picture, pix_op,
3703 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3705 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3706 1, 1, s->field_select[dir][1],
3707 ref_picture, pix_op,
3708 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3710 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3711 ref_picture= s->current_picture_ptr->data;
3714 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3715 0, 0, s->field_select[dir][0],
3716 ref_picture, pix_op,
3717 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3722 uint8_t ** ref2picture;
3724 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3725 ref2picture= ref_picture;
3727 ref2picture= s->current_picture_ptr->data;
3730 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3731 0, 0, s->field_select[dir][i],
3732 ref2picture, pix_op,
3733 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3735 dest_y += 2*block_s*s->linesize;
3736 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3737 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3741 if(s->picture_structure == PICT_FRAME){
3745 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3747 ref_picture, pix_op,
3748 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3750 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3754 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3755 0, 0, s->picture_structure != i+1,
3756 ref_picture, pix_op,
3757 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3759 // after put we make avg of the same block
3760 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3762 //opposite parity is always in the same frame if this is second field
3763 if(!s->first_field){
3764 ref_picture = s->current_picture_ptr->data;
3773 /* put block[] to dest[] */
3774 static inline void put_dct(MpegEncContext *s,
3775 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3777 s->dct_unquantize_intra(s, block, i, qscale);
3778 s->dsp.idct_put (dest, line_size, block);
3781 /* add block[] to dest[] */
3782 static inline void add_dct(MpegEncContext *s,
3783 DCTELEM *block, int i, uint8_t *dest, int line_size)
3785 if (s->block_last_index[i] >= 0) {
3786 s->dsp.idct_add (dest, line_size, block);
3790 static inline void add_dequant_dct(MpegEncContext *s,
3791 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3793 if (s->block_last_index[i] >= 0) {
3794 s->dct_unquantize_inter(s, block, i, qscale);
3796 s->dsp.idct_add (dest, line_size, block);
3801 * cleans dc, ac, coded_block for the current non intra MB
3803 void ff_clean_intra_table_entries(MpegEncContext *s)
3805 int wrap = s->b8_stride;
3806 int xy = s->block_index[0];
3809 s->dc_val[0][xy + 1 ] =
3810 s->dc_val[0][xy + wrap] =
3811 s->dc_val[0][xy + 1 + wrap] = 1024;
3813 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
3814 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3815 if (s->msmpeg4_version>=3) {
3816 s->coded_block[xy ] =
3817 s->coded_block[xy + 1 ] =
3818 s->coded_block[xy + wrap] =
3819 s->coded_block[xy + 1 + wrap] = 0;
3822 wrap = s->mb_stride;
3823 xy = s->mb_x + s->mb_y * wrap;
3825 s->dc_val[2][xy] = 1024;
3827 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3828 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3830 s->mbintra_table[xy]= 0;
3833 /* generic function called after a macroblock has been parsed by the
3834 decoder or after it has been encoded by the encoder.
3836 Important variables used:
3837 s->mb_intra : true if intra macroblock
3838 s->mv_dir : motion vector direction
3839 s->mv_type : motion vector type
3840 s->mv : motion vector
3841 s->interlaced_dct : true if interlaced dct used (mpeg2)
3843 static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3846 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3848 if(s->avctx->xvmc_acceleration){
3849 XVMC_decode_mb(s);//xvmc uses pblocks
3857 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3858 /* save DCT coefficients */
3860 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3863 *dct++ = block[i][s->dsp.idct_permutation[j]];
3866 s->current_picture.qscale_table[mb_xy]= s->qscale;
3868 /* update DC predictors for P macroblocks */
3870 if (s->h263_pred || s->h263_aic) {
3871 if(s->mbintra_table[mb_xy])
3872 ff_clean_intra_table_entries(s);
3876 s->last_dc[2] = 128 << s->intra_dc_precision;
3879 else if (s->h263_pred || s->h263_aic)
3880 s->mbintra_table[mb_xy]=1;
3882 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3883 uint8_t *dest_y, *dest_cb, *dest_cr;
3884 int dct_linesize, dct_offset;
3885 op_pixels_func (*op_pix)[4];
3886 qpel_mc_func (*op_qpix)[16];
3887 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
3888 const int uvlinesize= s->current_picture.linesize[1];
3889 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3890 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3892 /* avoid copy if macroblock skipped in last frame too */
3893 /* skip only during decoding as we might trash the buffers during encoding a bit */
3895 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3896 const int age= s->current_picture.age;
3900 if (s->mb_skipped) {
3902 assert(s->pict_type!=I_TYPE);
3904 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
3905 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3907 /* if previous was skipped too, then nothing to do ! */
3908 if (*mbskip_ptr >= age && s->current_picture.reference){
3911 } else if(!s->current_picture.reference){
3912 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3913 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3915 *mbskip_ptr = 0; /* not skipped */
3919 dct_linesize = linesize << s->interlaced_dct;
3920 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3924 dest_cb= s->dest[1];
3925 dest_cr= s->dest[2];
3927 dest_y = s->b_scratchpad;
3928 dest_cb= s->b_scratchpad+16*linesize;
3929 dest_cr= s->b_scratchpad+32*linesize;
3933 /* motion handling */
3934 /* decoding or more than one mb_type (MC was already done otherwise) */
3937 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3939 if (s->mv_dir & MV_DIR_FORWARD) {
3940 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3941 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3943 if (s->mv_dir & MV_DIR_BACKWARD) {
3944 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3947 op_qpix= s->me.qpel_put;
3948 if ((!s->no_rounding) || s->pict_type==B_TYPE){
3949 op_pix = s->dsp.put_pixels_tab;
3951 op_pix = s->dsp.put_no_rnd_pixels_tab;
3953 if (s->mv_dir & MV_DIR_FORWARD) {
3954 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3955 op_pix = s->dsp.avg_pixels_tab;
3956 op_qpix= s->me.qpel_avg;
3958 if (s->mv_dir & MV_DIR_BACKWARD) {
3959 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3964 /* skip dequant / idct if we are really late ;) */
3965 if(s->hurry_up>1) goto skip_idct;
3966 if(s->avctx->skip_idct){
3967 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
3968 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
3969 || s->avctx->skip_idct >= AVDISCARD_ALL)
3973 /* add dct residue */
3974 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3975 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3976 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
3977 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
3978 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
3979 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3981 if(!(s->flags&CODEC_FLAG_GRAY)){
3982 if (s->chroma_y_shift){
3983 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3984 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3988 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
3989 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
3990 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
3991 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
3994 } else if(s->codec_id != CODEC_ID_WMV2){
3995 add_dct(s, block[0], 0, dest_y , dct_linesize);
3996 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
3997 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
3998 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
4000 if(!(s->flags&CODEC_FLAG_GRAY)){
4001 if(s->chroma_y_shift){//Chroma420
4002 add_dct(s, block[4], 4, dest_cb, uvlinesize);
4003 add_dct(s, block[5], 5, dest_cr, uvlinesize);
4006 dct_linesize = uvlinesize << s->interlaced_dct;
4007 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4009 add_dct(s, block[4], 4, dest_cb, dct_linesize);
4010 add_dct(s, block[5], 5, dest_cr, dct_linesize);
4011 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
4012 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
4013 if(!s->chroma_x_shift){//Chroma444
4014 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
4015 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
4016 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
4017 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
4023 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
4026 /* dct only in intra block */
4027 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
4028 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
4029 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
4030 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
4031 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
4033 if(!(s->flags&CODEC_FLAG_GRAY)){
4034 if(s->chroma_y_shift){
4035 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
4036 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
4040 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
4041 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
4042 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
4043 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
4047 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
4048 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
4049 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
4050 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
4052 if(!(s->flags&CODEC_FLAG_GRAY)){
4053 if(s->chroma_y_shift){
4054 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
4055 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
4058 dct_linesize = uvlinesize << s->interlaced_dct;
4059 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4061 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
4062 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
4063 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
4064 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
4065 if(!s->chroma_x_shift){//Chroma444
4066 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
4067 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
4068 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
4069 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
4077 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
4078 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
4079 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
4084 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
4085 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
4086 else MPV_decode_mb_internal(s, block, 0);
4089 #ifdef CONFIG_ENCODERS
4091 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
4093 static const char tab[64]=
4105 DCTELEM *block= s->block[n];
4106 const int last_index= s->block_last_index[n];
4111 threshold= -threshold;
4115 /* are all which we could set to zero are allready zero? */
4116 if(last_index<=skip_dc - 1) return;
4118 for(i=0; i<=last_index; i++){
4119 const int j = s->intra_scantable.permutated[i];
4120 const int level = ABS(block[j]);
4122 if(skip_dc && i==0) continue;
4131 if(score >= threshold) return;
4132 for(i=skip_dc; i<=last_index; i++){
4133 const int j = s->intra_scantable.permutated[i];
4136 if(block[0]) s->block_last_index[n]= 0;
4137 else s->block_last_index[n]= -1;
4140 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
4143 const int maxlevel= s->max_qcoeff;
4144 const int minlevel= s->min_qcoeff;
4148 i=1; //skip clipping of intra dc
4152 for(;i<=last_index; i++){
4153 const int j= s->intra_scantable.permutated[i];
4154 int level = block[j];
4156 if (level>maxlevel){
4159 }else if(level<minlevel){
4167 if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
4168 av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
4171 #endif //CONFIG_ENCODERS
4175 * @param h is the normal height, this will be reduced automatically if needed for the last row
4177 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
4178 if (s->avctx->draw_horiz_band) {
4182 if(s->picture_structure != PICT_FRAME){
4185 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
4188 h= FFMIN(h, s->avctx->height - y);
4190 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
4191 src= (AVFrame*)s->current_picture_ptr;
4192 else if(s->last_picture_ptr)
4193 src= (AVFrame*)s->last_picture_ptr;
4197 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
4203 offset[0]= y * s->linesize;;
4205 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
4211 s->avctx->draw_horiz_band(s->avctx, src, offset,
4212 y, s->picture_structure, h);
4216 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
4217 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
4218 const int uvlinesize= s->current_picture.linesize[1];
4219 const int mb_size= 4 - s->avctx->lowres;
4221 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
4222 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
4223 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
4224 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
4225 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
4226 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;
4227 //block_index is not used by mpeg2, so it is not affected by chroma_format
4229 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4230 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4231 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4233 if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
4235 s->dest[0] += s->mb_y * linesize << mb_size;
4236 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4237 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4241 #ifdef CONFIG_ENCODERS
4243 static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
4253 for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
4254 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
4255 int v= ptr[x2 + y2*stride];
4261 weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
4266 static always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count)
4268 int16_t weight[8][64];
4269 DCTELEM orig[8][64];
4270 const int mb_x= s->mb_x;
4271 const int mb_y= s->mb_y;
4274 int dct_offset = s->linesize*8; //default for progressive frames
4275 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
4278 for(i=0; i<mb_block_count; i++) skip_dct[i]=0;
4280 if(s->adaptive_quant){
4281 const int last_qp= s->qscale;
4282 const int mb_xy= mb_x + mb_y*s->mb_stride;
4284 s->lambda= s->lambda_table[mb_xy];
4287 if(!(s->flags&CODEC_FLAG_QP_RD)){
4288 s->dquant= s->qscale - last_qp;
4290 if(s->out_format==FMT_H263){
4291 s->dquant= clip(s->dquant, -2, 2); //FIXME RD
4293 if(s->codec_id==CODEC_ID_MPEG4){
4295 if(s->pict_type == B_TYPE){
4297 s->dquant= (s->dquant/2)*2;
4298 if(s->mv_dir&MV_DIRECT)
4301 if(s->mv_type==MV_TYPE_8X8)
4307 ff_set_qscale(s, last_qp + s->dquant);
4308 }else if(s->flags&CODEC_FLAG_QP_RD)
4309 ff_set_qscale(s, s->qscale + s->dquant);
4311 wrap_y = s->linesize;
4312 wrap_c = s->uvlinesize;
4313 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4314 ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4315 ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4317 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4318 uint8_t *ebuf= s->edge_emu_buffer + 32;
4319 ff_emulated_edge_mc(ebuf , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width , s->height);
4321 ff_emulated_edge_mc(ebuf+18*wrap_y , ptr_cb, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4322 ptr_cb= ebuf+18*wrap_y;
4323 ff_emulated_edge_mc(ebuf+18*wrap_y+8, ptr_cr, wrap_c, 8, mb_block_height, mb_x*8, mb_y*8, s->width>>1, s->height>>1);
4324 ptr_cr= ebuf+18*wrap_y+8;
4328 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4329 int progressive_score, interlaced_score;
4331 s->interlaced_dct=0;
4332 progressive_score= s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y, 8)
4333 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4335 if(progressive_score > 0){
4336 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y*2, 8)
4337 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y , NULL, wrap_y*2, 8);
4338 if(progressive_score > interlaced_score){
4339 s->interlaced_dct=1;
4343 if (s->chroma_format == CHROMA_422)
4349 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
4350 s->dsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
4351 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
4352 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4354 if(s->flags&CODEC_FLAG_GRAY){
4358 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4359 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4360 if(!s->chroma_y_shift){ /* 422 */
4361 s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c);
4362 s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c);
4366 op_pixels_func (*op_pix)[4];
4367 qpel_mc_func (*op_qpix)[16];
4368 uint8_t *dest_y, *dest_cb, *dest_cr;
4370 dest_y = s->dest[0];
4371 dest_cb = s->dest[1];
4372 dest_cr = s->dest[2];
4374 if ((!s->no_rounding) || s->pict_type==B_TYPE){
4375 op_pix = s->dsp.put_pixels_tab;
4376 op_qpix= s->dsp.put_qpel_pixels_tab;
4378 op_pix = s->dsp.put_no_rnd_pixels_tab;
4379 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4382 if (s->mv_dir & MV_DIR_FORWARD) {
4383 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4384 op_pix = s->dsp.avg_pixels_tab;
4385 op_qpix= s->dsp.avg_qpel_pixels_tab;
4387 if (s->mv_dir & MV_DIR_BACKWARD) {
4388 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4391 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4392 int progressive_score, interlaced_score;
4394 s->interlaced_dct=0;
4395 progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8)
4396 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4398 if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4400 if(progressive_score>0){
4401 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8)
4402 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8);
4404 if(progressive_score > interlaced_score){
4405 s->interlaced_dct=1;
4409 if (s->chroma_format == CHROMA_422)
4415 s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y);
4416 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
4417 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y);
4418 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4420 if(s->flags&CODEC_FLAG_GRAY){
4424 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
4425 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
4426 if(!s->chroma_y_shift){ /* 422 */
4427 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c);
4428 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c);
4431 /* pre quantization */
4432 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
4434 if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4435 if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
4436 if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
4437 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;
4438 if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
4439 if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
4440 if(!s->chroma_y_shift){ /* 422 */
4441 if(s->dsp.sad[1](NULL, ptr_cb +(dct_offset>>1), dest_cb +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[6]= 1;
4442 if(s->dsp.sad[1](NULL, ptr_cr +(dct_offset>>1), dest_cr +(dct_offset>>1), wrap_c, 8) < 20*s->qscale) skip_dct[7]= 1;
4447 if(s->avctx->quantizer_noise_shaping){
4448 if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y , wrap_y);
4449 if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y + 8, wrap_y);
4450 if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset , wrap_y);
4451 if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
4452 if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb , wrap_c);
4453 if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr , wrap_c);
4454 if(!s->chroma_y_shift){ /* 422 */
4455 if(!skip_dct[6]) get_vissual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c);
4456 if(!skip_dct[7]) get_vissual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c);
4458 memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*mb_block_count);
4461 /* DCT & quantize */
4462 assert(s->out_format!=FMT_MJPEG || s->qscale==8);
4464 for(i=0;i<mb_block_count;i++) {
4467 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4468 // FIXME we could decide to change to quantizer instead of clipping
4469 // JS: I don't think that would be a good idea it could lower quality instead
4470 // of improve it. Just INTRADC clipping deserves changes in quantizer
4471 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
4473 s->block_last_index[i]= -1;
4475 if(s->avctx->quantizer_noise_shaping){
4476 for(i=0;i<mb_block_count;i++) {
4478 s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
4483 if(s->luma_elim_threshold && !s->mb_intra)
4485 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4486 if(s->chroma_elim_threshold && !s->mb_intra)
4487 for(i=4; i<mb_block_count; i++)
4488 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4490 if(s->flags & CODEC_FLAG_CBP_RD){
4491 for(i=0;i<mb_block_count;i++) {
4492 if(s->block_last_index[i] == -1)
4493 s->coded_score[i]= INT_MAX/256;
4498 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4499 s->block_last_index[4]=
4500 s->block_last_index[5]= 0;
4502 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4505 //non c quantize code returns incorrect block_last_index FIXME
4506 if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4507 for(i=0; i<mb_block_count; i++){
4509 if(s->block_last_index[i]>0){
4510 for(j=63; j>0; j--){
4511 if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4513 s->block_last_index[i]= j;
4518 /* huffman encode */
4519 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4520 case CODEC_ID_MPEG1VIDEO:
4521 case CODEC_ID_MPEG2VIDEO:
4522 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4523 case CODEC_ID_MPEG4:
4524 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4525 case CODEC_ID_MSMPEG4V2:
4526 case CODEC_ID_MSMPEG4V3:
4528 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4530 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4531 #ifdef CONFIG_H261_ENCODER
4533 ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4536 case CODEC_ID_H263P:
4540 h263_encode_mb(s, s->block, motion_x, motion_y); break;
4541 case CODEC_ID_MJPEG:
4542 mjpeg_encode_mb(s, s->block); break;
4548 static always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
4550 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
4551 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
4554 #endif //CONFIG_ENCODERS
4556 void ff_mpeg_flush(AVCodecContext *avctx){
4558 MpegEncContext *s = avctx->priv_data;
4560 if(s==NULL || s->picture==NULL)
4563 for(i=0; i<MAX_PICTURE_COUNT; i++){
4564 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4565 || s->picture[i].type == FF_BUFFER_TYPE_USER))
4566 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4568 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4570 s->mb_x= s->mb_y= 0;
4572 s->parse_context.state= -1;
4573 s->parse_context.frame_start_found= 0;
4574 s->parse_context.overread= 0;
4575 s->parse_context.overread_index= 0;
4576 s->parse_context.index= 0;
4577 s->parse_context.last_index= 0;
4578 s->bitstream_buffer_size=0;
4581 #ifdef CONFIG_ENCODERS
4582 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4584 const uint16_t *srcw= (uint16_t*)src;
4585 int words= length>>4;
4586 int bits= length&15;
4589 if(length==0) return;
4592 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4593 }else if(put_bits_count(pb)&7){
4594 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4596 for(i=0; put_bits_count(pb)&31; i++)
4597 put_bits(pb, 8, src[i]);
4599 memcpy(pbBufPtr(pb), src+i, 2*words-i);
4600 skip_put_bytes(pb, 2*words-i);
4603 put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4606 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4609 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4612 d->mb_skip_run= s->mb_skip_run;
4614 d->last_dc[i]= s->last_dc[i];
4617 d->mv_bits= s->mv_bits;
4618 d->i_tex_bits= s->i_tex_bits;
4619 d->p_tex_bits= s->p_tex_bits;
4620 d->i_count= s->i_count;
4621 d->f_count= s->f_count;
4622 d->b_count= s->b_count;
4623 d->skip_count= s->skip_count;
4624 d->misc_bits= s->misc_bits;
4628 d->qscale= s->qscale;
4629 d->dquant= s->dquant;
4632 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4635 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
4636 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4639 d->mb_skip_run= s->mb_skip_run;
4641 d->last_dc[i]= s->last_dc[i];
4644 d->mv_bits= s->mv_bits;
4645 d->i_tex_bits= s->i_tex_bits;
4646 d->p_tex_bits= s->p_tex_bits;
4647 d->i_count= s->i_count;
4648 d->f_count= s->f_count;
4649 d->b_count= s->b_count;
4650 d->skip_count= s->skip_count;
4651 d->misc_bits= s->misc_bits;
4653 d->mb_intra= s->mb_intra;
4654 d->mb_skipped= s->mb_skipped;
4655 d->mv_type= s->mv_type;
4656 d->mv_dir= s->mv_dir;
4658 if(s->data_partitioning){
4660 d->tex_pb= s->tex_pb;
4664 d->block_last_index[i]= s->block_last_index[i];
4665 d->interlaced_dct= s->interlaced_dct;
4666 d->qscale= s->qscale;
4669 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
4670 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4671 int *dmin, int *next_block, int motion_x, int motion_y)
4674 uint8_t *dest_backup[3];
4676 copy_context_before_encode(s, backup, type);
4678 s->block= s->blocks[*next_block];
4679 s->pb= pb[*next_block];
4680 if(s->data_partitioning){
4681 s->pb2 = pb2 [*next_block];
4682 s->tex_pb= tex_pb[*next_block];
4686 memcpy(dest_backup, s->dest, sizeof(s->dest));
4687 s->dest[0] = s->rd_scratchpad;
4688 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4689 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4690 assert(s->linesize >= 32); //FIXME
4693 encode_mb(s, motion_x, motion_y);
4695 score= put_bits_count(&s->pb);
4696 if(s->data_partitioning){
4697 score+= put_bits_count(&s->pb2);
4698 score+= put_bits_count(&s->tex_pb);
4701 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4702 MPV_decode_mb(s, s->block);
4704 score *= s->lambda2;
4705 score += sse_mb(s) << FF_LAMBDA_SHIFT;
4709 memcpy(s->dest, dest_backup, sizeof(s->dest));
4716 copy_context_after_encode(best, s, type);
4720 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4721 uint32_t *sq = squareTbl + 256;
4726 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
4727 else if(w==8 && h==8)
4728 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4732 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4741 static int sse_mb(MpegEncContext *s){
4745 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4746 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4749 if(s->avctx->mb_cmp == FF_CMP_NSSE){
4750 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)
4751 +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)
4752 +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);
4754 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)
4755 +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)
4756 +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);
4759 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)
4760 +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)
4761 +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);
4764 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4765 MpegEncContext *s= arg;
4769 s->me.dia_size= s->avctx->pre_dia_size;
4770 s->first_slice_line=1;
4771 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4772 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4773 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4775 s->first_slice_line=0;
4783 static int estimate_motion_thread(AVCodecContext *c, void *arg){
4784 MpegEncContext *s= arg;
4786 s->me.dia_size= s->avctx->dia_size;
4787 s->first_slice_line=1;
4788 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4789 s->mb_x=0; //for block init below
4790 ff_init_block_index(s);
4791 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4792 s->block_index[0]+=2;
4793 s->block_index[1]+=2;
4794 s->block_index[2]+=2;
4795 s->block_index[3]+=2;
4797 /* compute motion vector & mb_type and store in context */
4798 if(s->pict_type==B_TYPE)
4799 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4801 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4803 s->first_slice_line=0;
4808 static int mb_var_thread(AVCodecContext *c, void *arg){
4809 MpegEncContext *s= arg;
4812 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4813 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4816 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4818 int sum = s->dsp.pix_sum(pix, s->linesize);
4820 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4822 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4823 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4824 s->me.mb_var_sum_temp += varc;
4830 static void write_slice_end(MpegEncContext *s){
4831 if(s->codec_id==CODEC_ID_MPEG4){
4832 if(s->partitioned_frame){
4833 ff_mpeg4_merge_partitions(s);
4836 ff_mpeg4_stuffing(&s->pb);
4837 }else if(s->out_format == FMT_MJPEG){
4838 ff_mjpeg_stuffing(&s->pb);
4841 align_put_bits(&s->pb);
4842 flush_put_bits(&s->pb);
4844 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
4845 s->misc_bits+= get_bits_diff(s);
4848 static int encode_thread(AVCodecContext *c, void *arg){
4849 MpegEncContext *s= arg;
4850 int mb_x, mb_y, pdif = 0;
4852 MpegEncContext best_s, backup_s;
4853 uint8_t bit_buf[2][MAX_MB_BYTES];
4854 uint8_t bit_buf2[2][MAX_MB_BYTES];
4855 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
4856 PutBitContext pb[2], pb2[2], tex_pb[2];
4857 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4860 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
4861 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
4862 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
4865 s->last_bits= put_bits_count(&s->pb);
4876 /* init last dc values */
4877 /* note: quant matrix value (8) is implied here */
4878 s->last_dc[i] = 128 << s->intra_dc_precision;
4880 s->current_picture.error[i] = 0;
4883 memset(s->last_mv, 0, sizeof(s->last_mv));
4887 switch(s->codec_id){
4889 case CODEC_ID_H263P:
4891 s->gob_index = ff_h263_get_gob_height(s);
4893 case CODEC_ID_MPEG4:
4894 if(s->partitioned_frame)
4895 ff_mpeg4_init_partitions(s);
4901 s->first_slice_line = 1;
4902 s->ptr_lastgob = s->pb.buf;
4903 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4904 // printf("row %d at %X\n", s->mb_y, (int)s);
4908 ff_set_qscale(s, s->qscale);
4909 ff_init_block_index(s);
4911 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4912 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
4913 int mb_type= s->mb_type[xy];
4918 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
4919 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
4922 if(s->data_partitioning){
4923 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
4924 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
4925 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
4931 s->mb_y = mb_y; // moved into loop, can get changed by H.261
4932 ff_update_block_index(s);
4934 #ifdef CONFIG_H261_ENCODER
4935 if(s->codec_id == CODEC_ID_H261){
4936 ff_h261_reorder_mb_index(s);
4937 xy= s->mb_y*s->mb_stride + s->mb_x;
4938 mb_type= s->mb_type[xy];
4942 /* write gob / video packet header */
4944 int current_packet_size, is_gob_start;
4946 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4948 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
4950 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4952 switch(s->codec_id){
4954 case CODEC_ID_H263P:
4955 if(!s->h263_slice_structured)
4956 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4958 case CODEC_ID_MPEG2VIDEO:
4959 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4960 case CODEC_ID_MPEG1VIDEO:
4961 if(s->mb_skip_run) is_gob_start=0;
4966 if(s->start_mb_y != mb_y || mb_x!=0){
4969 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4970 ff_mpeg4_init_partitions(s);
4974 assert((put_bits_count(&s->pb)&7) == 0);
4975 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4977 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4978 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
4979 int d= 100 / s->avctx->error_rate;
4981 current_packet_size=0;
4982 #ifndef ALT_BITSTREAM_WRITER
4983 s->pb.buf_ptr= s->ptr_lastgob;
4985 assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4989 if (s->avctx->rtp_callback){
4990 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
4991 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
4994 switch(s->codec_id){
4995 case CODEC_ID_MPEG4:
4996 ff_mpeg4_encode_video_packet_header(s);
4997 ff_mpeg4_clean_buffers(s);
4999 case CODEC_ID_MPEG1VIDEO:
5000 case CODEC_ID_MPEG2VIDEO:
5001 ff_mpeg1_encode_slice_header(s);
5002 ff_mpeg1_clean_buffers(s);
5005 case CODEC_ID_H263P:
5006 h263_encode_gob_header(s, mb_y);
5010 if(s->flags&CODEC_FLAG_PASS1){
5011 int bits= put_bits_count(&s->pb);
5012 s->misc_bits+= bits - s->last_bits;
5016 s->ptr_lastgob += current_packet_size;
5017 s->first_slice_line=1;
5018 s->resync_mb_x=mb_x;
5019 s->resync_mb_y=mb_y;
5023 if( (s->resync_mb_x == s->mb_x)
5024 && s->resync_mb_y+1 == s->mb_y){
5025 s->first_slice_line=0;
5029 s->dquant=0; //only for QP_RD
5031 if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
5033 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
5035 copy_context_before_encode(&backup_s, s, -1);
5037 best_s.data_partitioning= s->data_partitioning;
5038 best_s.partitioned_frame= s->partitioned_frame;
5039 if(s->data_partitioning){
5040 backup_s.pb2= s->pb2;
5041 backup_s.tex_pb= s->tex_pb;
5044 if(mb_type&CANDIDATE_MB_TYPE_INTER){
5045 s->mv_dir = MV_DIR_FORWARD;
5046 s->mv_type = MV_TYPE_16X16;
5048 s->mv[0][0][0] = s->p_mv_table[xy][0];
5049 s->mv[0][0][1] = s->p_mv_table[xy][1];
5050 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
5051 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5053 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
5054 s->mv_dir = MV_DIR_FORWARD;
5055 s->mv_type = MV_TYPE_FIELD;
5058 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
5059 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
5060 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
5062 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
5063 &dmin, &next_block, 0, 0);
5065 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
5066 s->mv_dir = MV_DIR_FORWARD;
5067 s->mv_type = MV_TYPE_16X16;
5071 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
5072 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5074 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
5075 s->mv_dir = MV_DIR_FORWARD;
5076 s->mv_type = MV_TYPE_8X8;
5079 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
5080 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
5082 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
5083 &dmin, &next_block, 0, 0);
5085 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
5086 s->mv_dir = MV_DIR_FORWARD;
5087 s->mv_type = MV_TYPE_16X16;
5089 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
5090 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
5091 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
5092 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5094 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
5095 s->mv_dir = MV_DIR_BACKWARD;
5096 s->mv_type = MV_TYPE_16X16;
5098 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
5099 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
5100 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
5101 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
5103 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
5104 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5105 s->mv_type = MV_TYPE_16X16;
5107 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
5108 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
5109 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
5110 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
5111 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
5112 &dmin, &next_block, 0, 0);
5114 if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
5115 int mx= s->b_direct_mv_table[xy][0];
5116 int my= s->b_direct_mv_table[xy][1];
5118 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
5120 ff_mpeg4_set_direct_mv(s, mx, my);
5121 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
5122 &dmin, &next_block, mx, my);
5124 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
5125 s->mv_dir = MV_DIR_FORWARD;
5126 s->mv_type = MV_TYPE_FIELD;
5129 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
5130 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
5131 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
5133 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
5134 &dmin, &next_block, 0, 0);
5136 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
5137 s->mv_dir = MV_DIR_BACKWARD;
5138 s->mv_type = MV_TYPE_FIELD;
5141 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
5142 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
5143 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
5145 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
5146 &dmin, &next_block, 0, 0);
5148 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
5149 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5150 s->mv_type = MV_TYPE_FIELD;
5152 for(dir=0; dir<2; dir++){
5154 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
5155 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
5156 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
5159 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
5160 &dmin, &next_block, 0, 0);
5162 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
5164 s->mv_type = MV_TYPE_16X16;
5168 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
5169 &dmin, &next_block, 0, 0);
5170 if(s->h263_pred || s->h263_aic){
5172 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
5174 ff_clean_intra_table_entries(s); //old mode?
5178 if(s->flags & CODEC_FLAG_QP_RD){
5179 if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
5180 const int last_qp= backup_s.qscale;
5181 int dquant, dir, qp, dc[6];
5183 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
5185 assert(backup_s.dquant == 0);
5188 s->mv_dir= best_s.mv_dir;
5189 s->mv_type = MV_TYPE_16X16;
5190 s->mb_intra= best_s.mb_intra;
5191 s->mv[0][0][0] = best_s.mv[0][0][0];
5192 s->mv[0][0][1] = best_s.mv[0][0][1];
5193 s->mv[1][0][0] = best_s.mv[1][0][0];
5194 s->mv[1][0][1] = best_s.mv[1][0][1];
5196 dir= s->pict_type == B_TYPE ? 2 : 1;
5197 if(last_qp + dir > s->avctx->qmax) dir= -dir;
5198 for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
5199 qp= last_qp + dquant;
5200 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
5202 backup_s.dquant= dquant;
5203 if(s->mb_intra && s->dc_val[0]){
5205 dc[i]= s->dc_val[0][ s->block_index[i] ];
5206 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
5210 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
5211 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
5212 if(best_s.qscale != qp){
5213 if(s->mb_intra && s->dc_val[0]){
5215 s->dc_val[0][ s->block_index[i] ]= dc[i];
5216 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
5219 if(dir > 0 && dquant==dir){
5227 s->current_picture.qscale_table[xy]= qp;
5231 copy_context_after_encode(s, &best_s, -1);
5233 pb_bits_count= put_bits_count(&s->pb);
5234 flush_put_bits(&s->pb);
5235 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
5238 if(s->data_partitioning){
5239 pb2_bits_count= put_bits_count(&s->pb2);
5240 flush_put_bits(&s->pb2);
5241 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
5242 s->pb2= backup_s.pb2;
5244 tex_pb_bits_count= put_bits_count(&s->tex_pb);
5245 flush_put_bits(&s->tex_pb);
5246 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
5247 s->tex_pb= backup_s.tex_pb;
5249 s->last_bits= put_bits_count(&s->pb);
5251 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
5252 ff_h263_update_motion_val(s);
5254 if(next_block==0){ //FIXME 16 vs linesize16
5255 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
5256 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
5257 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
5260 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
5261 MPV_decode_mb(s, s->block);
5263 int motion_x, motion_y;
5264 s->mv_type=MV_TYPE_16X16;
5265 // only one MB-Type possible
5268 case CANDIDATE_MB_TYPE_INTRA:
5271 motion_x= s->mv[0][0][0] = 0;
5272 motion_y= s->mv[0][0][1] = 0;
5274 case CANDIDATE_MB_TYPE_INTER:
5275 s->mv_dir = MV_DIR_FORWARD;
5277 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
5278 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
5280 case CANDIDATE_MB_TYPE_INTER_I:
5281 s->mv_dir = MV_DIR_FORWARD;
5282 s->mv_type = MV_TYPE_FIELD;
5285 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
5286 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
5287 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
5289 motion_x = motion_y = 0;
5291 case CANDIDATE_MB_TYPE_INTER4V:
5292 s->mv_dir = MV_DIR_FORWARD;
5293 s->mv_type = MV_TYPE_8X8;
5296 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
5297 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
5299 motion_x= motion_y= 0;
5301 case CANDIDATE_MB_TYPE_DIRECT:
5302 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
5304 motion_x=s->b_direct_mv_table[xy][0];
5305 motion_y=s->b_direct_mv_table[xy][1];
5306 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
5308 case CANDIDATE_MB_TYPE_BIDIR:
5309 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5313 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
5314 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
5315 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
5316 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
5318 case CANDIDATE_MB_TYPE_BACKWARD:
5319 s->mv_dir = MV_DIR_BACKWARD;
5321 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
5322 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
5324 case CANDIDATE_MB_TYPE_FORWARD:
5325 s->mv_dir = MV_DIR_FORWARD;
5327 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
5328 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
5329 // printf(" %d %d ", motion_x, motion_y);
5331 case CANDIDATE_MB_TYPE_FORWARD_I:
5332 s->mv_dir = MV_DIR_FORWARD;
5333 s->mv_type = MV_TYPE_FIELD;
5336 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
5337 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
5338 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
5340 motion_x=motion_y=0;
5342 case CANDIDATE_MB_TYPE_BACKWARD_I:
5343 s->mv_dir = MV_DIR_BACKWARD;
5344 s->mv_type = MV_TYPE_FIELD;
5347 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
5348 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
5349 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
5351 motion_x=motion_y=0;
5353 case CANDIDATE_MB_TYPE_BIDIR_I:
5354 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5355 s->mv_type = MV_TYPE_FIELD;
5357 for(dir=0; dir<2; dir++){
5359 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
5360 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
5361 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
5364 motion_x=motion_y=0;
5367 motion_x=motion_y=0; //gcc warning fix
5368 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
5371 encode_mb(s, motion_x, motion_y);
5373 // RAL: Update last macroblock type
5374 s->last_mv_dir = s->mv_dir;
5376 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
5377 ff_h263_update_motion_val(s);
5379 MPV_decode_mb(s, s->block);
5382 /* clean the MV table in IPS frames for direct mode in B frames */
5383 if(s->mb_intra /* && I,P,S_TYPE */){
5384 s->p_mv_table[xy][0]=0;
5385 s->p_mv_table[xy][1]=0;
5388 if(s->flags&CODEC_FLAG_PSNR){
5392 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
5393 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
5395 s->current_picture.error[0] += sse(
5396 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
5397 s->dest[0], w, h, s->linesize);
5398 s->current_picture.error[1] += sse(
5399 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
5400 s->dest[1], w>>1, h>>1, s->uvlinesize);
5401 s->current_picture.error[2] += sse(
5402 s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
5403 s->dest[2], w>>1, h>>1, s->uvlinesize);
5406 if(s->out_format == FMT_H263)
5407 ff_h263_loop_filter(s);
5409 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
5413 //not beautiful here but we must write it before flushing so it has to be here
5414 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
5415 msmpeg4_encode_ext_header(s);
5419 /* Send the last GOB if RTP */
5420 if (s->avctx->rtp_callback) {
5421 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
5422 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
5423 /* Call the RTP callback to send the last GOB */
5425 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
5431 #define MERGE(field) dst->field += src->field; src->field=0
5432 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
5433 MERGE(me.scene_change_score);
5434 MERGE(me.mc_mb_var_sum_temp);
5435 MERGE(me.mb_var_sum_temp);
5438 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
5441 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
5442 MERGE(dct_count[1]);
5452 MERGE(padding_bug_score);
5453 MERGE(current_picture.error[0]);
5454 MERGE(current_picture.error[1]);
5455 MERGE(current_picture.error[2]);
5457 if(dst->avctx->noise_reduction){
5458 for(i=0; i<64; i++){
5459 MERGE(dct_error_sum[0][i]);
5460 MERGE(dct_error_sum[1][i]);
5464 assert(put_bits_count(&src->pb) % 8 ==0);
5465 assert(put_bits_count(&dst->pb) % 8 ==0);
5466 ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
5467 flush_put_bits(&dst->pb);
5470 static int estimate_qp(MpegEncContext *s, int dry_run){
5471 if (!s->fixed_qscale) {
5472 s->current_picture_ptr->quality=
5473 s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run);
5474 if (s->current_picture.quality < 0)
5478 if(s->adaptive_quant){
5479 switch(s->codec_id){
5480 case CODEC_ID_MPEG4:
5481 ff_clean_mpeg4_qscales(s);
5484 case CODEC_ID_H263P:
5486 ff_clean_h263_qscales(s);
5490 s->lambda= s->lambda_table[0];
5493 s->lambda= s->current_picture.quality;
5494 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
5499 static int encode_picture(MpegEncContext *s, int picture_number)
5504 s->picture_number = picture_number;
5506 /* Reset the average MB variance */
5507 s->me.mb_var_sum_temp =
5508 s->me.mc_mb_var_sum_temp = 0;
5510 /* we need to initialize some time vars before we can encode b-frames */
5511 // RAL: Condition added for MPEG1VIDEO
5512 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
5513 ff_set_mpeg4_time(s, s->picture_number); //FIXME rename and use has_b_frames or similar
5515 s->me.scene_change_score=0;
5517 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
5519 if(s->pict_type==I_TYPE){
5520 if(s->msmpeg4_version >= 3) s->no_rounding=1;
5521 else s->no_rounding=0;
5522 }else if(s->pict_type!=B_TYPE){
5523 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
5524 s->no_rounding ^= 1;
5527 if(s->flags & CODEC_FLAG_PASS2){
5528 if (estimate_qp(s,1) < 0)
5530 ff_get_2pass_fcode(s);
5531 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
5532 if(s->pict_type==B_TYPE)
5533 s->lambda= s->last_lambda_for[s->pict_type];
5535 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
5539 s->mb_intra=0; //for the rate distortion & bit compare functions
5540 for(i=1; i<s->avctx->thread_count; i++){
5541 ff_update_duplicate_context(s->thread_context[i], s);
5546 /* Estimate motion for every MB */
5547 if(s->pict_type != I_TYPE){
5548 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
5549 s->lambda2= (s->lambda2* s->avctx->me_penalty_compensation + 128)>>8;
5550 if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){
5551 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
5552 s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5556 s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5557 }else /* if(s->pict_type == I_TYPE) */{
5559 for(i=0; i<s->mb_stride*s->mb_height; i++)
5560 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
5562 if(!s->fixed_qscale){
5563 /* finding spatial complexity for I-frame rate control */
5564 s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5567 for(i=1; i<s->avctx->thread_count; i++){
5568 merge_context_after_me(s, s->thread_context[i]);
5570 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
5571 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
5574 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
5575 s->pict_type= I_TYPE;
5576 for(i=0; i<s->mb_stride*s->mb_height; i++)
5577 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
5578 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
5582 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
5583 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
5585 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5587 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
5588 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
5589 s->f_code= FFMAX(s->f_code, FFMAX(a,b));
5592 ff_fix_long_p_mvs(s);
5593 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
5594 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5598 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
5599 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
5604 if(s->pict_type==B_TYPE){
5607 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
5608 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5609 s->f_code = FFMAX(a, b);
5611 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
5612 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5613 s->b_code = FFMAX(a, b);
5615 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
5616 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
5617 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5618 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5619 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5621 for(dir=0; dir<2; dir++){
5624 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
5625 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
5626 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
5627 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
5635 if (estimate_qp(s, 0) < 0)
5638 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE))
5639 s->qscale= 3; //reduce clipping problems
5641 if (s->out_format == FMT_MJPEG) {
5642 /* for mjpeg, we do include qscale in the matrix */
5643 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
5645 int j= s->dsp.idct_permutation[i];
5647 s->intra_matrix[j] = clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
5649 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
5650 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
5654 //FIXME var duplication
5655 s->current_picture_ptr->key_frame=
5656 s->current_picture.key_frame= s->pict_type == I_TYPE; //FIXME pic_ptr
5657 s->current_picture_ptr->pict_type=
5658 s->current_picture.pict_type= s->pict_type;
5660 if(s->current_picture.key_frame)
5661 s->picture_in_gop_number=0;
5663 s->last_bits= put_bits_count(&s->pb);
5664 switch(s->out_format) {
5666 mjpeg_picture_header(s);
5668 #ifdef CONFIG_H261_ENCODER
5670 ff_h261_encode_picture_header(s, picture_number);
5674 if (s->codec_id == CODEC_ID_WMV2)
5675 ff_wmv2_encode_picture_header(s, picture_number);
5676 else if (s->h263_msmpeg4)
5677 msmpeg4_encode_picture_header(s, picture_number);
5678 else if (s->h263_pred)
5679 mpeg4_encode_picture_header(s, picture_number);
5680 #ifdef CONFIG_RV10_ENCODER
5681 else if (s->codec_id == CODEC_ID_RV10)
5682 rv10_encode_picture_header(s, picture_number);
5684 #ifdef CONFIG_RV20_ENCODER
5685 else if (s->codec_id == CODEC_ID_RV20)
5686 rv20_encode_picture_header(s, picture_number);
5688 else if (s->codec_id == CODEC_ID_FLV1)
5689 ff_flv_encode_picture_header(s, picture_number);
5691 h263_encode_picture_header(s, picture_number);
5694 mpeg1_encode_picture_header(s, picture_number);
5701 bits= put_bits_count(&s->pb);
5702 s->header_bits= bits - s->last_bits;
5704 for(i=1; i<s->avctx->thread_count; i++){
5705 update_duplicate_context_after_me(s->thread_context[i], s);
5707 s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5708 for(i=1; i<s->avctx->thread_count; i++){
5709 merge_context_after_encode(s, s->thread_context[i]);
5715 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
5716 const int intra= s->mb_intra;
5719 s->dct_count[intra]++;
5721 for(i=0; i<64; i++){
5722 int level= block[i];
5726 s->dct_error_sum[intra][i] += level;
5727 level -= s->dct_offset[intra][i];
5728 if(level<0) level=0;
5730 s->dct_error_sum[intra][i] -= level;
5731 level += s->dct_offset[intra][i];
5732 if(level>0) level=0;
5739 static int dct_quantize_trellis_c(MpegEncContext *s,
5740 DCTELEM *block, int n,
5741 int qscale, int *overflow){
5743 const uint8_t *scantable= s->intra_scantable.scantable;
5744 const uint8_t *perm_scantable= s->intra_scantable.permutated;
5746 unsigned int threshold1, threshold2;
5758 int coeff_count[64];
5759 int qmul, qadd, start_i, last_non_zero, i, dc;
5760 const int esc_length= s->ac_esc_length;
5762 uint8_t * last_length;
5763 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
5765 s->dsp.fdct (block);
5767 if(s->dct_error_sum)
5768 s->denoise_dct(s, block);
5770 qadd= ((qscale-1)|1)*8;
5781 /* For AIC we skip quant/dequant of INTRADC */
5786 /* note: block[0] is assumed to be positive */
5787 block[0] = (block[0] + (q >> 1)) / q;
5790 qmat = s->q_intra_matrix[qscale];
5791 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
5792 bias= 1<<(QMAT_SHIFT-1);
5793 length = s->intra_ac_vlc_length;
5794 last_length= s->intra_ac_vlc_last_length;
5798 qmat = s->q_inter_matrix[qscale];
5799 length = s->inter_ac_vlc_length;
5800 last_length= s->inter_ac_vlc_last_length;
5804 threshold1= (1<<QMAT_SHIFT) - bias - 1;
5805 threshold2= (threshold1<<1);
5807 for(i=63; i>=start_i; i--) {
5808 const int j = scantable[i];
5809 int level = block[j] * qmat[j];
5811 if(((unsigned)(level+threshold1))>threshold2){
5817 for(i=start_i; i<=last_non_zero; i++) {
5818 const int j = scantable[i];
5819 int level = block[j] * qmat[j];
5821 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
5822 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
5823 if(((unsigned)(level+threshold1))>threshold2){
5825 level= (bias + level)>>QMAT_SHIFT;
5827 coeff[1][i]= level-1;
5828 // coeff[2][k]= level-2;
5830 level= (bias - level)>>QMAT_SHIFT;
5831 coeff[0][i]= -level;
5832 coeff[1][i]= -level+1;
5833 // coeff[2][k]= -level+2;
5835 coeff_count[i]= FFMIN(level, 2);
5836 assert(coeff_count[i]);
5839 coeff[0][i]= (level>>31)|1;
5844 *overflow= s->max_qcoeff < max; //overflow might have happened
5846 if(last_non_zero < start_i){
5847 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
5848 return last_non_zero;
5851 score_tab[start_i]= 0;
5852 survivor[0]= start_i;
5855 for(i=start_i; i<=last_non_zero; i++){
5857 const int dct_coeff= ABS(block[ scantable[i] ]);
5858 const int zero_distoration= dct_coeff*dct_coeff;
5859 int best_score=256*256*256*120;
5860 for(level_index=0; level_index < coeff_count[i]; level_index++){
5862 int level= coeff[level_index][i];
5863 const int alevel= ABS(level);
5868 if(s->out_format == FMT_H263){
5869 unquant_coeff= alevel*qmul + qadd;
5871 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
5873 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
5874 unquant_coeff = (unquant_coeff - 1) | 1;
5876 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
5877 unquant_coeff = (unquant_coeff - 1) | 1;
5882 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration;
5884 if((level&(~127)) == 0){
5885 for(j=survivor_count-1; j>=0; j--){
5886 int run= i - survivor[j];
5887 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5888 score += score_tab[i-run];
5890 if(score < best_score){
5893 level_tab[i+1]= level-64;
5897 if(s->out_format == FMT_H263){
5898 for(j=survivor_count-1; j>=0; j--){
5899 int run= i - survivor[j];
5900 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5901 score += score_tab[i-run];
5902 if(score < last_score){
5905 last_level= level-64;
5911 distoration += esc_length*lambda;
5912 for(j=survivor_count-1; j>=0; j--){
5913 int run= i - survivor[j];
5914 int score= distoration + score_tab[i-run];
5916 if(score < best_score){
5919 level_tab[i+1]= level-64;
5923 if(s->out_format == FMT_H263){
5924 for(j=survivor_count-1; j>=0; j--){
5925 int run= i - survivor[j];
5926 int score= distoration + score_tab[i-run];
5927 if(score < last_score){
5930 last_level= level-64;
5938 score_tab[i+1]= best_score;
5940 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
5941 if(last_non_zero <= 27){
5942 for(; survivor_count; survivor_count--){
5943 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
5947 for(; survivor_count; survivor_count--){
5948 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
5953 survivor[ survivor_count++ ]= i+1;
5956 if(s->out_format != FMT_H263){
5957 last_score= 256*256*256*120;
5958 for(i= survivor[0]; i<=last_non_zero + 1; i++){
5959 int score= score_tab[i];
5960 if(i) score += lambda*2; //FIXME exacter?
5962 if(score < last_score){
5965 last_level= level_tab[i];
5966 last_run= run_tab[i];
5971 s->coded_score[n] = last_score;
5974 last_non_zero= last_i - 1;
5975 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
5977 if(last_non_zero < start_i)
5978 return last_non_zero;
5980 if(last_non_zero == 0 && start_i == 0){
5982 int best_score= dc * dc;
5984 for(i=0; i<coeff_count[0]; i++){
5985 int level= coeff[i][0];
5986 int alevel= ABS(level);
5987 int unquant_coeff, score, distortion;
5989 if(s->out_format == FMT_H263){
5990 unquant_coeff= (alevel*qmul + qadd)>>3;
5992 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
5993 unquant_coeff = (unquant_coeff - 1) | 1;
5995 unquant_coeff = (unquant_coeff + 4) >> 3;
5996 unquant_coeff<<= 3 + 3;
5998 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
6000 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
6001 else score= distortion + esc_length*lambda;
6003 if(score < best_score){
6005 best_level= level - 64;
6008 block[0]= best_level;
6009 s->coded_score[n] = best_score - dc*dc;
6010 if(best_level == 0) return -1;
6011 else return last_non_zero;
6017 block[ perm_scantable[last_non_zero] ]= last_level;
6020 for(; i>start_i; i -= run_tab[i] + 1){
6021 block[ perm_scantable[i-1] ]= level_tab[i];
6024 return last_non_zero;
6027 //#define REFINE_STATS 1
6028 static int16_t basis[64][64];
6030 static void build_basis(uint8_t *perm){
6037 double s= 0.25*(1<<BASIS_SHIFT);
6039 int perm_index= perm[index];
6040 if(i==0) s*= sqrt(0.5);
6041 if(j==0) s*= sqrt(0.5);
6042 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)));
6049 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
6050 DCTELEM *block, int16_t *weight, DCTELEM *orig,
6053 DECLARE_ALIGNED_16(DCTELEM, d1[64]);
6055 const uint8_t *scantable= s->intra_scantable.scantable;
6056 const uint8_t *perm_scantable= s->intra_scantable.permutated;
6057 // unsigned int threshold1, threshold2;
6062 int qmul, qadd, start_i, last_non_zero, i, dc;
6064 uint8_t * last_length;
6066 int rle_index, run, q, sum;
6069 static int after_last=0;
6070 static int to_zero=0;
6071 static int from_zero=0;
6074 static int messed_sign=0;
6077 if(basis[0][0] == 0)
6078 build_basis(s->dsp.idct_permutation);
6089 /* For AIC we skip quant/dequant of INTRADC */
6093 q <<= RECON_SHIFT-3;
6094 /* note: block[0] is assumed to be positive */
6096 // block[0] = (block[0] + (q >> 1)) / q;
6098 qmat = s->q_intra_matrix[qscale];
6099 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
6100 // bias= 1<<(QMAT_SHIFT-1);
6101 length = s->intra_ac_vlc_length;
6102 last_length= s->intra_ac_vlc_last_length;
6106 qmat = s->q_inter_matrix[qscale];
6107 length = s->inter_ac_vlc_length;
6108 last_length= s->inter_ac_vlc_last_length;
6110 last_non_zero = s->block_last_index[n];
6115 dc += (1<<(RECON_SHIFT-1));
6116 for(i=0; i<64; i++){
6117 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
6120 STOP_TIMER("memset rem[]")}
6123 for(i=0; i<64; i++){
6128 w= ABS(weight[i]) + qns*one;
6129 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
6132 // w=weight[i] = (63*qns + (w/2)) / w;
6138 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
6144 for(i=start_i; i<=last_non_zero; i++){
6145 int j= perm_scantable[i];
6146 const int level= block[j];
6150 if(level<0) coeff= qmul*level - qadd;
6151 else coeff= qmul*level + qadd;
6152 run_tab[rle_index++]=run;
6155 s->dsp.add_8x8basis(rem, basis[j], coeff);
6161 if(last_non_zero>0){
6162 STOP_TIMER("init rem[]")
6169 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
6172 int run2, best_unquant_change=0, analyze_gradient;
6176 analyze_gradient = last_non_zero > 2 || s->avctx->quantizer_noise_shaping >= 3;
6178 if(analyze_gradient){
6182 for(i=0; i<64; i++){
6185 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
6188 STOP_TIMER("rem*w*w")}
6198 const int level= block[0];
6199 int change, old_coeff;
6201 assert(s->mb_intra);
6205 for(change=-1; change<=1; change+=2){
6206 int new_level= level + change;
6207 int score, new_coeff;
6209 new_coeff= q*new_level;
6210 if(new_coeff >= 2048 || new_coeff < 0)
6213 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
6214 if(score<best_score){
6217 best_change= change;
6218 best_unquant_change= new_coeff - old_coeff;
6225 run2= run_tab[rle_index++];
6229 for(i=start_i; i<64; i++){
6230 int j= perm_scantable[i];
6231 const int level= block[j];
6232 int change, old_coeff;
6234 if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
6238 if(level<0) old_coeff= qmul*level - qadd;
6239 else old_coeff= qmul*level + qadd;
6240 run2= run_tab[rle_index++]; //FIXME ! maybe after last
6244 assert(run2>=0 || i >= last_non_zero );
6247 for(change=-1; change<=1; change+=2){
6248 int new_level= level + change;
6249 int score, new_coeff, unquant_change;
6252 if(s->avctx->quantizer_noise_shaping < 2 && ABS(new_level) > ABS(level))
6256 if(new_level<0) new_coeff= qmul*new_level - qadd;
6257 else new_coeff= qmul*new_level + qadd;
6258 if(new_coeff >= 2048 || new_coeff <= -2048)
6260 //FIXME check for overflow
6263 if(level < 63 && level > -63){
6264 if(i < last_non_zero)
6265 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
6266 - length[UNI_AC_ENC_INDEX(run, level+64)];
6268 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
6269 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
6272 assert(ABS(new_level)==1);
6274 if(analyze_gradient){
6275 int g= d1[ scantable[i] ];
6276 if(g && (g^new_level) >= 0)
6280 if(i < last_non_zero){
6281 int next_i= i + run2 + 1;
6282 int next_level= block[ perm_scantable[next_i] ] + 64;
6284 if(next_level&(~127))
6287 if(next_i < last_non_zero)
6288 score += length[UNI_AC_ENC_INDEX(run, 65)]
6289 + length[UNI_AC_ENC_INDEX(run2, next_level)]
6290 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
6292 score += length[UNI_AC_ENC_INDEX(run, 65)]
6293 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
6294 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
6296 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
6298 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
6299 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
6305 assert(ABS(level)==1);
6307 if(i < last_non_zero){
6308 int next_i= i + run2 + 1;
6309 int next_level= block[ perm_scantable[next_i] ] + 64;
6311 if(next_level&(~127))
6314 if(next_i < last_non_zero)
6315 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
6316 - length[UNI_AC_ENC_INDEX(run2, next_level)]
6317 - length[UNI_AC_ENC_INDEX(run, 65)];
6319 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
6320 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
6321 - length[UNI_AC_ENC_INDEX(run, 65)];
6323 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
6325 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
6326 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
6333 unquant_change= new_coeff - old_coeff;
6334 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
6336 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
6337 if(score<best_score){
6340 best_change= change;
6341 best_unquant_change= unquant_change;
6345 prev_level= level + 64;
6346 if(prev_level&(~127))
6355 STOP_TIMER("iterative step")}
6359 int j= perm_scantable[ best_coeff ];
6361 block[j] += best_change;
6363 if(best_coeff > last_non_zero){
6364 last_non_zero= best_coeff;
6372 if(block[j] - best_change){
6373 if(ABS(block[j]) > ABS(block[j] - best_change)){
6385 for(; last_non_zero>=start_i; last_non_zero--){
6386 if(block[perm_scantable[last_non_zero]])
6392 if(256*256*256*64 % count == 0){
6393 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);
6398 for(i=start_i; i<=last_non_zero; i++){
6399 int j= perm_scantable[i];
6400 const int level= block[j];
6403 run_tab[rle_index++]=run;
6410 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
6416 if(last_non_zero>0){
6417 STOP_TIMER("iterative search")
6422 return last_non_zero;
6425 static int dct_quantize_c(MpegEncContext *s,
6426 DCTELEM *block, int n,
6427 int qscale, int *overflow)
6429 int i, j, level, last_non_zero, q, start_i;
6431 const uint8_t *scantable= s->intra_scantable.scantable;
6434 unsigned int threshold1, threshold2;
6436 s->dsp.fdct (block);
6438 if(s->dct_error_sum)
6439 s->denoise_dct(s, block);
6449 /* For AIC we skip quant/dequant of INTRADC */
6452 /* note: block[0] is assumed to be positive */
6453 block[0] = (block[0] + (q >> 1)) / q;
6456 qmat = s->q_intra_matrix[qscale];
6457 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
6461 qmat = s->q_inter_matrix[qscale];
6462 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
6464 threshold1= (1<<QMAT_SHIFT) - bias - 1;
6465 threshold2= (threshold1<<1);
6466 for(i=63;i>=start_i;i--) {
6468 level = block[j] * qmat[j];
6470 if(((unsigned)(level+threshold1))>threshold2){
6477 for(i=start_i; i<=last_non_zero; i++) {
6479 level = block[j] * qmat[j];
6481 // if( bias+level >= (1<<QMAT_SHIFT)
6482 // || bias-level >= (1<<QMAT_SHIFT)){
6483 if(((unsigned)(level+threshold1))>threshold2){
6485 level= (bias + level)>>QMAT_SHIFT;
6488 level= (bias - level)>>QMAT_SHIFT;
6496 *overflow= s->max_qcoeff < max; //overflow might have happened
6498 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
6499 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
6500 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
6502 return last_non_zero;
6505 #endif //CONFIG_ENCODERS
6507 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
6508 DCTELEM *block, int n, int qscale)
6510 int i, level, nCoeffs;
6511 const uint16_t *quant_matrix;
6513 nCoeffs= s->block_last_index[n];
6516 block[0] = block[0] * s->y_dc_scale;
6518 block[0] = block[0] * s->c_dc_scale;
6519 /* XXX: only mpeg1 */
6520 quant_matrix = s->intra_matrix;
6521 for(i=1;i<=nCoeffs;i++) {
6522 int j= s->intra_scantable.permutated[i];
6527 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6528 level = (level - 1) | 1;
6531 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6532 level = (level - 1) | 1;
6539 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
6540 DCTELEM *block, int n, int qscale)
6542 int i, level, nCoeffs;
6543 const uint16_t *quant_matrix;
6545 nCoeffs= s->block_last_index[n];
6547 quant_matrix = s->inter_matrix;
6548 for(i=0; i<=nCoeffs; i++) {
6549 int j= s->intra_scantable.permutated[i];
6554 level = (((level << 1) + 1) * qscale *
6555 ((int) (quant_matrix[j]))) >> 4;
6556 level = (level - 1) | 1;
6559 level = (((level << 1) + 1) * qscale *
6560 ((int) (quant_matrix[j]))) >> 4;
6561 level = (level - 1) | 1;
6568 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
6569 DCTELEM *block, int n, int qscale)
6571 int i, level, nCoeffs;
6572 const uint16_t *quant_matrix;
6574 if(s->alternate_scan) nCoeffs= 63;
6575 else nCoeffs= s->block_last_index[n];
6578 block[0] = block[0] * s->y_dc_scale;
6580 block[0] = block[0] * s->c_dc_scale;
6581 quant_matrix = s->intra_matrix;
6582 for(i=1;i<=nCoeffs;i++) {
6583 int j= s->intra_scantable.permutated[i];
6588 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6591 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6598 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
6599 DCTELEM *block, int n, int qscale)
6601 int i, level, nCoeffs;
6602 const uint16_t *quant_matrix;
6605 if(s->alternate_scan) nCoeffs= 63;
6606 else nCoeffs= s->block_last_index[n];
6609 block[0] = block[0] * s->y_dc_scale;
6611 block[0] = block[0] * s->c_dc_scale;
6612 quant_matrix = s->intra_matrix;
6613 for(i=1;i<=nCoeffs;i++) {
6614 int j= s->intra_scantable.permutated[i];
6619 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6622 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6631 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
6632 DCTELEM *block, int n, int qscale)
6634 int i, level, nCoeffs;
6635 const uint16_t *quant_matrix;
6638 if(s->alternate_scan) nCoeffs= 63;
6639 else nCoeffs= s->block_last_index[n];
6641 quant_matrix = s->inter_matrix;
6642 for(i=0; i<=nCoeffs; i++) {
6643 int j= s->intra_scantable.permutated[i];
6648 level = (((level << 1) + 1) * qscale *
6649 ((int) (quant_matrix[j]))) >> 4;
6652 level = (((level << 1) + 1) * qscale *
6653 ((int) (quant_matrix[j]))) >> 4;
6662 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
6663 DCTELEM *block, int n, int qscale)
6665 int i, level, qmul, qadd;
6668 assert(s->block_last_index[n]>=0);
6674 block[0] = block[0] * s->y_dc_scale;
6676 block[0] = block[0] * s->c_dc_scale;
6677 qadd = (qscale - 1) | 1;
6684 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6686 for(i=1; i<=nCoeffs; i++) {
6690 level = level * qmul - qadd;
6692 level = level * qmul + qadd;
6699 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
6700 DCTELEM *block, int n, int qscale)
6702 int i, level, qmul, qadd;
6705 assert(s->block_last_index[n]>=0);
6707 qadd = (qscale - 1) | 1;
6710 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6712 for(i=0; i<=nCoeffs; i++) {
6716 level = level * qmul - qadd;
6718 level = level * qmul + qadd;
6725 #ifdef CONFIG_ENCODERS
6726 AVCodec h263_encoder = {
6730 sizeof(MpegEncContext),
6734 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6737 AVCodec h263p_encoder = {
6741 sizeof(MpegEncContext),
6745 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6748 AVCodec flv_encoder = {
6752 sizeof(MpegEncContext),
6756 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6759 AVCodec rv10_encoder = {
6763 sizeof(MpegEncContext),
6767 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6770 AVCodec rv20_encoder = {
6774 sizeof(MpegEncContext),
6778 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6781 AVCodec mpeg4_encoder = {
6785 sizeof(MpegEncContext),
6789 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6790 .capabilities= CODEC_CAP_DELAY,
6793 AVCodec msmpeg4v1_encoder = {
6797 sizeof(MpegEncContext),
6801 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6804 AVCodec msmpeg4v2_encoder = {
6808 sizeof(MpegEncContext),
6812 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6815 AVCodec msmpeg4v3_encoder = {
6819 sizeof(MpegEncContext),
6823 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6826 AVCodec wmv1_encoder = {
6830 sizeof(MpegEncContext),
6834 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6837 AVCodec mjpeg_encoder = {
6841 sizeof(MpegEncContext),
6845 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUVJ420P, -1},
6848 #endif //CONFIG_ENCODERS