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 "fastmemcpy.h"
41 #ifdef CONFIG_ENCODERS
42 static void encode_picture(MpegEncContext *s, int picture_number);
43 #endif //CONFIG_ENCODERS
44 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
45 DCTELEM *block, int n, int qscale);
46 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
47 DCTELEM *block, int n, int qscale);
48 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
49 DCTELEM *block, int n, int qscale);
50 static void dct_unquantize_mpeg2_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, int16_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 static void copy_picture_attributes(MpegEncContext *s, AVFrame *dst, AVFrame *src){
332 dst->pict_type = src->pict_type;
333 dst->quality = src->quality;
334 dst->coded_picture_number = src->coded_picture_number;
335 dst->display_picture_number = src->display_picture_number;
336 // dst->reference = src->reference;
338 dst->interlaced_frame = src->interlaced_frame;
339 dst->top_field_first = src->top_field_first;
341 if(s->avctx->me_threshold){
342 if(!src->motion_val[0])
343 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_val not set!\n");
345 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.mb_type not set!\n");
346 if(!src->ref_index[0])
347 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.ref_index not set!\n");
348 if(src->motion_subsample_log2 != dst->motion_subsample_log2)
349 av_log(s->avctx, AV_LOG_ERROR, "AVFrame.motion_subsample_log2 doesn't match! (%d!=%d)\n",
350 src->motion_subsample_log2, dst->motion_subsample_log2);
352 memcpy(dst->mb_type, src->mb_type, s->mb_stride * s->mb_height * sizeof(dst->mb_type[0]));
355 int stride= ((16*s->mb_width )>>src->motion_subsample_log2) + 1;
356 int height= ((16*s->mb_height)>>src->motion_subsample_log2);
358 if(src->motion_val[i] && src->motion_val[i] != dst->motion_val[i]){
359 memcpy(dst->motion_val[i], src->motion_val[i], 2*stride*height*sizeof(int16_t));
361 if(src->ref_index[i] && src->ref_index[i] != dst->ref_index[i]){
362 memcpy(dst->ref_index[i], src->ref_index[i], s->b8_stride*2*s->mb_height*sizeof(int8_t));
369 * allocates a Picture
370 * The pixels are allocated/set by calling get_buffer() if shared=0
372 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
373 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) doesnt sig11
374 const int mb_array_size= s->mb_stride*s->mb_height;
375 const int b8_array_size= s->b8_stride*s->mb_height*2;
376 const int b4_array_size= s->b4_stride*s->mb_height*4;
380 assert(pic->data[0]);
381 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
382 pic->type= FF_BUFFER_TYPE_SHARED;
386 assert(!pic->data[0]);
388 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
390 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
391 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
395 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
396 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
400 if(pic->linesize[1] != pic->linesize[2]){
401 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
405 s->linesize = pic->linesize[0];
406 s->uvlinesize= pic->linesize[1];
409 if(pic->qscale_table==NULL){
411 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
412 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
413 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
416 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
417 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
418 CHECKED_ALLOCZ(pic->mb_type_base , big_mb_num * sizeof(uint32_t))
419 pic->mb_type= pic->mb_type_base + s->mb_stride+1;
420 if(s->out_format == FMT_H264){
422 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t))
423 pic->motion_val[i]= pic->motion_val_base[i]+4;
424 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
426 pic->motion_subsample_log2= 2;
427 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
429 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
430 pic->motion_val[i]= pic->motion_val_base[i]+4;
431 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
433 pic->motion_subsample_log2= 3;
435 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
436 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
438 pic->qstride= s->mb_stride;
439 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
442 //it might be nicer if the application would keep track of these but it would require a API change
443 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
444 s->prev_pict_types[0]= s->pict_type;
445 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == B_TYPE)
446 pic->age= INT_MAX; // skipped MBs in b frames are quite rare in mpeg1/2 and its a bit tricky to skip them anyway
449 fail: //for the CHECKED_ALLOCZ macro
454 * deallocates a picture
456 static void free_picture(MpegEncContext *s, Picture *pic){
459 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
460 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
463 av_freep(&pic->mb_var);
464 av_freep(&pic->mc_mb_var);
465 av_freep(&pic->mb_mean);
466 av_freep(&pic->mbskip_table);
467 av_freep(&pic->qscale_table);
468 av_freep(&pic->mb_type_base);
469 av_freep(&pic->dct_coeff);
470 av_freep(&pic->pan_scan);
473 av_freep(&pic->motion_val_base[i]);
474 av_freep(&pic->ref_index[i]);
477 if(pic->type == FF_BUFFER_TYPE_SHARED){
486 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
489 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
490 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
491 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
493 //FIXME should be linesize instead of s->width*2 but that isnt known before get_buffer()
494 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
495 s->rd_scratchpad= s->me.scratchpad;
496 s->b_scratchpad= s->me.scratchpad;
497 s->obmc_scratchpad= s->me.scratchpad + 16;
499 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
500 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
501 if(s->avctx->noise_reduction){
502 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
505 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
506 s->block= s->blocks[0];
509 s->pblocks[i] = (short *)(&s->block[i]);
513 return -1; //free() through MPV_common_end()
516 static void free_duplicate_context(MpegEncContext *s){
519 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
520 av_freep(&s->me.scratchpad);
523 s->obmc_scratchpad= NULL;
525 av_freep(&s->dct_error_sum);
526 av_freep(&s->me.map);
527 av_freep(&s->me.score_map);
528 av_freep(&s->blocks);
532 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
533 #define COPY(a) bak->a= src->a
534 COPY(allocated_edge_emu_buffer);
535 COPY(edge_emu_buffer);
539 COPY(obmc_scratchpad);
546 COPY(me.map_generation);
554 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
557 //FIXME copy only needed parts
559 backup_duplicate_context(&bak, dst);
560 memcpy(dst, src, sizeof(MpegEncContext));
561 backup_duplicate_context(dst, &bak);
563 dst->pblocks[i] = (short *)(&dst->block[i]);
565 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
568 static void update_duplicate_context_after_me(MpegEncContext *dst, MpegEncContext *src){
569 #define COPY(a) dst->a= src->a
571 COPY(current_picture);
577 COPY(picture_in_gop_number);
578 COPY(gop_picture_number);
579 COPY(frame_pred_frame_dct); //FIXME don't set in encode_header
580 COPY(progressive_frame); //FIXME don't set in encode_header
581 COPY(partitioned_frame); //FIXME don't set in encode_header
586 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
587 * the changed fields will not depend upon the prior state of the MpegEncContext.
589 static void MPV_common_defaults(MpegEncContext *s){
591 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
592 s->chroma_qscale_table= ff_default_chroma_qscale_table;
593 s->progressive_frame= 1;
594 s->progressive_sequence= 1;
595 s->picture_structure= PICT_FRAME;
597 s->coded_picture_number = 0;
598 s->picture_number = 0;
599 s->input_picture_number = 0;
601 s->picture_in_gop_number = 0;
608 * sets the given MpegEncContext to defaults for decoding.
609 * the changed fields will not depend upon the prior state of the MpegEncContext.
611 void MPV_decode_defaults(MpegEncContext *s){
612 MPV_common_defaults(s);
616 * sets the given MpegEncContext to defaults for encoding.
617 * the changed fields will not depend upon the prior state of the MpegEncContext.
620 #ifdef CONFIG_ENCODERS
621 static void MPV_encode_defaults(MpegEncContext *s){
624 MPV_common_defaults(s);
630 default_mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) );
631 memset(default_fcode_tab , 0, sizeof(uint8_t)*(2*MAX_MV+1));
633 for(i=-16; i<16; i++){
634 default_fcode_tab[i + MAX_MV]= 1;
637 s->me.mv_penalty= default_mv_penalty;
638 s->fcode_tab= default_fcode_tab;
640 #endif //CONFIG_ENCODERS
643 * init common structure for both encoder and decoder.
644 * this assumes that some variables like width/height are already set
646 int MPV_common_init(MpegEncContext *s)
648 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
650 s->mb_height = (s->height + 15) / 16;
652 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
653 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
657 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
660 dsputil_init(&s->dsp, s->avctx);
663 s->flags= s->avctx->flags;
664 s->flags2= s->avctx->flags2;
666 s->mb_width = (s->width + 15) / 16;
667 s->mb_stride = s->mb_width + 1;
668 s->b8_stride = s->mb_width*2 + 1;
669 s->b4_stride = s->mb_width*4 + 1;
670 mb_array_size= s->mb_height * s->mb_stride;
671 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
673 /* set chroma shifts */
674 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
675 &(s->chroma_y_shift) );
677 /* set default edge pos, will be overriden in decode_header if needed */
678 s->h_edge_pos= s->mb_width*16;
679 s->v_edge_pos= s->mb_height*16;
681 s->mb_num = s->mb_width * s->mb_height;
686 s->block_wrap[3]= s->b8_stride;
688 s->block_wrap[5]= s->mb_stride;
690 y_size = s->b8_stride * (2 * s->mb_height + 1);
691 c_size = s->mb_stride * (s->mb_height + 1);
692 yc_size = y_size + 2 * c_size;
694 /* convert fourcc to upper case */
695 s->avctx->codec_tag= toupper( s->avctx->codec_tag &0xFF)
696 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
697 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
698 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
700 s->avctx->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
701 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
702 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
703 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
705 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
707 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
708 for(y=0; y<s->mb_height; y++){
709 for(x=0; x<s->mb_width; x++){
710 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
713 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
716 /* Allocate MV tables */
717 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
718 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
719 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
720 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
721 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
722 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
723 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
724 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
725 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
726 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
727 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
728 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
730 if(s->msmpeg4_version){
731 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
733 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
735 /* Allocate MB type table */
736 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
738 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
740 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
741 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
742 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
743 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
744 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
745 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
747 if(s->avctx->noise_reduction){
748 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
751 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
753 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
755 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
756 /* interlaced direct mode decoding tables */
761 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
762 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
764 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
765 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
766 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
768 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
771 if (s->out_format == FMT_H263) {
773 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
774 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
775 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
776 s->ac_val[2] = s->ac_val[1] + c_size;
779 CHECKED_ALLOCZ(s->coded_block_base, y_size);
780 s->coded_block= s->coded_block_base + s->b8_stride + 1;
782 /* cbp, ac_pred, pred_dir */
783 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
784 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
787 if (s->h263_pred || s->h263_plus || !s->encoding) {
789 //MN: we need these for error resilience of intra-frames
790 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
791 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
792 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
793 s->dc_val[2] = s->dc_val[1] + c_size;
794 for(i=0;i<yc_size;i++)
795 s->dc_val_base[i] = 1024;
798 /* which mb is a intra block */
799 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
800 memset(s->mbintra_table, 1, mb_array_size);
802 /* init macroblock skip table */
803 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
804 //Note the +1 is for a quicker mpeg4 slice_end detection
805 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
807 s->parse_context.state= -1;
808 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
809 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
810 s->visualization_buffer[1] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
811 s->visualization_buffer[2] = av_malloc((s->mb_width*8 + EDGE_WIDTH) * s->mb_height*8 + EDGE_WIDTH);
814 s->context_initialized = 1;
816 s->thread_context[0]= s;
817 for(i=1; i<s->avctx->thread_count; i++){
818 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
819 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
822 for(i=0; i<s->avctx->thread_count; i++){
823 if(init_duplicate_context(s->thread_context[i], s) < 0)
825 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
826 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
835 /* init common structure for both encoder and decoder */
836 void MPV_common_end(MpegEncContext *s)
840 for(i=0; i<s->avctx->thread_count; i++){
841 free_duplicate_context(s->thread_context[i]);
843 for(i=1; i<s->avctx->thread_count; i++){
844 av_freep(&s->thread_context[i]);
847 av_freep(&s->parse_context.buffer);
848 s->parse_context.buffer_size=0;
850 av_freep(&s->mb_type);
851 av_freep(&s->p_mv_table_base);
852 av_freep(&s->b_forw_mv_table_base);
853 av_freep(&s->b_back_mv_table_base);
854 av_freep(&s->b_bidir_forw_mv_table_base);
855 av_freep(&s->b_bidir_back_mv_table_base);
856 av_freep(&s->b_direct_mv_table_base);
858 s->b_forw_mv_table= NULL;
859 s->b_back_mv_table= NULL;
860 s->b_bidir_forw_mv_table= NULL;
861 s->b_bidir_back_mv_table= NULL;
862 s->b_direct_mv_table= NULL;
866 av_freep(&s->b_field_mv_table_base[i][j][k]);
867 s->b_field_mv_table[i][j][k]=NULL;
869 av_freep(&s->b_field_select_table[i][j]);
870 av_freep(&s->p_field_mv_table_base[i][j]);
871 s->p_field_mv_table[i][j]=NULL;
873 av_freep(&s->p_field_select_table[i]);
876 av_freep(&s->dc_val_base);
877 av_freep(&s->ac_val_base);
878 av_freep(&s->coded_block_base);
879 av_freep(&s->mbintra_table);
880 av_freep(&s->cbp_table);
881 av_freep(&s->pred_dir_table);
883 av_freep(&s->mbskip_table);
884 av_freep(&s->prev_pict_types);
885 av_freep(&s->bitstream_buffer);
886 s->allocated_bitstream_buffer_size=0;
888 av_freep(&s->avctx->stats_out);
889 av_freep(&s->ac_stats);
890 av_freep(&s->error_status_table);
891 av_freep(&s->mb_index2xy);
892 av_freep(&s->lambda_table);
893 av_freep(&s->q_intra_matrix);
894 av_freep(&s->q_inter_matrix);
895 av_freep(&s->q_intra_matrix16);
896 av_freep(&s->q_inter_matrix16);
897 av_freep(&s->input_picture);
898 av_freep(&s->reordered_input_picture);
899 av_freep(&s->dct_offset);
902 for(i=0; i<MAX_PICTURE_COUNT; i++){
903 free_picture(s, &s->picture[i]);
906 av_freep(&s->picture);
907 s->context_initialized = 0;
910 s->current_picture_ptr= NULL;
911 s->linesize= s->uvlinesize= 0;
914 av_freep(&s->visualization_buffer[i]);
916 avcodec_default_free_buffers(s->avctx);
919 #ifdef CONFIG_ENCODERS
921 /* init video encoder */
922 int MPV_encode_init(AVCodecContext *avctx)
924 MpegEncContext *s = avctx->priv_data;
926 int chroma_h_shift, chroma_v_shift;
928 MPV_encode_defaults(s);
930 switch (avctx->codec_id) {
931 case CODEC_ID_MPEG2VIDEO:
932 if(avctx->pix_fmt != PIX_FMT_YUV420P && avctx->pix_fmt != PIX_FMT_YUV422P){
933 av_log(avctx, AV_LOG_ERROR, "only YUV420 and YUV422 are supported\n");
939 if(avctx->pix_fmt != PIX_FMT_YUVJ420P && (avctx->pix_fmt != PIX_FMT_YUV420P || avctx->strict_std_compliance>FF_COMPLIANCE_INOFFICIAL)){
940 av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
945 if(avctx->pix_fmt != PIX_FMT_YUV420P){
946 av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
951 switch (avctx->pix_fmt) {
952 case PIX_FMT_YUVJ422P:
953 case PIX_FMT_YUV422P:
954 s->chroma_format = CHROMA_422;
956 case PIX_FMT_YUVJ420P:
957 case PIX_FMT_YUV420P:
959 s->chroma_format = CHROMA_420;
963 s->bit_rate = avctx->bit_rate;
964 s->width = avctx->width;
965 s->height = avctx->height;
966 if(avctx->gop_size > 600 && avctx->strict_std_compliance>FF_COMPLIANCE_EXPERIMENTAL){
967 av_log(avctx, AV_LOG_ERROR, "Warning keyframe interval too large! reducing it ...\n");
970 s->gop_size = avctx->gop_size;
972 s->flags= avctx->flags;
973 s->flags2= avctx->flags2;
974 s->max_b_frames= avctx->max_b_frames;
975 s->codec_id= avctx->codec->id;
976 s->luma_elim_threshold = avctx->luma_elim_threshold;
977 s->chroma_elim_threshold= avctx->chroma_elim_threshold;
978 s->strict_std_compliance= avctx->strict_std_compliance;
979 s->data_partitioning= avctx->flags & CODEC_FLAG_PART;
980 s->quarter_sample= (avctx->flags & CODEC_FLAG_QPEL)!=0;
981 s->mpeg_quant= avctx->mpeg_quant;
982 s->rtp_mode= !!avctx->rtp_payload_size;
983 s->intra_dc_precision= avctx->intra_dc_precision;
984 s->user_specified_pts = AV_NOPTS_VALUE;
986 if (s->gop_size <= 1) {
993 s->me_method = avctx->me_method;
996 s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
998 s->adaptive_quant= ( s->avctx->lumi_masking
999 || s->avctx->dark_masking
1000 || s->avctx->temporal_cplx_masking
1001 || s->avctx->spatial_cplx_masking
1002 || s->avctx->p_masking
1003 || s->avctx->border_masking
1004 || (s->flags&CODEC_FLAG_QP_RD))
1005 && !s->fixed_qscale;
1007 s->obmc= !!(s->flags & CODEC_FLAG_OBMC);
1008 s->loop_filter= !!(s->flags & CODEC_FLAG_LOOP_FILTER);
1009 s->alternate_scan= !!(s->flags & CODEC_FLAG_ALT_SCAN);
1010 s->intra_vlc_format= !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
1012 if(avctx->rc_max_rate && !avctx->rc_buffer_size){
1013 av_log(avctx, AV_LOG_ERROR, "a vbv buffer size is needed, for encoding with a maximum bitrate\n");
1017 if(avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate){
1018 av_log(avctx, AV_LOG_INFO, "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
1021 if(avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate){
1022 av_log(avctx, AV_LOG_INFO, "bitrate below min bitrate\n");
1026 if(avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate){
1027 av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
1031 if( s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate
1032 && (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO)
1033 && 90000LL * (avctx->rc_buffer_size-1) > s->avctx->rc_max_rate*0xFFFFLL){
1035 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");
1038 if((s->flags & CODEC_FLAG_4MV) && s->codec_id != CODEC_ID_MPEG4
1039 && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P && s->codec_id != CODEC_ID_FLV1){
1040 av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
1044 if(s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE){
1045 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with simple mb decision\n");
1049 if(s->obmc && s->codec_id != CODEC_ID_H263 && s->codec_id != CODEC_ID_H263P){
1050 av_log(avctx, AV_LOG_ERROR, "OBMC is only supported with H263(+)\n");
1054 if(s->quarter_sample && s->codec_id != CODEC_ID_MPEG4){
1055 av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
1059 if(s->data_partitioning && s->codec_id != CODEC_ID_MPEG4){
1060 av_log(avctx, AV_LOG_ERROR, "data partitioning not supported by codec\n");
1064 if(s->max_b_frames && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO){
1065 av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
1069 if((s->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME|CODEC_FLAG_ALT_SCAN))
1070 && s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO){
1071 av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
1075 if(s->mpeg_quant && s->codec_id != CODEC_ID_MPEG4){ //FIXME mpeg2 uses that too
1076 av_log(avctx, AV_LOG_ERROR, "mpeg2 style quantization not supported by codec\n");
1080 if((s->flags & CODEC_FLAG_CBP_RD) && !(s->flags & CODEC_FLAG_TRELLIS_QUANT)){
1081 av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
1085 if((s->flags & CODEC_FLAG_QP_RD) && s->avctx->mb_decision != FF_MB_DECISION_RD){
1086 av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
1090 if(s->avctx->scenechange_threshold < 1000000000 && (s->flags & CODEC_FLAG_CLOSED_GOP)){
1091 av_log(avctx, AV_LOG_ERROR, "closed gop with scene change detection arent supported yet\n");
1095 if((s->flags2 & CODEC_FLAG2_INTRA_VLC) && s->codec_id != CODEC_ID_MPEG2VIDEO){
1096 av_log(avctx, AV_LOG_ERROR, "intra vlc table not supported by codec\n");
1100 if(s->avctx->thread_count > 1 && s->codec_id != CODEC_ID_MPEG4
1101 && s->codec_id != CODEC_ID_MPEG1VIDEO && s->codec_id != CODEC_ID_MPEG2VIDEO
1102 && (s->codec_id != CODEC_ID_H263P || !(s->flags & CODEC_FLAG_H263P_SLICE_STRUCT))){
1103 av_log(avctx, AV_LOG_ERROR, "multi threaded encoding not supported by codec\n");
1107 if(s->avctx->thread_count > 1)
1110 if(!avctx->time_base.den || !avctx->time_base.num){
1111 av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
1115 i= (INT_MAX/2+128)>>8;
1116 if(avctx->me_threshold >= i){
1117 av_log(avctx, AV_LOG_ERROR, "me_threshold too large, max is %d\n", i - 1);
1120 if(avctx->mb_threshold >= i){
1121 av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n", i - 1);
1125 if(avctx->b_frame_strategy && (avctx->flags&CODEC_FLAG_PASS2)){
1126 av_log(avctx, AV_LOG_INFO, "notice: b_frame_strategy only affects the first pass\n");
1127 avctx->b_frame_strategy = 0;
1130 i= ff_gcd(avctx->time_base.den, avctx->time_base.num);
1132 av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
1133 avctx->time_base.den /= i;
1134 avctx->time_base.num /= i;
1138 if(s->codec_id==CODEC_ID_MJPEG){
1139 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
1140 s->inter_quant_bias= 0;
1141 }else if(s->mpeg_quant || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO){
1142 s->intra_quant_bias= 3<<(QUANT_BIAS_SHIFT-3); //(a + x*3/8)/x
1143 s->inter_quant_bias= 0;
1145 s->intra_quant_bias=0;
1146 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1149 if(avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
1150 s->intra_quant_bias= avctx->intra_quant_bias;
1151 if(avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
1152 s->inter_quant_bias= avctx->inter_quant_bias;
1154 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
1156 if(avctx->codec_id == CODEC_ID_MPEG4 && s->avctx->time_base.den > (1<<16)-1){
1157 av_log(avctx, AV_LOG_ERROR, "timebase not supported by mpeg 4 standard\n");
1160 s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
1162 switch(avctx->codec->id) {
1163 case CODEC_ID_MPEG1VIDEO:
1164 s->out_format = FMT_MPEG1;
1165 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1166 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1168 case CODEC_ID_MPEG2VIDEO:
1169 s->out_format = FMT_MPEG1;
1170 s->low_delay= 0; //s->max_b_frames ? 0 : 1;
1171 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1174 case CODEC_ID_LJPEG:
1175 case CODEC_ID_JPEGLS:
1176 case CODEC_ID_MJPEG:
1177 s->out_format = FMT_MJPEG;
1178 s->intra_only = 1; /* force intra only for jpeg */
1179 s->mjpeg_write_tables = avctx->codec->id != CODEC_ID_JPEGLS;
1180 s->mjpeg_data_only_frames = 0; /* write all the needed headers */
1181 s->mjpeg_vsample[0] = 1<<chroma_v_shift;
1182 s->mjpeg_vsample[1] = 1;
1183 s->mjpeg_vsample[2] = 1;
1184 s->mjpeg_hsample[0] = 1<<chroma_h_shift;
1185 s->mjpeg_hsample[1] = 1;
1186 s->mjpeg_hsample[2] = 1;
1187 if (mjpeg_init(s) < 0)
1193 s->out_format = FMT_H261;
1198 if (h263_get_picture_format(s->width, s->height) == 7) {
1199 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);
1202 s->out_format = FMT_H263;
1203 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1207 case CODEC_ID_H263P:
1208 s->out_format = FMT_H263;
1211 s->umvplus = (avctx->flags & CODEC_FLAG_H263P_UMV) ? 1:0;
1212 s->h263_aic= (avctx->flags & CODEC_FLAG_H263P_AIC) ? 1:0;
1213 s->modified_quant= s->h263_aic;
1214 s->alt_inter_vlc= (avctx->flags & CODEC_FLAG_H263P_AIV) ? 1:0;
1215 s->obmc= (avctx->flags & CODEC_FLAG_OBMC) ? 1:0;
1216 s->loop_filter= (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1:0;
1217 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1218 s->h263_slice_structured= (s->flags & CODEC_FLAG_H263P_SLICE_STRUCT) ? 1:0;
1221 /* These are just to be sure */
1226 s->out_format = FMT_H263;
1227 s->h263_flv = 2; /* format = 1; 11-bit codes */
1228 s->unrestricted_mv = 1;
1229 s->rtp_mode=0; /* don't allow GOB */
1234 s->out_format = FMT_H263;
1239 s->out_format = FMT_H263;
1242 s->modified_quant=1;
1246 s->unrestricted_mv= s->obmc || s->loop_filter || s->umvplus;
1248 case CODEC_ID_MPEG4:
1249 s->out_format = FMT_H263;
1251 s->unrestricted_mv = 1;
1252 s->low_delay= s->max_b_frames ? 0 : 1;
1253 avctx->delay= s->low_delay ? 0 : (s->max_b_frames + 1);
1255 case CODEC_ID_MSMPEG4V1:
1256 s->out_format = FMT_H263;
1257 s->h263_msmpeg4 = 1;
1259 s->unrestricted_mv = 1;
1260 s->msmpeg4_version= 1;
1264 case CODEC_ID_MSMPEG4V2:
1265 s->out_format = FMT_H263;
1266 s->h263_msmpeg4 = 1;
1268 s->unrestricted_mv = 1;
1269 s->msmpeg4_version= 2;
1273 case CODEC_ID_MSMPEG4V3:
1274 s->out_format = FMT_H263;
1275 s->h263_msmpeg4 = 1;
1277 s->unrestricted_mv = 1;
1278 s->msmpeg4_version= 3;
1279 s->flipflop_rounding=1;
1284 s->out_format = FMT_H263;
1285 s->h263_msmpeg4 = 1;
1287 s->unrestricted_mv = 1;
1288 s->msmpeg4_version= 4;
1289 s->flipflop_rounding=1;
1294 s->out_format = FMT_H263;
1295 s->h263_msmpeg4 = 1;
1297 s->unrestricted_mv = 1;
1298 s->msmpeg4_version= 5;
1299 s->flipflop_rounding=1;
1307 avctx->has_b_frames= !s->low_delay;
1312 if (MPV_common_init(s) < 0)
1315 if(s->modified_quant)
1316 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
1317 s->progressive_frame=
1318 s->progressive_sequence= !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME));
1319 s->quant_precision=5;
1321 ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
1322 ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
1324 #ifdef CONFIG_H261_ENCODER
1325 if (s->out_format == FMT_H261)
1326 ff_h261_encode_init(s);
1328 if (s->out_format == FMT_H263)
1329 h263_encode_init(s);
1330 if(s->msmpeg4_version)
1331 ff_msmpeg4_encode_init(s);
1332 if (s->out_format == FMT_MPEG1)
1333 ff_mpeg1_encode_init(s);
1337 int j= s->dsp.idct_permutation[i];
1338 if(s->codec_id==CODEC_ID_MPEG4 && s->mpeg_quant){
1339 s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1340 s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1341 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1342 s->intra_matrix[j] =
1343 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1346 s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1347 s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1349 if(s->avctx->intra_matrix)
1350 s->intra_matrix[j] = s->avctx->intra_matrix[i];
1351 if(s->avctx->inter_matrix)
1352 s->inter_matrix[j] = s->avctx->inter_matrix[i];
1355 /* precompute matrix */
1356 /* for mjpeg, we do include qscale in the matrix */
1357 if (s->out_format != FMT_MJPEG) {
1358 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
1359 s->intra_matrix, s->intra_quant_bias, avctx->qmin, 31, 1);
1360 convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
1361 s->inter_matrix, s->inter_quant_bias, avctx->qmin, 31, 0);
1364 if(ff_rate_control_init(s) < 0)
1370 int MPV_encode_end(AVCodecContext *avctx)
1372 MpegEncContext *s = avctx->priv_data;
1374 ff_rate_control_uninit(s);
1377 if (s->out_format == FMT_MJPEG)
1380 av_freep(&avctx->extradata);
1385 #endif //CONFIG_ENCODERS
1387 void init_rl(RLTable *rl, int use_static)
1389 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1390 uint8_t index_run[MAX_RUN+1];
1391 int last, run, level, start, end, i;
1393 /* If table is static, we can quit if rl->max_level[0] is not NULL */
1394 if(use_static && rl->max_level[0])
1397 /* compute max_level[], max_run[] and index_run[] */
1398 for(last=0;last<2;last++) {
1407 memset(max_level, 0, MAX_RUN + 1);
1408 memset(max_run, 0, MAX_LEVEL + 1);
1409 memset(index_run, rl->n, MAX_RUN + 1);
1410 for(i=start;i<end;i++) {
1411 run = rl->table_run[i];
1412 level = rl->table_level[i];
1413 if (index_run[run] == rl->n)
1415 if (level > max_level[run])
1416 max_level[run] = level;
1417 if (run > max_run[level])
1418 max_run[level] = run;
1421 rl->max_level[last] = av_mallocz_static(MAX_RUN + 1);
1423 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1424 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1426 rl->max_run[last] = av_mallocz_static(MAX_LEVEL + 1);
1428 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1429 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1431 rl->index_run[last] = av_mallocz_static(MAX_RUN + 1);
1433 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1434 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1438 /* draw the edges of width 'w' of an image of size width, height */
1439 //FIXME check that this is ok for mpeg4 interlaced
1440 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
1442 uint8_t *ptr, *last_line;
1445 last_line = buf + (height - 1) * wrap;
1447 /* top and bottom */
1448 memcpy(buf - (i + 1) * wrap, buf, width);
1449 memcpy(last_line + (i + 1) * wrap, last_line, width);
1451 /* left and right */
1453 for(i=0;i<height;i++) {
1454 memset(ptr - w, ptr[0], w);
1455 memset(ptr + width, ptr[width-1], w);
1460 memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
1461 memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
1462 memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
1463 memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
1467 int ff_find_unused_picture(MpegEncContext *s, int shared){
1471 for(i=0; i<MAX_PICTURE_COUNT; i++){
1472 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
1475 for(i=0; i<MAX_PICTURE_COUNT; i++){
1476 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
1478 for(i=0; i<MAX_PICTURE_COUNT; i++){
1479 if(s->picture[i].data[0]==NULL) return i;
1487 static void update_noise_reduction(MpegEncContext *s){
1490 for(intra=0; intra<2; intra++){
1491 if(s->dct_count[intra] > (1<<16)){
1492 for(i=0; i<64; i++){
1493 s->dct_error_sum[intra][i] >>=1;
1495 s->dct_count[intra] >>= 1;
1498 for(i=0; i<64; i++){
1499 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);
1505 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1507 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1513 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1515 /* mark&release old frames */
1516 if (s->pict_type != B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1517 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
1519 /* release forgotten pictures */
1520 /* if(mpeg124/h263) */
1522 for(i=0; i<MAX_PICTURE_COUNT; i++){
1523 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1524 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1525 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
1532 /* release non reference frames */
1533 for(i=0; i<MAX_PICTURE_COUNT; i++){
1534 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1535 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1539 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1540 pic= (AVFrame*)s->current_picture_ptr; //we allready have a unused image (maybe it was set before reading the header)
1542 i= ff_find_unused_picture(s, 0);
1543 pic= (AVFrame*)&s->picture[i];
1546 pic->reference= (s->pict_type != B_TYPE || s->codec_id == CODEC_ID_H264)
1547 && !s->dropable ? 3 : 0;
1549 pic->coded_picture_number= s->coded_picture_number++;
1551 if( alloc_picture(s, (Picture*)pic, 0) < 0)
1554 s->current_picture_ptr= (Picture*)pic;
1555 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
1556 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1559 s->current_picture_ptr->pict_type= s->pict_type;
1560 // if(s->flags && CODEC_FLAG_QSCALE)
1561 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1562 s->current_picture_ptr->key_frame= s->pict_type == I_TYPE;
1564 copy_picture(&s->current_picture, s->current_picture_ptr);
1566 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1567 if (s->pict_type != B_TYPE) {
1568 s->last_picture_ptr= s->next_picture_ptr;
1570 s->next_picture_ptr= s->current_picture_ptr;
1572 /* 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,
1573 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
1574 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
1575 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1576 s->pict_type, s->dropable);*/
1578 if(s->last_picture_ptr) copy_picture(&s->last_picture, s->last_picture_ptr);
1579 if(s->next_picture_ptr) copy_picture(&s->next_picture, s->next_picture_ptr);
1581 if(s->pict_type != I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL)){
1582 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1583 assert(s->pict_type != B_TYPE); //these should have been dropped if we don't have a reference
1587 assert(s->pict_type == I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1589 if(s->picture_structure!=PICT_FRAME){
1592 if(s->picture_structure == PICT_BOTTOM_FIELD){
1593 s->current_picture.data[i] += s->current_picture.linesize[i];
1595 s->current_picture.linesize[i] *= 2;
1596 s->last_picture.linesize[i] *=2;
1597 s->next_picture.linesize[i] *=2;
1602 s->hurry_up= s->avctx->hurry_up;
1603 s->error_resilience= avctx->error_resilience;
1605 /* set dequantizer, we can't do it during init as it might change for mpeg4
1606 and we can't do it in the header decode as init isnt called for mpeg4 there yet */
1607 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1608 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1609 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1610 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1611 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1612 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1614 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1615 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1618 if(s->dct_error_sum){
1619 assert(s->avctx->noise_reduction && s->encoding);
1621 update_noise_reduction(s);
1625 if(s->avctx->xvmc_acceleration)
1626 return XVMC_field_start(s, avctx);
1631 /* generic function for encode/decode called after a frame has been coded/decoded */
1632 void MPV_frame_end(MpegEncContext *s)
1635 /* draw edge for correct motion prediction if outside */
1637 //just to make sure that all data is rendered.
1638 if(s->avctx->xvmc_acceleration){
1642 if(s->unrestricted_mv && s->current_picture.reference && !s->intra_only && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1643 draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1644 draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1645 draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1649 s->last_pict_type = s->pict_type;
1650 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1651 if(s->pict_type!=B_TYPE){
1652 s->last_non_b_pict_type= s->pict_type;
1655 /* copy back current_picture variables */
1656 for(i=0; i<MAX_PICTURE_COUNT; i++){
1657 if(s->picture[i].data[0] == s->current_picture.data[0]){
1658 s->picture[i]= s->current_picture;
1662 assert(i<MAX_PICTURE_COUNT);
1666 /* release non-reference frames */
1667 for(i=0; i<MAX_PICTURE_COUNT; i++){
1668 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1669 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1673 // clear copies, to avoid confusion
1675 memset(&s->last_picture, 0, sizeof(Picture));
1676 memset(&s->next_picture, 0, sizeof(Picture));
1677 memset(&s->current_picture, 0, sizeof(Picture));
1679 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1683 * draws an line from (ex, ey) -> (sx, sy).
1684 * @param w width of the image
1685 * @param h height of the image
1686 * @param stride stride/linesize of the image
1687 * @param color color of the arrow
1689 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1692 sx= clip(sx, 0, w-1);
1693 sy= clip(sy, 0, h-1);
1694 ex= clip(ex, 0, w-1);
1695 ey= clip(ey, 0, h-1);
1697 buf[sy*stride + sx]+= color;
1699 if(ABS(ex - sx) > ABS(ey - sy)){
1704 buf+= sx + sy*stride;
1706 f= ((ey-sy)<<16)/ex;
1707 for(x= 0; x <= ex; x++){
1710 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1711 buf[(y+1)*stride + x]+= (color* fr )>>16;
1718 buf+= sx + sy*stride;
1720 if(ey) f= ((ex-sx)<<16)/ey;
1722 for(y= 0; y <= ey; y++){
1725 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;;
1726 buf[y*stride + x+1]+= (color* fr )>>16;;
1732 * draws an arrow from (ex, ey) -> (sx, sy).
1733 * @param w width of the image
1734 * @param h height of the image
1735 * @param stride stride/linesize of the image
1736 * @param color color of the arrow
1738 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1741 sx= clip(sx, -100, w+100);
1742 sy= clip(sy, -100, h+100);
1743 ex= clip(ex, -100, w+100);
1744 ey= clip(ey, -100, h+100);
1749 if(dx*dx + dy*dy > 3*3){
1752 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1754 //FIXME subpixel accuracy
1755 rx= ROUNDED_DIV(rx*3<<4, length);
1756 ry= ROUNDED_DIV(ry*3<<4, length);
1758 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1759 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1761 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1765 * prints debuging info for the given picture.
1767 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1769 if(!pict || !pict->mb_type) return;
1771 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1774 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1775 switch (pict->pict_type) {
1776 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1777 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1778 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1779 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1780 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1781 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1783 for(y=0; y<s->mb_height; y++){
1784 for(x=0; x<s->mb_width; x++){
1785 if(s->avctx->debug&FF_DEBUG_SKIP){
1786 int count= s->mbskip_table[x + y*s->mb_stride];
1787 if(count>9) count=9;
1788 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1790 if(s->avctx->debug&FF_DEBUG_QP){
1791 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1793 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1794 int mb_type= pict->mb_type[x + y*s->mb_stride];
1795 //Type & MV direction
1797 av_log(s->avctx, AV_LOG_DEBUG, "P");
1798 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1799 av_log(s->avctx, AV_LOG_DEBUG, "A");
1800 else if(IS_INTRA4x4(mb_type))
1801 av_log(s->avctx, AV_LOG_DEBUG, "i");
1802 else if(IS_INTRA16x16(mb_type))
1803 av_log(s->avctx, AV_LOG_DEBUG, "I");
1804 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1805 av_log(s->avctx, AV_LOG_DEBUG, "d");
1806 else if(IS_DIRECT(mb_type))
1807 av_log(s->avctx, AV_LOG_DEBUG, "D");
1808 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1809 av_log(s->avctx, AV_LOG_DEBUG, "g");
1810 else if(IS_GMC(mb_type))
1811 av_log(s->avctx, AV_LOG_DEBUG, "G");
1812 else if(IS_SKIP(mb_type))
1813 av_log(s->avctx, AV_LOG_DEBUG, "S");
1814 else if(!USES_LIST(mb_type, 1))
1815 av_log(s->avctx, AV_LOG_DEBUG, ">");
1816 else if(!USES_LIST(mb_type, 0))
1817 av_log(s->avctx, AV_LOG_DEBUG, "<");
1819 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1820 av_log(s->avctx, AV_LOG_DEBUG, "X");
1825 av_log(s->avctx, AV_LOG_DEBUG, "+");
1826 else if(IS_16X8(mb_type))
1827 av_log(s->avctx, AV_LOG_DEBUG, "-");
1828 else if(IS_8X16(mb_type))
1829 av_log(s->avctx, AV_LOG_DEBUG, "|");
1830 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1831 av_log(s->avctx, AV_LOG_DEBUG, " ");
1833 av_log(s->avctx, AV_LOG_DEBUG, "?");
1836 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1837 av_log(s->avctx, AV_LOG_DEBUG, "=");
1839 av_log(s->avctx, AV_LOG_DEBUG, " ");
1841 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1843 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1847 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1848 const int shift= 1 + s->quarter_sample;
1852 int h_chroma_shift, v_chroma_shift;
1853 const int width = s->avctx->width;
1854 const int height= s->avctx->height;
1855 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1856 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1857 s->low_delay=0; //needed to see the vectors without trashing the buffers
1859 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1861 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1862 pict->data[i]= s->visualization_buffer[i];
1864 pict->type= FF_BUFFER_TYPE_COPY;
1867 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1869 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1870 const int mb_index= mb_x + mb_y*s->mb_stride;
1871 if((s->avctx->debug_mv) && pict->motion_val){
1873 for(type=0; type<3; type++){
1876 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1880 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1884 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1889 if(!USES_LIST(pict->mb_type[mb_index], direction))
1892 if(IS_8X8(pict->mb_type[mb_index])){
1895 int sx= mb_x*16 + 4 + 8*(i&1);
1896 int sy= mb_y*16 + 4 + 8*(i>>1);
1897 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1898 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1899 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1900 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1902 }else if(IS_16X8(pict->mb_type[mb_index])){
1906 int sy=mb_y*16 + 4 + 8*i;
1907 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1908 int mx=(pict->motion_val[direction][xy][0]>>shift);
1909 int my=(pict->motion_val[direction][xy][1]>>shift);
1911 if(IS_INTERLACED(pict->mb_type[mb_index]))
1914 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1916 }else if(IS_8X16(pict->mb_type[mb_index])){
1919 int sx=mb_x*16 + 4 + 8*i;
1921 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1922 int mx=(pict->motion_val[direction][xy][0]>>shift);
1923 int my=(pict->motion_val[direction][xy][1]>>shift);
1925 if(IS_INTERLACED(pict->mb_type[mb_index]))
1928 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1931 int sx= mb_x*16 + 8;
1932 int sy= mb_y*16 + 8;
1933 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1934 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1935 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1936 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1940 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1941 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1944 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= c;
1945 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= c;
1948 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1949 int mb_type= pict->mb_type[mb_index];
1952 #define COLOR(theta, r)\
1953 u= (int)(128 + r*cos(theta*3.141592/180));\
1954 v= (int)(128 + r*sin(theta*3.141592/180));
1958 if(IS_PCM(mb_type)){
1960 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1962 }else if(IS_INTRA4x4(mb_type)){
1964 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1966 }else if(IS_DIRECT(mb_type)){
1968 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1970 }else if(IS_GMC(mb_type)){
1972 }else if(IS_SKIP(mb_type)){
1974 }else if(!USES_LIST(mb_type, 1)){
1976 }else if(!USES_LIST(mb_type, 0)){
1979 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1983 u*= 0x0101010101010101ULL;
1984 v*= 0x0101010101010101ULL;
1986 *(uint64_t*)(pict->data[1] + 8*mb_x + (8*mb_y + y)*pict->linesize[1])= u;
1987 *(uint64_t*)(pict->data[2] + 8*mb_x + (8*mb_y + y)*pict->linesize[2])= v;
1991 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1992 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1993 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1995 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1997 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1999 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
2000 int dm= 1 << (mv_sample_log2-2);
2002 int sx= mb_x*16 + 8*(i&1);
2003 int sy= mb_y*16 + 8*(i>>1);
2004 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
2006 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
2007 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
2009 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
2010 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
2011 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
2015 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
2019 s->mbskip_table[mb_index]=0;
2025 #ifdef CONFIG_ENCODERS
2027 static int get_sae(uint8_t *src, int ref, int stride){
2031 for(y=0; y<16; y++){
2032 for(x=0; x<16; x++){
2033 acc+= ABS(src[x+y*stride] - ref);
2040 static int get_intra_count(MpegEncContext *s, uint8_t *src, uint8_t *ref, int stride){
2047 for(y=0; y<h; y+=16){
2048 for(x=0; x<w; x+=16){
2049 int offset= x + y*stride;
2050 int sad = s->dsp.sad[0](NULL, src + offset, ref + offset, stride, 16);
2051 int mean= (s->dsp.pix_sum(src + offset, stride) + 128)>>8;
2052 int sae = get_sae(src + offset, mean, stride);
2054 acc+= sae + 500 < sad;
2061 static int load_input_picture(MpegEncContext *s, AVFrame *pic_arg){
2065 const int encoding_delay= s->max_b_frames;
2070 pic_arg->display_picture_number= s->input_picture_number++;
2072 if(pts != AV_NOPTS_VALUE){
2073 if(s->user_specified_pts != AV_NOPTS_VALUE){
2075 int64_t last= s->user_specified_pts;
2078 av_log(s->avctx, AV_LOG_ERROR, "Error, Invalid timestamp=%"PRId64", last=%"PRId64"\n", pts, s->user_specified_pts);
2082 s->user_specified_pts= pts;
2084 if(s->user_specified_pts != AV_NOPTS_VALUE){
2085 s->user_specified_pts=
2086 pts= s->user_specified_pts + 1;
2087 av_log(s->avctx, AV_LOG_INFO, "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n", pts);
2089 pts= pic_arg->display_picture_number;
2095 if(encoding_delay && !(s->flags&CODEC_FLAG_INPUT_PRESERVED)) direct=0;
2096 if(pic_arg->linesize[0] != s->linesize) direct=0;
2097 if(pic_arg->linesize[1] != s->uvlinesize) direct=0;
2098 if(pic_arg->linesize[2] != s->uvlinesize) direct=0;
2100 // av_log(AV_LOG_DEBUG, "%d %d %d %d\n",pic_arg->linesize[0], pic_arg->linesize[1], s->linesize, s->uvlinesize);
2103 i= ff_find_unused_picture(s, 1);
2105 pic= (AVFrame*)&s->picture[i];
2109 pic->data[i]= pic_arg->data[i];
2110 pic->linesize[i]= pic_arg->linesize[i];
2112 alloc_picture(s, (Picture*)pic, 1);
2114 i= ff_find_unused_picture(s, 0);
2116 pic= (AVFrame*)&s->picture[i];
2119 alloc_picture(s, (Picture*)pic, 0);
2121 if( pic->data[0] + INPLACE_OFFSET == pic_arg->data[0]
2122 && pic->data[1] + INPLACE_OFFSET == pic_arg->data[1]
2123 && pic->data[2] + INPLACE_OFFSET == pic_arg->data[2]){
2126 int h_chroma_shift, v_chroma_shift;
2127 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2130 int src_stride= pic_arg->linesize[i];
2131 int dst_stride= i ? s->uvlinesize : s->linesize;
2132 int h_shift= i ? h_chroma_shift : 0;
2133 int v_shift= i ? v_chroma_shift : 0;
2134 int w= s->width >>h_shift;
2135 int h= s->height>>v_shift;
2136 uint8_t *src= pic_arg->data[i];
2137 uint8_t *dst= pic->data[i] + INPLACE_OFFSET;
2139 if(src_stride==dst_stride)
2140 memcpy(dst, src, src_stride*h);
2143 memcpy(dst, src, w);
2151 copy_picture_attributes(s, pic, pic_arg);
2152 pic->pts= pts; //we set this here to avoid modifiying pic_arg
2155 /* shift buffer entries */
2156 for(i=1; i<MAX_PICTURE_COUNT /*s->encoding_delay+1*/; i++)
2157 s->input_picture[i-1]= s->input_picture[i];
2159 s->input_picture[encoding_delay]= (Picture*)pic;
2164 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref){
2169 for(plane=0; plane<3; plane++){
2170 const int stride= p->linesize[plane];
2171 const int bw= plane ? 1 : 2;
2172 for(y=0; y<s->mb_height*bw; y++){
2173 for(x=0; x<s->mb_width*bw; x++){
2174 int off= p->type == FF_BUFFER_TYPE_SHARED ? 0: 16;
2175 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);
2177 switch(s->avctx->frame_skip_exp){
2178 case 0: score= FFMAX(score, v); break;
2179 case 1: score+= ABS(v);break;
2180 case 2: score+= v*v;break;
2181 case 3: score64+= ABS(v*v*(int64_t)v);break;
2182 case 4: score64+= v*v*(int64_t)(v*v);break;
2188 if(score) score64= score;
2190 if(score64 < s->avctx->frame_skip_threshold)
2192 if(score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda)>>8))
2197 static int estimate_best_b_count(MpegEncContext *s){
2198 AVCodec *codec= avcodec_find_encoder(s->avctx->codec_id);
2199 AVCodecContext *c= avcodec_alloc_context();
2200 AVFrame input[FF_MAX_B_FRAMES+2];
2201 const int scale= s->avctx->brd_scale;
2202 int i, j, out_size, p_lambda, b_lambda, lambda2;
2203 int outbuf_size= s->width * s->height; //FIXME
2204 uint8_t *outbuf= av_malloc(outbuf_size);
2205 int64_t best_rd= INT64_MAX;
2206 int best_b_count= -1;
2208 assert(scale>=0 && scale <=3);
2211 p_lambda= s->last_lambda_for[P_TYPE]; //s->next_picture_ptr->quality;
2212 b_lambda= s->last_lambda_for[B_TYPE]; //p_lambda *ABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
2213 if(!b_lambda) b_lambda= p_lambda; //FIXME we should do this somewhere else
2214 lambda2= (b_lambda*b_lambda + (1<<FF_LAMBDA_SHIFT)/2 ) >> FF_LAMBDA_SHIFT;
2216 c->width = s->width >> scale;
2217 c->height= s->height>> scale;
2218 c->flags= CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR | CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
2219 c->flags|= s->avctx->flags & CODEC_FLAG_QPEL;
2220 c->mb_decision= s->avctx->mb_decision;
2221 c->me_cmp= s->avctx->me_cmp;
2222 c->mb_cmp= s->avctx->mb_cmp;
2223 c->me_sub_cmp= s->avctx->me_sub_cmp;
2224 c->pix_fmt = PIX_FMT_YUV420P;
2225 c->time_base= s->avctx->time_base;
2226 c->max_b_frames= s->max_b_frames;
2228 if (avcodec_open(c, codec) < 0)
2231 for(i=0; i<s->max_b_frames+2; i++){
2232 int ysize= c->width*c->height;
2233 int csize= (c->width/2)*(c->height/2);
2234 Picture pre_input, *pre_input_ptr= i ? s->input_picture[i-1] : s->next_picture_ptr;
2237 pre_input= *pre_input_ptr;
2239 if(pre_input.type != FF_BUFFER_TYPE_SHARED && i){
2240 pre_input.data[0]+=INPLACE_OFFSET;
2241 pre_input.data[1]+=INPLACE_OFFSET;
2242 pre_input.data[2]+=INPLACE_OFFSET;
2245 avcodec_get_frame_defaults(&input[i]);
2246 input[i].data[0]= av_malloc(ysize + 2*csize);
2247 input[i].data[1]= input[i].data[0] + ysize;
2248 input[i].data[2]= input[i].data[1] + csize;
2249 input[i].linesize[0]= c->width;
2250 input[i].linesize[1]=
2251 input[i].linesize[2]= c->width/2;
2253 if(!i || s->input_picture[i-1]){
2254 s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0], pre_input.data[0], pre_input.linesize[0], c->width, c->height);
2255 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);
2256 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);
2260 for(j=0; j<s->max_b_frames+1; j++){
2263 if(!s->input_picture[j])
2266 c->error[0]= c->error[1]= c->error[2]= 0;
2268 input[0].pict_type= I_TYPE;
2269 input[0].quality= 1 * FF_QP2LAMBDA;
2270 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[0]);
2271 // rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
2273 for(i=0; i<s->max_b_frames+1; i++){
2274 int is_p= i % (j+1) == j || i==s->max_b_frames;
2276 input[i+1].pict_type= is_p ? P_TYPE : B_TYPE;
2277 input[i+1].quality= is_p ? p_lambda : b_lambda;
2278 out_size = avcodec_encode_video(c, outbuf, outbuf_size, &input[i+1]);
2279 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2282 /* get the delayed frames */
2284 out_size = avcodec_encode_video(c, outbuf, outbuf_size, NULL);
2285 rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
2288 rd += c->error[0] + c->error[1] + c->error[2];
2300 for(i=0; i<s->max_b_frames+2; i++){
2301 av_freep(&input[i].data[0]);
2304 return best_b_count;
2307 static void select_input_picture(MpegEncContext *s){
2310 for(i=1; i<MAX_PICTURE_COUNT; i++)
2311 s->reordered_input_picture[i-1]= s->reordered_input_picture[i];
2312 s->reordered_input_picture[MAX_PICTURE_COUNT-1]= NULL;
2314 /* set next picture type & ordering */
2315 if(s->reordered_input_picture[0]==NULL && s->input_picture[0]){
2316 if(/*s->picture_in_gop_number >= s->gop_size ||*/ s->next_picture_ptr==NULL || s->intra_only){
2317 s->reordered_input_picture[0]= s->input_picture[0];
2318 s->reordered_input_picture[0]->pict_type= I_TYPE;
2319 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2323 if(s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor){
2324 if(s->picture_in_gop_number < s->gop_size && skip_check(s, s->input_picture[0], s->next_picture_ptr)){
2325 //FIXME check that te gop check above is +-1 correct
2326 //av_log(NULL, AV_LOG_DEBUG, "skip %p %Ld\n", s->input_picture[0]->data[0], s->input_picture[0]->pts);
2328 if(s->input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2330 s->input_picture[0]->data[i]= NULL;
2331 s->input_picture[0]->type= 0;
2333 assert( s->input_picture[0]->type==FF_BUFFER_TYPE_USER
2334 || s->input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2336 s->avctx->release_buffer(s->avctx, (AVFrame*)s->input_picture[0]);
2340 ff_vbv_update(s, 0);
2346 if(s->flags&CODEC_FLAG_PASS2){
2347 for(i=0; i<s->max_b_frames+1; i++){
2348 int pict_num= s->input_picture[0]->display_picture_number + i;
2350 if(pict_num >= s->rc_context.num_entries)
2352 if(!s->input_picture[i]){
2353 s->rc_context.entry[pict_num-1].new_pict_type = P_TYPE;
2357 s->input_picture[i]->pict_type=
2358 s->rc_context.entry[pict_num].new_pict_type;
2362 if(s->avctx->b_frame_strategy==0){
2363 b_frames= s->max_b_frames;
2364 while(b_frames && !s->input_picture[b_frames]) b_frames--;
2365 }else if(s->avctx->b_frame_strategy==1){
2366 for(i=1; i<s->max_b_frames+1; i++){
2367 if(s->input_picture[i] && s->input_picture[i]->b_frame_score==0){
2368 s->input_picture[i]->b_frame_score=
2369 get_intra_count(s, s->input_picture[i ]->data[0],
2370 s->input_picture[i-1]->data[0], s->linesize) + 1;
2373 for(i=0; i<s->max_b_frames+1; i++){
2374 if(s->input_picture[i]==NULL || s->input_picture[i]->b_frame_score - 1 > s->mb_num/s->avctx->b_sensitivity) break;
2377 b_frames= FFMAX(0, i-1);
2380 for(i=0; i<b_frames+1; i++){
2381 s->input_picture[i]->b_frame_score=0;
2383 }else if(s->avctx->b_frame_strategy==2){
2384 b_frames= estimate_best_b_count(s);
2386 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
2391 //static int b_count=0;
2392 //b_count+= b_frames;
2393 //av_log(s->avctx, AV_LOG_DEBUG, "b_frames: %d\n", b_count);
2395 for(i= b_frames - 1; i>=0; i--){
2396 int type= s->input_picture[i]->pict_type;
2397 if(type && type != B_TYPE)
2400 if(s->input_picture[b_frames]->pict_type == B_TYPE && b_frames == s->max_b_frames){
2401 av_log(s->avctx, AV_LOG_ERROR, "warning, too many b frames in a row\n");
2404 if(s->picture_in_gop_number + b_frames >= s->gop_size){
2405 if((s->flags2 & CODEC_FLAG2_STRICT_GOP) && s->gop_size > s->picture_in_gop_number){
2406 b_frames= s->gop_size - s->picture_in_gop_number - 1;
2408 if(s->flags & CODEC_FLAG_CLOSED_GOP)
2410 s->input_picture[b_frames]->pict_type= I_TYPE;
2414 if( (s->flags & CODEC_FLAG_CLOSED_GOP)
2416 && s->input_picture[b_frames]->pict_type== I_TYPE)
2419 s->reordered_input_picture[0]= s->input_picture[b_frames];
2420 if(s->reordered_input_picture[0]->pict_type != I_TYPE)
2421 s->reordered_input_picture[0]->pict_type= P_TYPE;
2422 s->reordered_input_picture[0]->coded_picture_number= s->coded_picture_number++;
2423 for(i=0; i<b_frames; i++){
2424 s->reordered_input_picture[i+1]= s->input_picture[i];
2425 s->reordered_input_picture[i+1]->pict_type= B_TYPE;
2426 s->reordered_input_picture[i+1]->coded_picture_number= s->coded_picture_number++;
2431 if(s->reordered_input_picture[0]){
2432 s->reordered_input_picture[0]->reference= s->reordered_input_picture[0]->pict_type!=B_TYPE ? 3 : 0;
2434 copy_picture(&s->new_picture, s->reordered_input_picture[0]);
2436 if(s->reordered_input_picture[0]->type == FF_BUFFER_TYPE_SHARED){
2437 // input is a shared pix, so we can't modifiy it -> alloc a new one & ensure that the shared one is reuseable
2439 int i= ff_find_unused_picture(s, 0);
2440 Picture *pic= &s->picture[i];
2442 /* mark us unused / free shared pic */
2444 s->reordered_input_picture[0]->data[i]= NULL;
2445 s->reordered_input_picture[0]->type= 0;
2447 pic->reference = s->reordered_input_picture[0]->reference;
2449 alloc_picture(s, pic, 0);
2451 copy_picture_attributes(s, (AVFrame*)pic, (AVFrame*)s->reordered_input_picture[0]);
2453 s->current_picture_ptr= pic;
2455 // input is not a shared pix -> reuse buffer for current_pix
2457 assert( s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_USER
2458 || s->reordered_input_picture[0]->type==FF_BUFFER_TYPE_INTERNAL);
2460 s->current_picture_ptr= s->reordered_input_picture[0];
2462 s->new_picture.data[i]+= INPLACE_OFFSET;
2465 copy_picture(&s->current_picture, s->current_picture_ptr);
2467 s->picture_number= s->new_picture.display_picture_number;
2468 //printf("dpn:%d\n", s->picture_number);
2470 memset(&s->new_picture, 0, sizeof(Picture));
2474 int MPV_encode_picture(AVCodecContext *avctx,
2475 unsigned char *buf, int buf_size, void *data)
2477 MpegEncContext *s = avctx->priv_data;
2478 AVFrame *pic_arg = data;
2479 int i, stuffing_count;
2481 for(i=0; i<avctx->thread_count; i++){
2482 int start_y= s->thread_context[i]->start_mb_y;
2483 int end_y= s->thread_context[i]-> end_mb_y;
2484 int h= s->mb_height;
2485 uint8_t *start= buf + (size_t)(((int64_t) buf_size)*start_y/h);
2486 uint8_t *end = buf + (size_t)(((int64_t) buf_size)* end_y/h);
2488 init_put_bits(&s->thread_context[i]->pb, start, end - start);
2491 s->picture_in_gop_number++;
2493 if(load_input_picture(s, pic_arg) < 0)
2496 select_input_picture(s);
2499 if(s->new_picture.data[0]){
2500 s->pict_type= s->new_picture.pict_type;
2502 //printf("qs:%f %f %d\n", s->new_picture.quality, s->current_picture.quality, s->qscale);
2503 MPV_frame_start(s, avctx);
2505 encode_picture(s, s->picture_number);
2507 avctx->real_pict_num = s->picture_number;
2508 avctx->header_bits = s->header_bits;
2509 avctx->mv_bits = s->mv_bits;
2510 avctx->misc_bits = s->misc_bits;
2511 avctx->i_tex_bits = s->i_tex_bits;
2512 avctx->p_tex_bits = s->p_tex_bits;
2513 avctx->i_count = s->i_count;
2514 avctx->p_count = s->mb_num - s->i_count - s->skip_count; //FIXME f/b_count in avctx
2515 avctx->skip_count = s->skip_count;
2519 if (s->out_format == FMT_MJPEG)
2520 mjpeg_picture_trailer(s);
2522 if(s->flags&CODEC_FLAG_PASS1)
2523 ff_write_pass1_stats(s);
2526 s->current_picture_ptr->error[i]= s->current_picture.error[i];
2527 avctx->error[i] += s->current_picture_ptr->error[i];
2530 if(s->flags&CODEC_FLAG_PASS1)
2531 assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits + avctx->i_tex_bits + avctx->p_tex_bits == put_bits_count(&s->pb));
2532 flush_put_bits(&s->pb);
2533 s->frame_bits = put_bits_count(&s->pb);
2535 stuffing_count= ff_vbv_update(s, s->frame_bits);
2537 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < stuffing_count + 50){
2538 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
2542 switch(s->codec_id){
2543 case CODEC_ID_MPEG1VIDEO:
2544 case CODEC_ID_MPEG2VIDEO:
2545 while(stuffing_count--){
2546 put_bits(&s->pb, 8, 0);
2549 case CODEC_ID_MPEG4:
2550 put_bits(&s->pb, 16, 0);
2551 put_bits(&s->pb, 16, 0x1C3);
2552 stuffing_count -= 4;
2553 while(stuffing_count--){
2554 put_bits(&s->pb, 8, 0xFF);
2558 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2560 flush_put_bits(&s->pb);
2561 s->frame_bits = put_bits_count(&s->pb);
2564 /* update mpeg1/2 vbv_delay for CBR */
2565 if(s->avctx->rc_max_rate && s->avctx->rc_min_rate == s->avctx->rc_max_rate && s->out_format == FMT_MPEG1
2566 && 90000LL * (avctx->rc_buffer_size-1) <= s->avctx->rc_max_rate*0xFFFFLL){
2569 assert(s->repeat_first_field==0);
2571 vbv_delay= lrintf(90000 * s->rc_context.buffer_index / s->avctx->rc_max_rate);
2572 assert(vbv_delay < 0xFFFF);
2574 s->vbv_delay_ptr[0] &= 0xF8;
2575 s->vbv_delay_ptr[0] |= vbv_delay>>13;
2576 s->vbv_delay_ptr[1] = vbv_delay>>5;
2577 s->vbv_delay_ptr[2] &= 0x07;
2578 s->vbv_delay_ptr[2] |= vbv_delay<<3;
2580 s->total_bits += s->frame_bits;
2581 avctx->frame_bits = s->frame_bits;
2583 assert((pbBufPtr(&s->pb) == s->pb.buf));
2586 assert((s->frame_bits&7)==0);
2588 return s->frame_bits/8;
2591 #endif //CONFIG_ENCODERS
2593 static inline void gmc1_motion(MpegEncContext *s,
2594 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2595 uint8_t **ref_picture)
2598 int offset, src_x, src_y, linesize, uvlinesize;
2599 int motion_x, motion_y;
2602 motion_x= s->sprite_offset[0][0];
2603 motion_y= s->sprite_offset[0][1];
2604 src_x = s->mb_x * 16 + (motion_x >> (s->sprite_warping_accuracy+1));
2605 src_y = s->mb_y * 16 + (motion_y >> (s->sprite_warping_accuracy+1));
2606 motion_x<<=(3-s->sprite_warping_accuracy);
2607 motion_y<<=(3-s->sprite_warping_accuracy);
2608 src_x = clip(src_x, -16, s->width);
2609 if (src_x == s->width)
2611 src_y = clip(src_y, -16, s->height);
2612 if (src_y == s->height)
2615 linesize = s->linesize;
2616 uvlinesize = s->uvlinesize;
2618 ptr = ref_picture[0] + (src_y * linesize) + src_x;
2620 if(s->flags&CODEC_FLAG_EMU_EDGE){
2621 if( (unsigned)src_x >= s->h_edge_pos - 17
2622 || (unsigned)src_y >= s->v_edge_pos - 17){
2623 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, linesize, 17, 17, src_x, src_y, s->h_edge_pos, s->v_edge_pos);
2624 ptr= s->edge_emu_buffer;
2628 if((motion_x|motion_y)&7){
2629 s->dsp.gmc1(dest_y , ptr , linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2630 s->dsp.gmc1(dest_y+8, ptr+8, linesize, 16, motion_x&15, motion_y&15, 128 - s->no_rounding);
2634 dxy= ((motion_x>>3)&1) | ((motion_y>>2)&2);
2635 if (s->no_rounding){
2636 s->dsp.put_no_rnd_pixels_tab[0][dxy](dest_y, ptr, linesize, 16);
2638 s->dsp.put_pixels_tab [0][dxy](dest_y, ptr, linesize, 16);
2642 if(s->flags&CODEC_FLAG_GRAY) return;
2644 motion_x= s->sprite_offset[1][0];
2645 motion_y= s->sprite_offset[1][1];
2646 src_x = s->mb_x * 8 + (motion_x >> (s->sprite_warping_accuracy+1));
2647 src_y = s->mb_y * 8 + (motion_y >> (s->sprite_warping_accuracy+1));
2648 motion_x<<=(3-s->sprite_warping_accuracy);
2649 motion_y<<=(3-s->sprite_warping_accuracy);
2650 src_x = clip(src_x, -8, s->width>>1);
2651 if (src_x == s->width>>1)
2653 src_y = clip(src_y, -8, s->height>>1);
2654 if (src_y == s->height>>1)
2657 offset = (src_y * uvlinesize) + src_x;
2658 ptr = ref_picture[1] + offset;
2659 if(s->flags&CODEC_FLAG_EMU_EDGE){
2660 if( (unsigned)src_x >= (s->h_edge_pos>>1) - 9
2661 || (unsigned)src_y >= (s->v_edge_pos>>1) - 9){
2662 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);
2663 ptr= s->edge_emu_buffer;
2667 s->dsp.gmc1(dest_cb, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2669 ptr = ref_picture[2] + offset;
2671 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);
2672 ptr= s->edge_emu_buffer;
2674 s->dsp.gmc1(dest_cr, ptr, uvlinesize, 8, motion_x&15, motion_y&15, 128 - s->no_rounding);
2679 static inline void gmc_motion(MpegEncContext *s,
2680 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2681 uint8_t **ref_picture)
2684 int linesize, uvlinesize;
2685 const int a= s->sprite_warping_accuracy;
2688 linesize = s->linesize;
2689 uvlinesize = s->uvlinesize;
2691 ptr = ref_picture[0];
2693 ox= s->sprite_offset[0][0] + s->sprite_delta[0][0]*s->mb_x*16 + s->sprite_delta[0][1]*s->mb_y*16;
2694 oy= s->sprite_offset[0][1] + s->sprite_delta[1][0]*s->mb_x*16 + s->sprite_delta[1][1]*s->mb_y*16;
2696 s->dsp.gmc(dest_y, ptr, linesize, 16,
2699 s->sprite_delta[0][0], s->sprite_delta[0][1],
2700 s->sprite_delta[1][0], s->sprite_delta[1][1],
2701 a+1, (1<<(2*a+1)) - s->no_rounding,
2702 s->h_edge_pos, s->v_edge_pos);
2703 s->dsp.gmc(dest_y+8, ptr, linesize, 16,
2704 ox + s->sprite_delta[0][0]*8,
2705 oy + s->sprite_delta[1][0]*8,
2706 s->sprite_delta[0][0], s->sprite_delta[0][1],
2707 s->sprite_delta[1][0], s->sprite_delta[1][1],
2708 a+1, (1<<(2*a+1)) - s->no_rounding,
2709 s->h_edge_pos, s->v_edge_pos);
2711 if(s->flags&CODEC_FLAG_GRAY) return;
2713 ox= s->sprite_offset[1][0] + s->sprite_delta[0][0]*s->mb_x*8 + s->sprite_delta[0][1]*s->mb_y*8;
2714 oy= s->sprite_offset[1][1] + s->sprite_delta[1][0]*s->mb_x*8 + s->sprite_delta[1][1]*s->mb_y*8;
2716 ptr = ref_picture[1];
2717 s->dsp.gmc(dest_cb, ptr, uvlinesize, 8,
2720 s->sprite_delta[0][0], s->sprite_delta[0][1],
2721 s->sprite_delta[1][0], s->sprite_delta[1][1],
2722 a+1, (1<<(2*a+1)) - s->no_rounding,
2723 s->h_edge_pos>>1, s->v_edge_pos>>1);
2725 ptr = ref_picture[2];
2726 s->dsp.gmc(dest_cr, ptr, uvlinesize, 8,
2729 s->sprite_delta[0][0], s->sprite_delta[0][1],
2730 s->sprite_delta[1][0], s->sprite_delta[1][1],
2731 a+1, (1<<(2*a+1)) - s->no_rounding,
2732 s->h_edge_pos>>1, s->v_edge_pos>>1);
2736 * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
2737 * @param buf destination buffer
2738 * @param src source buffer
2739 * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
2740 * @param block_w width of block
2741 * @param block_h height of block
2742 * @param src_x x coordinate of the top left sample of the block in the source buffer
2743 * @param src_y y coordinate of the top left sample of the block in the source buffer
2744 * @param w width of the source buffer
2745 * @param h height of the source buffer
2747 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
2748 int src_x, int src_y, int w, int h){
2750 int start_y, start_x, end_y, end_x;
2753 src+= (h-1-src_y)*linesize;
2755 }else if(src_y<=-block_h){
2756 src+= (1-block_h-src_y)*linesize;
2762 }else if(src_x<=-block_w){
2763 src+= (1-block_w-src_x);
2767 start_y= FFMAX(0, -src_y);
2768 start_x= FFMAX(0, -src_x);
2769 end_y= FFMIN(block_h, h-src_y);
2770 end_x= FFMIN(block_w, w-src_x);
2772 // copy existing part
2773 for(y=start_y; y<end_y; y++){
2774 for(x=start_x; x<end_x; x++){
2775 buf[x + y*linesize]= src[x + y*linesize];
2780 for(y=0; y<start_y; y++){
2781 for(x=start_x; x<end_x; x++){
2782 buf[x + y*linesize]= buf[x + start_y*linesize];
2787 for(y=end_y; y<block_h; y++){
2788 for(x=start_x; x<end_x; x++){
2789 buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
2793 for(y=0; y<block_h; y++){
2795 for(x=0; x<start_x; x++){
2796 buf[x + y*linesize]= buf[start_x + y*linesize];
2800 for(x=end_x; x<block_w; x++){
2801 buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
2806 static inline int hpel_motion(MpegEncContext *s,
2807 uint8_t *dest, uint8_t *src,
2808 int field_based, int field_select,
2809 int src_x, int src_y,
2810 int width, int height, int stride,
2811 int h_edge_pos, int v_edge_pos,
2812 int w, int h, op_pixels_func *pix_op,
2813 int motion_x, int motion_y)
2818 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2819 src_x += motion_x >> 1;
2820 src_y += motion_y >> 1;
2822 /* WARNING: do no forget half pels */
2823 src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
2826 src_y = clip(src_y, -16, height);
2827 if (src_y == height)
2829 src += src_y * stride + src_x;
2831 if(s->unrestricted_mv && (s->flags&CODEC_FLAG_EMU_EDGE)){
2832 if( (unsigned)src_x > h_edge_pos - (motion_x&1) - w
2833 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2834 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2835 src_x, src_y<<field_based, h_edge_pos, s->v_edge_pos);
2836 src= s->edge_emu_buffer;
2842 pix_op[dxy](dest, src, stride, h);
2846 static inline int hpel_motion_lowres(MpegEncContext *s,
2847 uint8_t *dest, uint8_t *src,
2848 int field_based, int field_select,
2849 int src_x, int src_y,
2850 int width, int height, int stride,
2851 int h_edge_pos, int v_edge_pos,
2852 int w, int h, h264_chroma_mc_func *pix_op,
2853 int motion_x, int motion_y)
2855 const int lowres= s->avctx->lowres;
2856 const int s_mask= (2<<lowres)-1;
2860 if(s->quarter_sample){
2865 sx= motion_x & s_mask;
2866 sy= motion_y & s_mask;
2867 src_x += motion_x >> (lowres+1);
2868 src_y += motion_y >> (lowres+1);
2870 src += src_y * stride + src_x;
2872 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
2873 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
2874 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
2875 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
2876 src= s->edge_emu_buffer;
2884 pix_op[lowres](dest, src, stride, h, sx, sy);
2888 /* apply one mpeg motion vector to the three components */
2889 static always_inline void mpeg_motion(MpegEncContext *s,
2890 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2891 int field_based, int bottom_field, int field_select,
2892 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
2893 int motion_x, int motion_y, int h)
2895 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2896 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, uvlinesize, linesize;
2899 if(s->quarter_sample)
2906 v_edge_pos = s->v_edge_pos >> field_based;
2907 linesize = s->current_picture.linesize[0] << field_based;
2908 uvlinesize = s->current_picture.linesize[1] << field_based;
2910 dxy = ((motion_y & 1) << 1) | (motion_x & 1);
2911 src_x = s->mb_x* 16 + (motion_x >> 1);
2912 src_y =(s->mb_y<<(4-field_based)) + (motion_y >> 1);
2914 if (s->out_format == FMT_H263) {
2915 if((s->workaround_bugs & FF_BUG_HPEL_CHROMA) && field_based){
2916 mx = (motion_x>>1)|(motion_x&1);
2918 uvdxy = ((my & 1) << 1) | (mx & 1);
2919 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2920 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2922 uvdxy = dxy | (motion_y & 2) | ((motion_x & 2) >> 1);
2926 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
2930 uvsrc_x = s->mb_x*8 + mx;
2931 uvsrc_y = s->mb_y*8 + my;
2933 if(s->chroma_y_shift){
2936 uvdxy = ((my & 1) << 1) | (mx & 1);
2937 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2938 uvsrc_y = (s->mb_y<<(3-field_based)) + (my >> 1);
2940 if(s->chroma_x_shift){
2943 uvdxy = ((motion_y & 1) << 1) | (mx & 1);
2944 uvsrc_x = s->mb_x* 8 + (mx >> 1);
2955 ptr_y = ref_picture[0] + src_y * linesize + src_x;
2956 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2957 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2959 if( (unsigned)src_x > s->h_edge_pos - (motion_x&1) - 16
2960 || (unsigned)src_y > v_edge_pos - (motion_y&1) - h){
2961 if(s->codec_id == CODEC_ID_MPEG2VIDEO ||
2962 s->codec_id == CODEC_ID_MPEG1VIDEO){
2963 av_log(s->avctx,AV_LOG_DEBUG,"MPEG motion vector out of boundary\n");
2966 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
2967 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
2968 ptr_y = s->edge_emu_buffer;
2969 if(!(s->flags&CODEC_FLAG_GRAY)){
2970 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
2971 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
2972 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2973 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
2974 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
2980 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
2981 dest_y += s->linesize;
2982 dest_cb+= s->uvlinesize;
2983 dest_cr+= s->uvlinesize;
2987 ptr_y += s->linesize;
2988 ptr_cb+= s->uvlinesize;
2989 ptr_cr+= s->uvlinesize;
2992 pix_op[0][dxy](dest_y, ptr_y, linesize, h);
2994 if(!(s->flags&CODEC_FLAG_GRAY)){
2995 pix_op[s->chroma_x_shift][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift);
2996 pix_op[s->chroma_x_shift][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift);
2998 #if defined(CONFIG_H261_ENCODER) || defined(CONFIG_H261_DECODER)
2999 if(s->out_format == FMT_H261){
3000 ff_h261_loop_filter(s);
3005 /* apply one mpeg motion vector to the three components */
3006 static always_inline void mpeg_motion_lowres(MpegEncContext *s,
3007 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3008 int field_based, int bottom_field, int field_select,
3009 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
3010 int motion_x, int motion_y, int h)
3012 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3013 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
3014 const int lowres= s->avctx->lowres;
3015 const int block_s= 8>>lowres;
3016 const int s_mask= (2<<lowres)-1;
3017 const int h_edge_pos = s->h_edge_pos >> lowres;
3018 const int v_edge_pos = s->v_edge_pos >> lowres;
3019 linesize = s->current_picture.linesize[0] << field_based;
3020 uvlinesize = s->current_picture.linesize[1] << field_based;
3022 if(s->quarter_sample){ //FIXME obviously not perfect but qpel wont work in lowres anyway
3028 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
3031 sx= motion_x & s_mask;
3032 sy= motion_y & s_mask;
3033 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
3034 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
3036 if (s->out_format == FMT_H263) {
3037 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
3038 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
3041 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
3044 uvsx = (2*mx) & s_mask;
3045 uvsy = (2*my) & s_mask;
3046 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
3047 uvsrc_y = s->mb_y*block_s + (my >> lowres);
3053 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
3054 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
3057 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3058 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3059 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3061 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
3062 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
3063 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3064 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
3065 ptr_y = s->edge_emu_buffer;
3066 if(!(s->flags&CODEC_FLAG_GRAY)){
3067 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
3068 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
3069 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3070 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
3071 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
3077 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
3078 dest_y += s->linesize;
3079 dest_cb+= s->uvlinesize;
3080 dest_cr+= s->uvlinesize;
3084 ptr_y += s->linesize;
3085 ptr_cb+= s->uvlinesize;
3086 ptr_cr+= s->uvlinesize;
3091 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
3093 if(!(s->flags&CODEC_FLAG_GRAY)){
3094 uvsx <<= 2 - lowres;
3095 uvsy <<= 2 - lowres;
3096 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3097 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
3099 //FIXME h261 lowres loop filter
3102 //FIXME move to dsputil, avg variant, 16x16 version
3103 static inline void put_obmc(uint8_t *dst, uint8_t *src[5], int stride){
3105 uint8_t * const top = src[1];
3106 uint8_t * const left = src[2];
3107 uint8_t * const mid = src[0];
3108 uint8_t * const right = src[3];
3109 uint8_t * const bottom= src[4];
3110 #define OBMC_FILTER(x, t, l, m, r, b)\
3111 dst[x]= (t*top[x] + l*left[x] + m*mid[x] + r*right[x] + b*bottom[x] + 4)>>3
3112 #define OBMC_FILTER4(x, t, l, m, r, b)\
3113 OBMC_FILTER(x , t, l, m, r, b);\
3114 OBMC_FILTER(x+1 , t, l, m, r, b);\
3115 OBMC_FILTER(x +stride, t, l, m, r, b);\
3116 OBMC_FILTER(x+1+stride, t, l, m, r, b);
3119 OBMC_FILTER (x , 2, 2, 4, 0, 0);
3120 OBMC_FILTER (x+1, 2, 1, 5, 0, 0);
3121 OBMC_FILTER4(x+2, 2, 1, 5, 0, 0);
3122 OBMC_FILTER4(x+4, 2, 0, 5, 1, 0);
3123 OBMC_FILTER (x+6, 2, 0, 5, 1, 0);
3124 OBMC_FILTER (x+7, 2, 0, 4, 2, 0);
3126 OBMC_FILTER (x , 1, 2, 5, 0, 0);
3127 OBMC_FILTER (x+1, 1, 2, 5, 0, 0);
3128 OBMC_FILTER (x+6, 1, 0, 5, 2, 0);
3129 OBMC_FILTER (x+7, 1, 0, 5, 2, 0);
3131 OBMC_FILTER4(x , 1, 2, 5, 0, 0);
3132 OBMC_FILTER4(x+2, 1, 1, 6, 0, 0);
3133 OBMC_FILTER4(x+4, 1, 0, 6, 1, 0);
3134 OBMC_FILTER4(x+6, 1, 0, 5, 2, 0);
3136 OBMC_FILTER4(x , 0, 2, 5, 0, 1);
3137 OBMC_FILTER4(x+2, 0, 1, 6, 0, 1);
3138 OBMC_FILTER4(x+4, 0, 0, 6, 1, 1);
3139 OBMC_FILTER4(x+6, 0, 0, 5, 2, 1);
3141 OBMC_FILTER (x , 0, 2, 5, 0, 1);
3142 OBMC_FILTER (x+1, 0, 2, 5, 0, 1);
3143 OBMC_FILTER4(x+2, 0, 1, 5, 0, 2);
3144 OBMC_FILTER4(x+4, 0, 0, 5, 1, 2);
3145 OBMC_FILTER (x+6, 0, 0, 5, 2, 1);
3146 OBMC_FILTER (x+7, 0, 0, 5, 2, 1);
3148 OBMC_FILTER (x , 0, 2, 4, 0, 2);
3149 OBMC_FILTER (x+1, 0, 1, 5, 0, 2);
3150 OBMC_FILTER (x+6, 0, 0, 5, 1, 2);
3151 OBMC_FILTER (x+7, 0, 0, 4, 2, 2);
3154 /* obmc for 1 8x8 luma block */
3155 static inline void obmc_motion(MpegEncContext *s,
3156 uint8_t *dest, uint8_t *src,
3157 int src_x, int src_y,
3158 op_pixels_func *pix_op,
3159 int16_t mv[5][2]/* mid top left right bottom*/)
3165 assert(s->quarter_sample==0);
3168 if(i && mv[i][0]==mv[MID][0] && mv[i][1]==mv[MID][1]){
3171 ptr[i]= s->obmc_scratchpad + 8*(i&1) + s->linesize*8*(i>>1);
3172 hpel_motion(s, ptr[i], src, 0, 0,
3174 s->width, s->height, s->linesize,
3175 s->h_edge_pos, s->v_edge_pos,
3177 mv[i][0], mv[i][1]);
3181 put_obmc(dest, ptr, s->linesize);
3184 static inline void qpel_motion(MpegEncContext *s,
3185 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3186 int field_based, int bottom_field, int field_select,
3187 uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
3188 qpel_mc_func (*qpix_op)[16],
3189 int motion_x, int motion_y, int h)
3191 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
3192 int dxy, uvdxy, mx, my, src_x, src_y, uvsrc_x, uvsrc_y, v_edge_pos, linesize, uvlinesize;
3194 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3195 src_x = s->mb_x * 16 + (motion_x >> 2);
3196 src_y = s->mb_y * (16 >> field_based) + (motion_y >> 2);
3198 v_edge_pos = s->v_edge_pos >> field_based;
3199 linesize = s->linesize << field_based;
3200 uvlinesize = s->uvlinesize << field_based;
3205 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA2){
3206 static const int rtab[8]= {0,0,1,1,0,0,0,1};
3207 mx= (motion_x>>1) + rtab[motion_x&7];
3208 my= (motion_y>>1) + rtab[motion_y&7];
3209 }else if(s->workaround_bugs&FF_BUG_QPEL_CHROMA){
3210 mx= (motion_x>>1)|(motion_x&1);
3211 my= (motion_y>>1)|(motion_y&1);
3219 uvdxy= (mx&1) | ((my&1)<<1);
3223 uvsrc_x = s->mb_x * 8 + mx;
3224 uvsrc_y = s->mb_y * (8 >> field_based) + my;
3226 ptr_y = ref_picture[0] + src_y * linesize + src_x;
3227 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
3228 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
3230 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
3231 || (unsigned)src_y > v_edge_pos - (motion_y&3) - h ){
3232 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
3233 src_x, src_y<<field_based, s->h_edge_pos, s->v_edge_pos);
3234 ptr_y= s->edge_emu_buffer;
3235 if(!(s->flags&CODEC_FLAG_GRAY)){
3236 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
3237 ff_emulated_edge_mc(uvbuf, ptr_cb, s->uvlinesize, 9, 9 + field_based,
3238 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3239 ff_emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9, 9 + field_based,
3240 uvsrc_x, uvsrc_y<<field_based, s->h_edge_pos>>1, s->v_edge_pos>>1);
3247 qpix_op[0][dxy](dest_y, ptr_y, linesize);
3250 dest_y += s->linesize;
3251 dest_cb+= s->uvlinesize;
3252 dest_cr+= s->uvlinesize;
3256 ptr_y += s->linesize;
3257 ptr_cb += s->uvlinesize;
3258 ptr_cr += s->uvlinesize;
3260 //damn interlaced mode
3261 //FIXME boundary mirroring is not exactly correct here
3262 qpix_op[1][dxy](dest_y , ptr_y , linesize);
3263 qpix_op[1][dxy](dest_y+8, ptr_y+8, linesize);
3265 if(!(s->flags&CODEC_FLAG_GRAY)){
3266 pix_op[1][uvdxy](dest_cr, ptr_cr, uvlinesize, h >> 1);
3267 pix_op[1][uvdxy](dest_cb, ptr_cb, uvlinesize, h >> 1);
3271 inline int ff_h263_round_chroma(int x){
3273 return (h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3276 return -(h263_chroma_roundtab[x & 0xf] + ((x >> 3) & ~1));
3281 * h263 chorma 4mv motion compensation.
3283 static inline void chroma_4mv_motion(MpegEncContext *s,
3284 uint8_t *dest_cb, uint8_t *dest_cr,
3285 uint8_t **ref_picture,
3286 op_pixels_func *pix_op,
3288 int dxy, emu=0, src_x, src_y, offset;
3291 /* In case of 8X8, we construct a single chroma motion vector
3292 with a special rounding */
3293 mx= ff_h263_round_chroma(mx);
3294 my= ff_h263_round_chroma(my);
3296 dxy = ((my & 1) << 1) | (mx & 1);
3300 src_x = s->mb_x * 8 + mx;
3301 src_y = s->mb_y * 8 + my;
3302 src_x = clip(src_x, -8, s->width/2);
3303 if (src_x == s->width/2)
3305 src_y = clip(src_y, -8, s->height/2);
3306 if (src_y == s->height/2)
3309 offset = (src_y * (s->uvlinesize)) + src_x;
3310 ptr = ref_picture[1] + offset;
3311 if(s->flags&CODEC_FLAG_EMU_EDGE){
3312 if( (unsigned)src_x > (s->h_edge_pos>>1) - (dxy &1) - 8
3313 || (unsigned)src_y > (s->v_edge_pos>>1) - (dxy>>1) - 8){
3314 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);
3315 ptr= s->edge_emu_buffer;
3319 pix_op[dxy](dest_cb, ptr, s->uvlinesize, 8);
3321 ptr = ref_picture[2] + offset;
3323 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);
3324 ptr= s->edge_emu_buffer;
3326 pix_op[dxy](dest_cr, ptr, s->uvlinesize, 8);
3329 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
3330 uint8_t *dest_cb, uint8_t *dest_cr,
3331 uint8_t **ref_picture,
3332 h264_chroma_mc_func *pix_op,
3334 const int lowres= s->avctx->lowres;
3335 const int block_s= 8>>lowres;
3336 const int s_mask= (2<<lowres)-1;
3337 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
3338 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
3339 int emu=0, src_x, src_y, offset, sx, sy;
3342 if(s->quarter_sample){
3347 /* In case of 8X8, we construct a single chroma motion vector
3348 with a special rounding */
3349 mx= ff_h263_round_chroma(mx);
3350 my= ff_h263_round_chroma(my);
3354 src_x = s->mb_x*block_s + (mx >> (lowres+1));
3355 src_y = s->mb_y*block_s + (my >> (lowres+1));
3357 offset = src_y * s->uvlinesize + src_x;
3358 ptr = ref_picture[1] + offset;
3359 if(s->flags&CODEC_FLAG_EMU_EDGE){
3360 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
3361 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
3362 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3363 ptr= s->edge_emu_buffer;
3369 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
3371 ptr = ref_picture[2] + offset;
3373 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
3374 ptr= s->edge_emu_buffer;
3376 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
3379 static inline void prefetch_motion(MpegEncContext *s, uint8_t **pix, int dir){
3380 /* fetch pixels for estimated mv 4 macroblocks ahead
3381 * optimized for 64byte cache lines */
3382 const int shift = s->quarter_sample ? 2 : 1;
3383 const int mx= (s->mv[dir][0][0]>>shift) + 16*s->mb_x + 8;
3384 const int my= (s->mv[dir][0][1]>>shift) + 16*s->mb_y;
3385 int off= mx + (my + (s->mb_x&3)*4)*s->linesize + 64;
3386 s->dsp.prefetch(pix[0]+off, s->linesize, 4);
3387 off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
3388 s->dsp.prefetch(pix[1]+off, pix[2]-pix[1], 2);
3392 * motion compensation of a single macroblock
3394 * @param dest_y luma destination pointer
3395 * @param dest_cb chroma cb/u destination pointer
3396 * @param dest_cr chroma cr/v destination pointer
3397 * @param dir direction (0->forward, 1->backward)
3398 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3399 * @param pic_op halfpel motion compensation function (average or put normally)
3400 * @param pic_op qpel motion compensation function (average or put normally)
3401 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3403 static inline void MPV_motion(MpegEncContext *s,
3404 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3405 int dir, uint8_t **ref_picture,
3406 op_pixels_func (*pix_op)[4], qpel_mc_func (*qpix_op)[16])
3408 int dxy, mx, my, src_x, src_y, motion_x, motion_y;
3410 uint8_t *ptr, *dest;
3415 prefetch_motion(s, ref_picture, dir);
3417 if(s->obmc && s->pict_type != B_TYPE){
3418 int16_t mv_cache[4][4][2];
3419 const int xy= s->mb_x + s->mb_y*s->mb_stride;
3420 const int mot_stride= s->b8_stride;
3421 const int mot_xy= mb_x*2 + mb_y*2*mot_stride;
3423 assert(!s->mb_skipped);
3425 memcpy(mv_cache[1][1], s->current_picture.motion_val[0][mot_xy ], sizeof(int16_t)*4);
3426 memcpy(mv_cache[2][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3427 memcpy(mv_cache[3][1], s->current_picture.motion_val[0][mot_xy+mot_stride], sizeof(int16_t)*4);
3429 if(mb_y==0 || IS_INTRA(s->current_picture.mb_type[xy-s->mb_stride])){
3430 memcpy(mv_cache[0][1], mv_cache[1][1], sizeof(int16_t)*4);
3432 memcpy(mv_cache[0][1], s->current_picture.motion_val[0][mot_xy-mot_stride], sizeof(int16_t)*4);
3435 if(mb_x==0 || IS_INTRA(s->current_picture.mb_type[xy-1])){
3436 *(int32_t*)mv_cache[1][0]= *(int32_t*)mv_cache[1][1];
3437 *(int32_t*)mv_cache[2][0]= *(int32_t*)mv_cache[2][1];
3439 *(int32_t*)mv_cache[1][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1];
3440 *(int32_t*)mv_cache[2][0]= *(int32_t*)s->current_picture.motion_val[0][mot_xy-1+mot_stride];
3443 if(mb_x+1>=s->mb_width || IS_INTRA(s->current_picture.mb_type[xy+1])){
3444 *(int32_t*)mv_cache[1][3]= *(int32_t*)mv_cache[1][2];
3445 *(int32_t*)mv_cache[2][3]= *(int32_t*)mv_cache[2][2];
3447 *(int32_t*)mv_cache[1][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2];
3448 *(int32_t*)mv_cache[2][3]= *(int32_t*)s->current_picture.motion_val[0][mot_xy+2+mot_stride];
3454 const int x= (i&1)+1;
3455 const int y= (i>>1)+1;
3457 {mv_cache[y][x ][0], mv_cache[y][x ][1]},
3458 {mv_cache[y-1][x][0], mv_cache[y-1][x][1]},
3459 {mv_cache[y][x-1][0], mv_cache[y][x-1][1]},
3460 {mv_cache[y][x+1][0], mv_cache[y][x+1][1]},
3461 {mv_cache[y+1][x][0], mv_cache[y+1][x][1]}};
3463 obmc_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3465 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3472 if(!(s->flags&CODEC_FLAG_GRAY))
3473 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3478 switch(s->mv_type) {
3481 if(s->real_sprite_warping_points==1){
3482 gmc1_motion(s, dest_y, dest_cb, dest_cr,
3485 gmc_motion(s, dest_y, dest_cb, dest_cr,
3488 }else if(s->quarter_sample){
3489 qpel_motion(s, dest_y, dest_cb, dest_cr,
3491 ref_picture, pix_op, qpix_op,
3492 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3494 ff_mspel_motion(s, dest_y, dest_cb, dest_cr,
3495 ref_picture, pix_op,
3496 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3499 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3501 ref_picture, pix_op,
3502 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3508 if(s->quarter_sample){
3510 motion_x = s->mv[dir][i][0];
3511 motion_y = s->mv[dir][i][1];
3513 dxy = ((motion_y & 3) << 2) | (motion_x & 3);
3514 src_x = mb_x * 16 + (motion_x >> 2) + (i & 1) * 8;
3515 src_y = mb_y * 16 + (motion_y >> 2) + (i >>1) * 8;
3517 /* WARNING: do no forget half pels */
3518 src_x = clip(src_x, -16, s->width);
3519 if (src_x == s->width)
3521 src_y = clip(src_y, -16, s->height);
3522 if (src_y == s->height)
3525 ptr = ref_picture[0] + (src_y * s->linesize) + (src_x);
3526 if(s->flags&CODEC_FLAG_EMU_EDGE){
3527 if( (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 8
3528 || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 8 ){
3529 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);
3530 ptr= s->edge_emu_buffer;
3533 dest = dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize;
3534 qpix_op[1][dxy](dest, ptr, s->linesize);
3536 mx += s->mv[dir][i][0]/2;
3537 my += s->mv[dir][i][1]/2;
3541 hpel_motion(s, dest_y + ((i & 1) * 8) + (i >> 1) * 8 * s->linesize,
3542 ref_picture[0], 0, 0,
3543 mb_x * 16 + (i & 1) * 8, mb_y * 16 + (i >>1) * 8,
3544 s->width, s->height, s->linesize,
3545 s->h_edge_pos, s->v_edge_pos,
3547 s->mv[dir][i][0], s->mv[dir][i][1]);
3549 mx += s->mv[dir][i][0];
3550 my += s->mv[dir][i][1];
3554 if(!(s->flags&CODEC_FLAG_GRAY))
3555 chroma_4mv_motion(s, dest_cb, dest_cr, ref_picture, pix_op[1], mx, my);
3558 if (s->picture_structure == PICT_FRAME) {
3559 if(s->quarter_sample){
3561 qpel_motion(s, dest_y, dest_cb, dest_cr,
3562 1, i, s->field_select[dir][i],
3563 ref_picture, pix_op, qpix_op,
3564 s->mv[dir][i][0], s->mv[dir][i][1], 8);
3568 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3569 1, 0, s->field_select[dir][0],
3570 ref_picture, pix_op,
3571 s->mv[dir][0][0], s->mv[dir][0][1], 8);
3573 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3574 1, 1, s->field_select[dir][1],
3575 ref_picture, pix_op,
3576 s->mv[dir][1][0], s->mv[dir][1][1], 8);
3579 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3580 ref_picture= s->current_picture_ptr->data;
3583 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3584 0, 0, s->field_select[dir][0],
3585 ref_picture, pix_op,
3586 s->mv[dir][0][0], s->mv[dir][0][1], 16);
3591 uint8_t ** ref2picture;
3593 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3594 ref2picture= ref_picture;
3596 ref2picture= s->current_picture_ptr->data;
3599 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3600 0, 0, s->field_select[dir][i],
3601 ref2picture, pix_op,
3602 s->mv[dir][i][0], s->mv[dir][i][1] + 16*i, 8);
3604 dest_y += 16*s->linesize;
3605 dest_cb+= (16>>s->chroma_y_shift)*s->uvlinesize;
3606 dest_cr+= (16>>s->chroma_y_shift)*s->uvlinesize;
3610 if(s->picture_structure == PICT_FRAME){
3614 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3616 ref_picture, pix_op,
3617 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], 8);
3619 pix_op = s->dsp.avg_pixels_tab;
3623 mpeg_motion(s, dest_y, dest_cb, dest_cr,
3624 0, 0, s->picture_structure != i+1,
3625 ref_picture, pix_op,
3626 s->mv[dir][2*i][0],s->mv[dir][2*i][1],16);
3628 // after put we make avg of the same block
3629 pix_op=s->dsp.avg_pixels_tab;
3631 //opposite parity is always in the same frame if this is second field
3632 if(!s->first_field){
3633 ref_picture = s->current_picture_ptr->data;
3643 * motion compensation of a single macroblock
3645 * @param dest_y luma destination pointer
3646 * @param dest_cb chroma cb/u destination pointer
3647 * @param dest_cr chroma cr/v destination pointer
3648 * @param dir direction (0->forward, 1->backward)
3649 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
3650 * @param pic_op halfpel motion compensation function (average or put normally)
3651 * the motion vectors are taken from s->mv and the MV type from s->mv_type
3653 static inline void MPV_motion_lowres(MpegEncContext *s,
3654 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
3655 int dir, uint8_t **ref_picture,
3656 h264_chroma_mc_func *pix_op)
3660 const int lowres= s->avctx->lowres;
3661 const int block_s= 8>>lowres;
3666 switch(s->mv_type) {
3668 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3670 ref_picture, pix_op,
3671 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3677 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
3678 ref_picture[0], 0, 0,
3679 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
3680 s->width, s->height, s->linesize,
3681 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
3682 block_s, block_s, pix_op,
3683 s->mv[dir][i][0], s->mv[dir][i][1]);
3685 mx += s->mv[dir][i][0];
3686 my += s->mv[dir][i][1];
3689 if(!(s->flags&CODEC_FLAG_GRAY))
3690 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
3693 if (s->picture_structure == PICT_FRAME) {
3695 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3696 1, 0, s->field_select[dir][0],
3697 ref_picture, pix_op,
3698 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
3700 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3701 1, 1, s->field_select[dir][1],
3702 ref_picture, pix_op,
3703 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
3705 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != B_TYPE && !s->first_field){
3706 ref_picture= s->current_picture_ptr->data;
3709 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3710 0, 0, s->field_select[dir][0],
3711 ref_picture, pix_op,
3712 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
3717 uint8_t ** ref2picture;
3719 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == B_TYPE || s->first_field){
3720 ref2picture= ref_picture;
3722 ref2picture= s->current_picture_ptr->data;
3725 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3726 0, 0, s->field_select[dir][i],
3727 ref2picture, pix_op,
3728 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
3730 dest_y += 2*block_s*s->linesize;
3731 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3732 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
3736 if(s->picture_structure == PICT_FRAME){
3740 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3742 ref_picture, pix_op,
3743 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
3745 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3749 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
3750 0, 0, s->picture_structure != i+1,
3751 ref_picture, pix_op,
3752 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
3754 // after put we make avg of the same block
3755 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
3757 //opposite parity is always in the same frame if this is second field
3758 if(!s->first_field){
3759 ref_picture = s->current_picture_ptr->data;
3768 /* put block[] to dest[] */
3769 static inline void put_dct(MpegEncContext *s,
3770 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3772 s->dct_unquantize_intra(s, block, i, qscale);
3773 s->dsp.idct_put (dest, line_size, block);
3776 /* add block[] to dest[] */
3777 static inline void add_dct(MpegEncContext *s,
3778 DCTELEM *block, int i, uint8_t *dest, int line_size)
3780 if (s->block_last_index[i] >= 0) {
3781 s->dsp.idct_add (dest, line_size, block);
3785 static inline void add_dequant_dct(MpegEncContext *s,
3786 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
3788 if (s->block_last_index[i] >= 0) {
3789 s->dct_unquantize_inter(s, block, i, qscale);
3791 s->dsp.idct_add (dest, line_size, block);
3796 * cleans dc, ac, coded_block for the current non intra MB
3798 void ff_clean_intra_table_entries(MpegEncContext *s)
3800 int wrap = s->b8_stride;
3801 int xy = s->block_index[0];
3804 s->dc_val[0][xy + 1 ] =
3805 s->dc_val[0][xy + wrap] =
3806 s->dc_val[0][xy + 1 + wrap] = 1024;
3808 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
3809 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3810 if (s->msmpeg4_version>=3) {
3811 s->coded_block[xy ] =
3812 s->coded_block[xy + 1 ] =
3813 s->coded_block[xy + wrap] =
3814 s->coded_block[xy + 1 + wrap] = 0;
3817 wrap = s->mb_stride;
3818 xy = s->mb_x + s->mb_y * wrap;
3820 s->dc_val[2][xy] = 1024;
3822 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3823 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3825 s->mbintra_table[xy]= 0;
3828 /* generic function called after a macroblock has been parsed by the
3829 decoder or after it has been encoded by the encoder.
3831 Important variables used:
3832 s->mb_intra : true if intra macroblock
3833 s->mv_dir : motion vector direction
3834 s->mv_type : motion vector type
3835 s->mv : motion vector
3836 s->interlaced_dct : true if interlaced dct used (mpeg2)
3838 static always_inline void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64], int lowres_flag)
3841 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3843 if(s->avctx->xvmc_acceleration){
3844 XVMC_decode_mb(s);//xvmc uses pblocks
3852 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3853 /* save DCT coefficients */
3855 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
3858 *dct++ = block[i][s->dsp.idct_permutation[j]];
3861 s->current_picture.qscale_table[mb_xy]= s->qscale;
3863 /* update DC predictors for P macroblocks */
3865 if (s->h263_pred || s->h263_aic) {
3866 if(s->mbintra_table[mb_xy])
3867 ff_clean_intra_table_entries(s);
3871 s->last_dc[2] = 128 << s->intra_dc_precision;
3874 else if (s->h263_pred || s->h263_aic)
3875 s->mbintra_table[mb_xy]=1;
3877 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==B_TYPE))) { //FIXME precalc
3878 uint8_t *dest_y, *dest_cb, *dest_cr;
3879 int dct_linesize, dct_offset;
3880 op_pixels_func (*op_pix)[4];
3881 qpel_mc_func (*op_qpix)[16];
3882 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
3883 const int uvlinesize= s->current_picture.linesize[1];
3884 const int readable= s->pict_type != B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3885 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3887 /* avoid copy if macroblock skipped in last frame too */
3888 /* skip only during decoding as we might trash the buffers during encoding a bit */
3890 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3891 const int age= s->current_picture.age;
3895 if (s->mb_skipped) {
3897 assert(s->pict_type!=I_TYPE);
3899 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
3900 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3902 /* if previous was skipped too, then nothing to do ! */
3903 if (*mbskip_ptr >= age && s->current_picture.reference){
3906 } else if(!s->current_picture.reference){
3907 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
3908 if(*mbskip_ptr >99) *mbskip_ptr= 99;
3910 *mbskip_ptr = 0; /* not skipped */
3914 dct_linesize = linesize << s->interlaced_dct;
3915 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
3919 dest_cb= s->dest[1];
3920 dest_cr= s->dest[2];
3922 dest_y = s->b_scratchpad;
3923 dest_cb= s->b_scratchpad+16*linesize;
3924 dest_cr= s->b_scratchpad+32*linesize;
3928 /* motion handling */
3929 /* decoding or more than one mb_type (MC was already done otherwise) */
3932 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
3934 if (s->mv_dir & MV_DIR_FORWARD) {
3935 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
3936 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
3938 if (s->mv_dir & MV_DIR_BACKWARD) {
3939 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
3942 if ((!s->no_rounding) || s->pict_type==B_TYPE){
3943 op_pix = s->dsp.put_pixels_tab;
3944 op_qpix= s->dsp.put_qpel_pixels_tab;
3946 op_pix = s->dsp.put_no_rnd_pixels_tab;
3947 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
3949 if (s->mv_dir & MV_DIR_FORWARD) {
3950 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
3951 op_pix = s->dsp.avg_pixels_tab;
3952 op_qpix= s->dsp.avg_qpel_pixels_tab;
3954 if (s->mv_dir & MV_DIR_BACKWARD) {
3955 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
3960 /* skip dequant / idct if we are really late ;) */
3961 if(s->hurry_up>1) goto skip_idct;
3962 if(s->avctx->skip_idct){
3963 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == B_TYPE)
3964 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != I_TYPE)
3965 || s->avctx->skip_idct >= AVDISCARD_ALL)
3969 /* add dct residue */
3970 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
3971 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
3972 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
3973 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
3974 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
3975 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3977 if(!(s->flags&CODEC_FLAG_GRAY)){
3978 if (s->chroma_y_shift){
3979 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3980 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3984 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
3985 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
3986 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
3987 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
3990 } else if(s->codec_id != CODEC_ID_WMV2){
3991 add_dct(s, block[0], 0, dest_y , dct_linesize);
3992 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
3993 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
3994 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3996 if(!(s->flags&CODEC_FLAG_GRAY)){
3997 if(s->chroma_y_shift){//Chroma420
3998 add_dct(s, block[4], 4, dest_cb, uvlinesize);
3999 add_dct(s, block[5], 5, dest_cr, uvlinesize);
4002 dct_linesize = uvlinesize << s->interlaced_dct;
4003 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4005 add_dct(s, block[4], 4, dest_cb, dct_linesize);
4006 add_dct(s, block[5], 5, dest_cr, dct_linesize);
4007 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
4008 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
4009 if(!s->chroma_x_shift){//Chroma444
4010 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
4011 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
4012 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
4013 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
4019 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
4022 /* dct only in intra block */
4023 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
4024 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
4025 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
4026 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
4027 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
4029 if(!(s->flags&CODEC_FLAG_GRAY)){
4030 if(s->chroma_y_shift){
4031 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
4032 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
4036 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
4037 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
4038 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
4039 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
4043 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
4044 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
4045 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
4046 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
4048 if(!(s->flags&CODEC_FLAG_GRAY)){
4049 if(s->chroma_y_shift){
4050 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
4051 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
4054 dct_linesize = uvlinesize << s->interlaced_dct;
4055 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
4057 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
4058 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
4059 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
4060 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
4061 if(!s->chroma_x_shift){//Chroma444
4062 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
4063 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
4064 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
4065 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
4073 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
4074 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
4075 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
4080 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
4081 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1);
4082 else MPV_decode_mb_internal(s, block, 0);
4085 #ifdef CONFIG_ENCODERS
4087 static inline void dct_single_coeff_elimination(MpegEncContext *s, int n, int threshold)
4089 static const char tab[64]=
4101 DCTELEM *block= s->block[n];
4102 const int last_index= s->block_last_index[n];
4107 threshold= -threshold;
4111 /* are all which we could set to zero are allready zero? */
4112 if(last_index<=skip_dc - 1) return;
4114 for(i=0; i<=last_index; i++){
4115 const int j = s->intra_scantable.permutated[i];
4116 const int level = ABS(block[j]);
4118 if(skip_dc && i==0) continue;
4127 if(score >= threshold) return;
4128 for(i=skip_dc; i<=last_index; i++){
4129 const int j = s->intra_scantable.permutated[i];
4132 if(block[0]) s->block_last_index[n]= 0;
4133 else s->block_last_index[n]= -1;
4136 static inline void clip_coeffs(MpegEncContext *s, DCTELEM *block, int last_index)
4139 const int maxlevel= s->max_qcoeff;
4140 const int minlevel= s->min_qcoeff;
4144 i=1; //skip clipping of intra dc
4148 for(;i<=last_index; i++){
4149 const int j= s->intra_scantable.permutated[i];
4150 int level = block[j];
4152 if (level>maxlevel){
4155 }else if(level<minlevel){
4163 if(overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
4164 av_log(s->avctx, AV_LOG_INFO, "warning, clipping %d dct coefficients to %d..%d\n", overflow, minlevel, maxlevel);
4167 #endif //CONFIG_ENCODERS
4171 * @param h is the normal height, this will be reduced automatically if needed for the last row
4173 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
4174 if (s->avctx->draw_horiz_band) {
4178 if(s->picture_structure != PICT_FRAME){
4181 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
4184 h= FFMIN(h, s->avctx->height - y);
4186 if(s->pict_type==B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
4187 src= (AVFrame*)s->current_picture_ptr;
4188 else if(s->last_picture_ptr)
4189 src= (AVFrame*)s->last_picture_ptr;
4193 if(s->pict_type==B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
4199 offset[0]= y * s->linesize;;
4201 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
4207 s->avctx->draw_horiz_band(s->avctx, src, offset,
4208 y, s->picture_structure, h);
4212 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
4213 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
4214 const int uvlinesize= s->current_picture.linesize[1];
4215 const int mb_size= 4 - s->avctx->lowres;
4217 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
4218 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
4219 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
4220 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
4221 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
4222 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;
4223 //block_index is not used by mpeg2, so it is not affected by chroma_format
4225 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
4226 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4227 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
4229 if(!(s->pict_type==B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
4231 s->dest[0] += s->mb_y * linesize << mb_size;
4232 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4233 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
4237 #ifdef CONFIG_ENCODERS
4239 static void get_vissual_weight(int16_t *weight, uint8_t *ptr, int stride){
4249 for(y2= FFMAX(y-1, 0); y2 < FFMIN(8, y+2); y2++){
4250 for(x2= FFMAX(x-1, 0); x2 < FFMIN(8, x+2); x2++){
4251 int v= ptr[x2 + y2*stride];
4257 weight[x + 8*y]= (36*ff_sqrt(count*sqr - sum*sum)) / count;
4262 static always_inline void encode_mb_internal(MpegEncContext *s, int motion_x, int motion_y, int mb_block_height, int mb_block_count)
4264 int16_t weight[8][64];
4265 DCTELEM orig[8][64];
4266 const int mb_x= s->mb_x;
4267 const int mb_y= s->mb_y;
4270 int dct_offset = s->linesize*8; //default for progressive frames
4271 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
4274 for(i=0; i<mb_block_count; i++) skip_dct[i]=0;
4276 if(s->adaptive_quant){
4277 const int last_qp= s->qscale;
4278 const int mb_xy= mb_x + mb_y*s->mb_stride;
4280 s->lambda= s->lambda_table[mb_xy];
4283 if(!(s->flags&CODEC_FLAG_QP_RD)){
4284 s->dquant= s->qscale - last_qp;
4286 if(s->out_format==FMT_H263){
4287 s->dquant= clip(s->dquant, -2, 2); //FIXME RD
4289 if(s->codec_id==CODEC_ID_MPEG4){
4291 if(s->pict_type == B_TYPE){
4293 s->dquant= (s->dquant/2)*2;
4294 if(s->mv_dir&MV_DIRECT)
4297 if(s->mv_type==MV_TYPE_8X8)
4303 ff_set_qscale(s, last_qp + s->dquant);
4304 }else if(s->flags&CODEC_FLAG_QP_RD)
4305 ff_set_qscale(s, s->qscale + s->dquant);
4307 wrap_y = s->linesize;
4308 wrap_c = s->uvlinesize;
4309 ptr_y = s->new_picture.data[0] + (mb_y * 16 * wrap_y) + mb_x * 16;
4310 ptr_cb = s->new_picture.data[1] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4311 ptr_cr = s->new_picture.data[2] + (mb_y * mb_block_height * wrap_c) + mb_x * 8;
4313 if(mb_x*16+16 > s->width || mb_y*16+16 > s->height){
4314 uint8_t *ebuf= s->edge_emu_buffer + 32;
4315 ff_emulated_edge_mc(ebuf , ptr_y , wrap_y,16,16,mb_x*16,mb_y*16, s->width , s->height);
4317 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);
4318 ptr_cb= ebuf+18*wrap_y;
4319 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);
4320 ptr_cr= ebuf+18*wrap_y+8;
4324 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4325 int progressive_score, interlaced_score;
4327 s->interlaced_dct=0;
4328 progressive_score= s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y, 8)
4329 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y*8, NULL, wrap_y, 8) - 400;
4331 if(progressive_score > 0){
4332 interlaced_score = s->dsp.ildct_cmp[4](s, ptr_y , NULL, wrap_y*2, 8)
4333 +s->dsp.ildct_cmp[4](s, ptr_y + wrap_y , NULL, wrap_y*2, 8);
4334 if(progressive_score > interlaced_score){
4335 s->interlaced_dct=1;
4339 if (s->chroma_format == CHROMA_422)
4345 s->dsp.get_pixels(s->block[0], ptr_y , wrap_y);
4346 s->dsp.get_pixels(s->block[1], ptr_y + 8, wrap_y);
4347 s->dsp.get_pixels(s->block[2], ptr_y + dct_offset , wrap_y);
4348 s->dsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
4350 if(s->flags&CODEC_FLAG_GRAY){
4354 s->dsp.get_pixels(s->block[4], ptr_cb, wrap_c);
4355 s->dsp.get_pixels(s->block[5], ptr_cr, wrap_c);
4356 if(!s->chroma_y_shift){ /* 422 */
4357 s->dsp.get_pixels(s->block[6], ptr_cb + (dct_offset>>1), wrap_c);
4358 s->dsp.get_pixels(s->block[7], ptr_cr + (dct_offset>>1), wrap_c);
4362 op_pixels_func (*op_pix)[4];
4363 qpel_mc_func (*op_qpix)[16];
4364 uint8_t *dest_y, *dest_cb, *dest_cr;
4366 dest_y = s->dest[0];
4367 dest_cb = s->dest[1];
4368 dest_cr = s->dest[2];
4370 if ((!s->no_rounding) || s->pict_type==B_TYPE){
4371 op_pix = s->dsp.put_pixels_tab;
4372 op_qpix= s->dsp.put_qpel_pixels_tab;
4374 op_pix = s->dsp.put_no_rnd_pixels_tab;
4375 op_qpix= s->dsp.put_no_rnd_qpel_pixels_tab;
4378 if (s->mv_dir & MV_DIR_FORWARD) {
4379 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
4380 op_pix = s->dsp.avg_pixels_tab;
4381 op_qpix= s->dsp.avg_qpel_pixels_tab;
4383 if (s->mv_dir & MV_DIR_BACKWARD) {
4384 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
4387 if(s->flags&CODEC_FLAG_INTERLACED_DCT){
4388 int progressive_score, interlaced_score;
4390 s->interlaced_dct=0;
4391 progressive_score= s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y, 8)
4392 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y*8, ptr_y + wrap_y*8, wrap_y, 8) - 400;
4394 if(s->avctx->ildct_cmp == FF_CMP_VSSE) progressive_score -= 400;
4396 if(progressive_score>0){
4397 interlaced_score = s->dsp.ildct_cmp[0](s, dest_y , ptr_y , wrap_y*2, 8)
4398 +s->dsp.ildct_cmp[0](s, dest_y + wrap_y , ptr_y + wrap_y , wrap_y*2, 8);
4400 if(progressive_score > interlaced_score){
4401 s->interlaced_dct=1;
4405 if (s->chroma_format == CHROMA_422)
4411 s->dsp.diff_pixels(s->block[0], ptr_y , dest_y , wrap_y);
4412 s->dsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
4413 s->dsp.diff_pixels(s->block[2], ptr_y + dct_offset , dest_y + dct_offset , wrap_y);
4414 s->dsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8, dest_y + dct_offset + 8, wrap_y);
4416 if(s->flags&CODEC_FLAG_GRAY){
4420 s->dsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
4421 s->dsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
4422 if(!s->chroma_y_shift){ /* 422 */
4423 s->dsp.diff_pixels(s->block[6], ptr_cb + (dct_offset>>1), dest_cb + (dct_offset>>1), wrap_c);
4424 s->dsp.diff_pixels(s->block[7], ptr_cr + (dct_offset>>1), dest_cr + (dct_offset>>1), wrap_c);
4427 /* pre quantization */
4428 if(s->current_picture.mc_mb_var[s->mb_stride*mb_y+ mb_x]<2*s->qscale*s->qscale){
4430 if(s->dsp.sad[1](NULL, ptr_y , dest_y , wrap_y, 8) < 20*s->qscale) skip_dct[0]= 1;
4431 if(s->dsp.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20*s->qscale) skip_dct[1]= 1;
4432 if(s->dsp.sad[1](NULL, ptr_y +dct_offset , dest_y +dct_offset , wrap_y, 8) < 20*s->qscale) skip_dct[2]= 1;
4433 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;
4434 if(s->dsp.sad[1](NULL, ptr_cb , dest_cb , wrap_c, 8) < 20*s->qscale) skip_dct[4]= 1;
4435 if(s->dsp.sad[1](NULL, ptr_cr , dest_cr , wrap_c, 8) < 20*s->qscale) skip_dct[5]= 1;
4436 if(!s->chroma_y_shift){ /* 422 */
4437 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;
4438 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;
4443 if(s->avctx->quantizer_noise_shaping){
4444 if(!skip_dct[0]) get_vissual_weight(weight[0], ptr_y , wrap_y);
4445 if(!skip_dct[1]) get_vissual_weight(weight[1], ptr_y + 8, wrap_y);
4446 if(!skip_dct[2]) get_vissual_weight(weight[2], ptr_y + dct_offset , wrap_y);
4447 if(!skip_dct[3]) get_vissual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
4448 if(!skip_dct[4]) get_vissual_weight(weight[4], ptr_cb , wrap_c);
4449 if(!skip_dct[5]) get_vissual_weight(weight[5], ptr_cr , wrap_c);
4450 if(!s->chroma_y_shift){ /* 422 */
4451 if(!skip_dct[6]) get_vissual_weight(weight[6], ptr_cb + (dct_offset>>1), wrap_c);
4452 if(!skip_dct[7]) get_vissual_weight(weight[7], ptr_cr + (dct_offset>>1), wrap_c);
4454 memcpy(orig[0], s->block[0], sizeof(DCTELEM)*64*mb_block_count);
4457 /* DCT & quantize */
4458 assert(s->out_format!=FMT_MJPEG || s->qscale==8);
4460 for(i=0;i<mb_block_count;i++) {
4463 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
4464 // FIXME we could decide to change to quantizer instead of clipping
4465 // JS: I don't think that would be a good idea it could lower quality instead
4466 // of improve it. Just INTRADC clipping deserves changes in quantizer
4467 if (overflow) clip_coeffs(s, s->block[i], s->block_last_index[i]);
4469 s->block_last_index[i]= -1;
4471 if(s->avctx->quantizer_noise_shaping){
4472 for(i=0;i<mb_block_count;i++) {
4474 s->block_last_index[i] = dct_quantize_refine(s, s->block[i], weight[i], orig[i], i, s->qscale);
4479 if(s->luma_elim_threshold && !s->mb_intra)
4481 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
4482 if(s->chroma_elim_threshold && !s->mb_intra)
4483 for(i=4; i<mb_block_count; i++)
4484 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
4486 if(s->flags & CODEC_FLAG_CBP_RD){
4487 for(i=0;i<mb_block_count;i++) {
4488 if(s->block_last_index[i] == -1)
4489 s->coded_score[i]= INT_MAX/256;
4494 if((s->flags&CODEC_FLAG_GRAY) && s->mb_intra){
4495 s->block_last_index[4]=
4496 s->block_last_index[5]= 0;
4498 s->block[5][0]= (1024 + s->c_dc_scale/2)/ s->c_dc_scale;
4501 //non c quantize code returns incorrect block_last_index FIXME
4502 if(s->alternate_scan && s->dct_quantize != dct_quantize_c){
4503 for(i=0; i<mb_block_count; i++){
4505 if(s->block_last_index[i]>0){
4506 for(j=63; j>0; j--){
4507 if(s->block[i][ s->intra_scantable.permutated[j] ]) break;
4509 s->block_last_index[i]= j;
4514 /* huffman encode */
4515 switch(s->codec_id){ //FIXME funct ptr could be slightly faster
4516 case CODEC_ID_MPEG1VIDEO:
4517 case CODEC_ID_MPEG2VIDEO:
4518 mpeg1_encode_mb(s, s->block, motion_x, motion_y); break;
4519 case CODEC_ID_MPEG4:
4520 mpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4521 case CODEC_ID_MSMPEG4V2:
4522 case CODEC_ID_MSMPEG4V3:
4524 msmpeg4_encode_mb(s, s->block, motion_x, motion_y); break;
4526 ff_wmv2_encode_mb(s, s->block, motion_x, motion_y); break;
4527 #ifdef CONFIG_H261_ENCODER
4529 ff_h261_encode_mb(s, s->block, motion_x, motion_y); break;
4532 case CODEC_ID_H263P:
4536 h263_encode_mb(s, s->block, motion_x, motion_y); break;
4537 case CODEC_ID_MJPEG:
4538 mjpeg_encode_mb(s, s->block); break;
4544 static always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
4546 if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y, 8, 6);
4547 else encode_mb_internal(s, motion_x, motion_y, 16, 8);
4550 #endif //CONFIG_ENCODERS
4552 void ff_mpeg_flush(AVCodecContext *avctx){
4554 MpegEncContext *s = avctx->priv_data;
4556 if(s==NULL || s->picture==NULL)
4559 for(i=0; i<MAX_PICTURE_COUNT; i++){
4560 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
4561 || s->picture[i].type == FF_BUFFER_TYPE_USER))
4562 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
4564 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
4566 s->mb_x= s->mb_y= 0;
4568 s->parse_context.state= -1;
4569 s->parse_context.frame_start_found= 0;
4570 s->parse_context.overread= 0;
4571 s->parse_context.overread_index= 0;
4572 s->parse_context.index= 0;
4573 s->parse_context.last_index= 0;
4574 s->bitstream_buffer_size=0;
4577 #ifdef CONFIG_ENCODERS
4578 void ff_copy_bits(PutBitContext *pb, uint8_t *src, int length)
4580 const uint16_t *srcw= (uint16_t*)src;
4581 int words= length>>4;
4582 int bits= length&15;
4585 if(length==0) return;
4588 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4589 }else if(put_bits_count(pb)&7){
4590 for(i=0; i<words; i++) put_bits(pb, 16, be2me_16(srcw[i]));
4592 for(i=0; put_bits_count(pb)&31; i++)
4593 put_bits(pb, 8, src[i]);
4595 memcpy(pbBufPtr(pb), src+i, 2*words-i);
4596 skip_put_bytes(pb, 2*words-i);
4599 put_bits(pb, bits, be2me_16(srcw[words])>>(16-bits));
4602 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
4605 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4608 d->mb_skip_run= s->mb_skip_run;
4610 d->last_dc[i]= s->last_dc[i];
4613 d->mv_bits= s->mv_bits;
4614 d->i_tex_bits= s->i_tex_bits;
4615 d->p_tex_bits= s->p_tex_bits;
4616 d->i_count= s->i_count;
4617 d->f_count= s->f_count;
4618 d->b_count= s->b_count;
4619 d->skip_count= s->skip_count;
4620 d->misc_bits= s->misc_bits;
4624 d->qscale= s->qscale;
4625 d->dquant= s->dquant;
4628 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
4631 memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
4632 memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop?
4635 d->mb_skip_run= s->mb_skip_run;
4637 d->last_dc[i]= s->last_dc[i];
4640 d->mv_bits= s->mv_bits;
4641 d->i_tex_bits= s->i_tex_bits;
4642 d->p_tex_bits= s->p_tex_bits;
4643 d->i_count= s->i_count;
4644 d->f_count= s->f_count;
4645 d->b_count= s->b_count;
4646 d->skip_count= s->skip_count;
4647 d->misc_bits= s->misc_bits;
4649 d->mb_intra= s->mb_intra;
4650 d->mb_skipped= s->mb_skipped;
4651 d->mv_type= s->mv_type;
4652 d->mv_dir= s->mv_dir;
4654 if(s->data_partitioning){
4656 d->tex_pb= s->tex_pb;
4660 d->block_last_index[i]= s->block_last_index[i];
4661 d->interlaced_dct= s->interlaced_dct;
4662 d->qscale= s->qscale;
4665 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
4666 PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
4667 int *dmin, int *next_block, int motion_x, int motion_y)
4670 uint8_t *dest_backup[3];
4672 copy_context_before_encode(s, backup, type);
4674 s->block= s->blocks[*next_block];
4675 s->pb= pb[*next_block];
4676 if(s->data_partitioning){
4677 s->pb2 = pb2 [*next_block];
4678 s->tex_pb= tex_pb[*next_block];
4682 memcpy(dest_backup, s->dest, sizeof(s->dest));
4683 s->dest[0] = s->rd_scratchpad;
4684 s->dest[1] = s->rd_scratchpad + 16*s->linesize;
4685 s->dest[2] = s->rd_scratchpad + 16*s->linesize + 8;
4686 assert(s->linesize >= 32); //FIXME
4689 encode_mb(s, motion_x, motion_y);
4691 score= put_bits_count(&s->pb);
4692 if(s->data_partitioning){
4693 score+= put_bits_count(&s->pb2);
4694 score+= put_bits_count(&s->tex_pb);
4697 if(s->avctx->mb_decision == FF_MB_DECISION_RD){
4698 MPV_decode_mb(s, s->block);
4700 score *= s->lambda2;
4701 score += sse_mb(s) << FF_LAMBDA_SHIFT;
4705 memcpy(s->dest, dest_backup, sizeof(s->dest));
4712 copy_context_after_encode(best, s, type);
4716 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
4717 uint32_t *sq = squareTbl + 256;
4722 return s->dsp.sse[0](NULL, src1, src2, stride, 16);
4723 else if(w==8 && h==8)
4724 return s->dsp.sse[1](NULL, src1, src2, stride, 8);
4728 acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
4737 static int sse_mb(MpegEncContext *s){
4741 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
4742 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
4745 if(s->avctx->mb_cmp == FF_CMP_NSSE){
4746 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)
4747 +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)
4748 +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);
4750 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)
4751 +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)
4752 +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);
4755 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)
4756 +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)
4757 +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);
4760 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
4761 MpegEncContext *s= arg;
4765 s->me.dia_size= s->avctx->pre_dia_size;
4766 s->first_slice_line=1;
4767 for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
4768 for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
4769 ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4771 s->first_slice_line=0;
4779 static int estimate_motion_thread(AVCodecContext *c, void *arg){
4780 MpegEncContext *s= arg;
4782 s->me.dia_size= s->avctx->dia_size;
4783 s->first_slice_line=1;
4784 for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
4785 s->mb_x=0; //for block init below
4786 ff_init_block_index(s);
4787 for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
4788 s->block_index[0]+=2;
4789 s->block_index[1]+=2;
4790 s->block_index[2]+=2;
4791 s->block_index[3]+=2;
4793 /* compute motion vector & mb_type and store in context */
4794 if(s->pict_type==B_TYPE)
4795 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
4797 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
4799 s->first_slice_line=0;
4804 static int mb_var_thread(AVCodecContext *c, void *arg){
4805 MpegEncContext *s= arg;
4808 for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4809 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4812 uint8_t *pix = s->new_picture.data[0] + (yy * s->linesize) + xx;
4814 int sum = s->dsp.pix_sum(pix, s->linesize);
4816 varc = (s->dsp.pix_norm1(pix, s->linesize) - (((unsigned)(sum*sum))>>8) + 500 + 128)>>8;
4818 s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
4819 s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
4820 s->me.mb_var_sum_temp += varc;
4826 static void write_slice_end(MpegEncContext *s){
4827 if(s->codec_id==CODEC_ID_MPEG4){
4828 if(s->partitioned_frame){
4829 ff_mpeg4_merge_partitions(s);
4832 ff_mpeg4_stuffing(&s->pb);
4833 }else if(s->out_format == FMT_MJPEG){
4834 ff_mjpeg_stuffing(&s->pb);
4837 align_put_bits(&s->pb);
4838 flush_put_bits(&s->pb);
4840 if((s->flags&CODEC_FLAG_PASS1) && !s->partitioned_frame)
4841 s->misc_bits+= get_bits_diff(s);
4844 static int encode_thread(AVCodecContext *c, void *arg){
4845 MpegEncContext *s= arg;
4846 int mb_x, mb_y, pdif = 0;
4848 MpegEncContext best_s, backup_s;
4849 uint8_t bit_buf[2][MAX_MB_BYTES];
4850 uint8_t bit_buf2[2][MAX_MB_BYTES];
4851 uint8_t bit_buf_tex[2][MAX_MB_BYTES];
4852 PutBitContext pb[2], pb2[2], tex_pb[2];
4853 //printf("%d->%d\n", s->resync_mb_y, s->end_mb_y);
4856 init_put_bits(&pb [i], bit_buf [i], MAX_MB_BYTES);
4857 init_put_bits(&pb2 [i], bit_buf2 [i], MAX_MB_BYTES);
4858 init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
4861 s->last_bits= put_bits_count(&s->pb);
4872 /* init last dc values */
4873 /* note: quant matrix value (8) is implied here */
4874 s->last_dc[i] = 128 << s->intra_dc_precision;
4876 s->current_picture.error[i] = 0;
4879 memset(s->last_mv, 0, sizeof(s->last_mv));
4883 switch(s->codec_id){
4885 case CODEC_ID_H263P:
4887 s->gob_index = ff_h263_get_gob_height(s);
4889 case CODEC_ID_MPEG4:
4890 if(s->partitioned_frame)
4891 ff_mpeg4_init_partitions(s);
4897 s->first_slice_line = 1;
4898 s->ptr_lastgob = s->pb.buf;
4899 for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
4900 // printf("row %d at %X\n", s->mb_y, (int)s);
4904 ff_set_qscale(s, s->qscale);
4905 ff_init_block_index(s);
4907 for(mb_x=0; mb_x < s->mb_width; mb_x++) {
4908 int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
4909 int mb_type= s->mb_type[xy];
4914 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
4915 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
4918 if(s->data_partitioning){
4919 if( s->pb2 .buf_end - s->pb2 .buf - (put_bits_count(&s-> pb2)>>3) < MAX_MB_BYTES
4920 || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
4921 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
4927 s->mb_y = mb_y; // moved into loop, can get changed by H.261
4928 ff_update_block_index(s);
4930 #ifdef CONFIG_H261_ENCODER
4931 if(s->codec_id == CODEC_ID_H261){
4932 ff_h261_reorder_mb_index(s);
4933 xy= s->mb_y*s->mb_stride + s->mb_x;
4934 mb_type= s->mb_type[xy];
4938 /* write gob / video packet header */
4940 int current_packet_size, is_gob_start;
4942 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
4944 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
4946 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
4948 switch(s->codec_id){
4950 case CODEC_ID_H263P:
4951 if(!s->h263_slice_structured)
4952 if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
4954 case CODEC_ID_MPEG2VIDEO:
4955 if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
4956 case CODEC_ID_MPEG1VIDEO:
4957 if(s->mb_skip_run) is_gob_start=0;
4962 if(s->start_mb_y != mb_y || mb_x!=0){
4965 if(s->codec_id==CODEC_ID_MPEG4 && s->partitioned_frame){
4966 ff_mpeg4_init_partitions(s);
4970 assert((put_bits_count(&s->pb)&7) == 0);
4971 current_packet_size= pbBufPtr(&s->pb) - s->ptr_lastgob;
4973 if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
4974 int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
4975 int d= 100 / s->avctx->error_rate;
4977 current_packet_size=0;
4978 #ifndef ALT_BITSTREAM_WRITER
4979 s->pb.buf_ptr= s->ptr_lastgob;
4981 assert(pbBufPtr(&s->pb) == s->ptr_lastgob);
4985 if (s->avctx->rtp_callback){
4986 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
4987 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
4990 switch(s->codec_id){
4991 case CODEC_ID_MPEG4:
4992 ff_mpeg4_encode_video_packet_header(s);
4993 ff_mpeg4_clean_buffers(s);
4995 case CODEC_ID_MPEG1VIDEO:
4996 case CODEC_ID_MPEG2VIDEO:
4997 ff_mpeg1_encode_slice_header(s);
4998 ff_mpeg1_clean_buffers(s);
5001 case CODEC_ID_H263P:
5002 h263_encode_gob_header(s, mb_y);
5006 if(s->flags&CODEC_FLAG_PASS1){
5007 int bits= put_bits_count(&s->pb);
5008 s->misc_bits+= bits - s->last_bits;
5012 s->ptr_lastgob += current_packet_size;
5013 s->first_slice_line=1;
5014 s->resync_mb_x=mb_x;
5015 s->resync_mb_y=mb_y;
5019 if( (s->resync_mb_x == s->mb_x)
5020 && s->resync_mb_y+1 == s->mb_y){
5021 s->first_slice_line=0;
5025 s->dquant=0; //only for QP_RD
5027 if(mb_type & (mb_type-1) || (s->flags & CODEC_FLAG_QP_RD)){ // more than 1 MB type possible or CODEC_FLAG_QP_RD
5029 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
5031 copy_context_before_encode(&backup_s, s, -1);
5033 best_s.data_partitioning= s->data_partitioning;
5034 best_s.partitioned_frame= s->partitioned_frame;
5035 if(s->data_partitioning){
5036 backup_s.pb2= s->pb2;
5037 backup_s.tex_pb= s->tex_pb;
5040 if(mb_type&CANDIDATE_MB_TYPE_INTER){
5041 s->mv_dir = MV_DIR_FORWARD;
5042 s->mv_type = MV_TYPE_16X16;
5044 s->mv[0][0][0] = s->p_mv_table[xy][0];
5045 s->mv[0][0][1] = s->p_mv_table[xy][1];
5046 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
5047 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5049 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
5050 s->mv_dir = MV_DIR_FORWARD;
5051 s->mv_type = MV_TYPE_FIELD;
5054 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
5055 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
5056 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
5058 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
5059 &dmin, &next_block, 0, 0);
5061 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
5062 s->mv_dir = MV_DIR_FORWARD;
5063 s->mv_type = MV_TYPE_16X16;
5067 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
5068 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5070 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
5071 s->mv_dir = MV_DIR_FORWARD;
5072 s->mv_type = MV_TYPE_8X8;
5075 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
5076 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
5078 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
5079 &dmin, &next_block, 0, 0);
5081 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
5082 s->mv_dir = MV_DIR_FORWARD;
5083 s->mv_type = MV_TYPE_16X16;
5085 s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
5086 s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
5087 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
5088 &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
5090 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
5091 s->mv_dir = MV_DIR_BACKWARD;
5092 s->mv_type = MV_TYPE_16X16;
5094 s->mv[1][0][0] = s->b_back_mv_table[xy][0];
5095 s->mv[1][0][1] = s->b_back_mv_table[xy][1];
5096 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
5097 &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
5099 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
5100 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5101 s->mv_type = MV_TYPE_16X16;
5103 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
5104 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
5105 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
5106 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
5107 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
5108 &dmin, &next_block, 0, 0);
5110 if(mb_type&CANDIDATE_MB_TYPE_DIRECT){
5111 int mx= s->b_direct_mv_table[xy][0];
5112 int my= s->b_direct_mv_table[xy][1];
5114 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
5116 ff_mpeg4_set_direct_mv(s, mx, my);
5117 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
5118 &dmin, &next_block, mx, my);
5120 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
5121 s->mv_dir = MV_DIR_FORWARD;
5122 s->mv_type = MV_TYPE_FIELD;
5125 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
5126 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
5127 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
5129 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
5130 &dmin, &next_block, 0, 0);
5132 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
5133 s->mv_dir = MV_DIR_BACKWARD;
5134 s->mv_type = MV_TYPE_FIELD;
5137 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
5138 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
5139 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
5141 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
5142 &dmin, &next_block, 0, 0);
5144 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
5145 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5146 s->mv_type = MV_TYPE_FIELD;
5148 for(dir=0; dir<2; dir++){
5150 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
5151 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
5152 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
5155 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
5156 &dmin, &next_block, 0, 0);
5158 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
5160 s->mv_type = MV_TYPE_16X16;
5164 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
5165 &dmin, &next_block, 0, 0);
5166 if(s->h263_pred || s->h263_aic){
5168 s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
5170 ff_clean_intra_table_entries(s); //old mode?
5174 if(s->flags & CODEC_FLAG_QP_RD){
5175 if(best_s.mv_type==MV_TYPE_16X16 && !(best_s.mv_dir&MV_DIRECT)){
5176 const int last_qp= backup_s.qscale;
5177 int dquant, dir, qp, dc[6];
5179 const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
5181 assert(backup_s.dquant == 0);
5184 s->mv_dir= best_s.mv_dir;
5185 s->mv_type = MV_TYPE_16X16;
5186 s->mb_intra= best_s.mb_intra;
5187 s->mv[0][0][0] = best_s.mv[0][0][0];
5188 s->mv[0][0][1] = best_s.mv[0][0][1];
5189 s->mv[1][0][0] = best_s.mv[1][0][0];
5190 s->mv[1][0][1] = best_s.mv[1][0][1];
5192 dir= s->pict_type == B_TYPE ? 2 : 1;
5193 if(last_qp + dir > s->avctx->qmax) dir= -dir;
5194 for(dquant= dir; dquant<=2 && dquant>=-2; dquant += dir){
5195 qp= last_qp + dquant;
5196 if(qp < s->avctx->qmin || qp > s->avctx->qmax)
5198 backup_s.dquant= dquant;
5199 if(s->mb_intra && s->dc_val[0]){
5201 dc[i]= s->dc_val[0][ s->block_index[i] ];
5202 memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(DCTELEM)*16);
5206 encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
5207 &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
5208 if(best_s.qscale != qp){
5209 if(s->mb_intra && s->dc_val[0]){
5211 s->dc_val[0][ s->block_index[i] ]= dc[i];
5212 memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(DCTELEM)*16);
5215 if(dir > 0 && dquant==dir){
5223 s->current_picture.qscale_table[xy]= qp;
5227 copy_context_after_encode(s, &best_s, -1);
5229 pb_bits_count= put_bits_count(&s->pb);
5230 flush_put_bits(&s->pb);
5231 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
5234 if(s->data_partitioning){
5235 pb2_bits_count= put_bits_count(&s->pb2);
5236 flush_put_bits(&s->pb2);
5237 ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
5238 s->pb2= backup_s.pb2;
5240 tex_pb_bits_count= put_bits_count(&s->tex_pb);
5241 flush_put_bits(&s->tex_pb);
5242 ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
5243 s->tex_pb= backup_s.tex_pb;
5245 s->last_bits= put_bits_count(&s->pb);
5247 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
5248 ff_h263_update_motion_val(s);
5250 if(next_block==0){ //FIXME 16 vs linesize16
5251 s->dsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad , s->linesize ,16);
5252 s->dsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize , s->uvlinesize, 8);
5253 s->dsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
5256 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
5257 MPV_decode_mb(s, s->block);
5259 int motion_x, motion_y;
5260 s->mv_type=MV_TYPE_16X16;
5261 // only one MB-Type possible
5264 case CANDIDATE_MB_TYPE_INTRA:
5267 motion_x= s->mv[0][0][0] = 0;
5268 motion_y= s->mv[0][0][1] = 0;
5270 case CANDIDATE_MB_TYPE_INTER:
5271 s->mv_dir = MV_DIR_FORWARD;
5273 motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
5274 motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
5276 case CANDIDATE_MB_TYPE_INTER_I:
5277 s->mv_dir = MV_DIR_FORWARD;
5278 s->mv_type = MV_TYPE_FIELD;
5281 j= s->field_select[0][i] = s->p_field_select_table[i][xy];
5282 s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
5283 s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
5285 motion_x = motion_y = 0;
5287 case CANDIDATE_MB_TYPE_INTER4V:
5288 s->mv_dir = MV_DIR_FORWARD;
5289 s->mv_type = MV_TYPE_8X8;
5292 s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
5293 s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
5295 motion_x= motion_y= 0;
5297 case CANDIDATE_MB_TYPE_DIRECT:
5298 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
5300 motion_x=s->b_direct_mv_table[xy][0];
5301 motion_y=s->b_direct_mv_table[xy][1];
5302 ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
5304 case CANDIDATE_MB_TYPE_BIDIR:
5305 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5309 s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
5310 s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
5311 s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
5312 s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
5314 case CANDIDATE_MB_TYPE_BACKWARD:
5315 s->mv_dir = MV_DIR_BACKWARD;
5317 motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
5318 motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
5320 case CANDIDATE_MB_TYPE_FORWARD:
5321 s->mv_dir = MV_DIR_FORWARD;
5323 motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
5324 motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
5325 // printf(" %d %d ", motion_x, motion_y);
5327 case CANDIDATE_MB_TYPE_FORWARD_I:
5328 s->mv_dir = MV_DIR_FORWARD;
5329 s->mv_type = MV_TYPE_FIELD;
5332 j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
5333 s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
5334 s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
5336 motion_x=motion_y=0;
5338 case CANDIDATE_MB_TYPE_BACKWARD_I:
5339 s->mv_dir = MV_DIR_BACKWARD;
5340 s->mv_type = MV_TYPE_FIELD;
5343 j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
5344 s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
5345 s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
5347 motion_x=motion_y=0;
5349 case CANDIDATE_MB_TYPE_BIDIR_I:
5350 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
5351 s->mv_type = MV_TYPE_FIELD;
5353 for(dir=0; dir<2; dir++){
5355 j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
5356 s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
5357 s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
5360 motion_x=motion_y=0;
5363 motion_x=motion_y=0; //gcc warning fix
5364 av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
5367 encode_mb(s, motion_x, motion_y);
5369 // RAL: Update last macroblock type
5370 s->last_mv_dir = s->mv_dir;
5372 if (s->out_format == FMT_H263 && s->pict_type!=B_TYPE)
5373 ff_h263_update_motion_val(s);
5375 MPV_decode_mb(s, s->block);
5378 /* clean the MV table in IPS frames for direct mode in B frames */
5379 if(s->mb_intra /* && I,P,S_TYPE */){
5380 s->p_mv_table[xy][0]=0;
5381 s->p_mv_table[xy][1]=0;
5384 if(s->flags&CODEC_FLAG_PSNR){
5388 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
5389 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
5391 s->current_picture.error[0] += sse(
5392 s, s->new_picture.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
5393 s->dest[0], w, h, s->linesize);
5394 s->current_picture.error[1] += sse(
5395 s, s->new_picture.data[1] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
5396 s->dest[1], w>>1, h>>1, s->uvlinesize);
5397 s->current_picture.error[2] += sse(
5398 s, s->new_picture .data[2] + s->mb_x*8 + s->mb_y*s->uvlinesize*8,
5399 s->dest[2], w>>1, h>>1, s->uvlinesize);
5402 if(s->out_format == FMT_H263)
5403 ff_h263_loop_filter(s);
5405 //printf("MB %d %d bits\n", s->mb_x+s->mb_y*s->mb_stride, put_bits_count(&s->pb));
5409 //not beautiful here but we must write it before flushing so it has to be here
5410 if (s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == I_TYPE)
5411 msmpeg4_encode_ext_header(s);
5415 /* Send the last GOB if RTP */
5416 if (s->avctx->rtp_callback) {
5417 int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
5418 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
5419 /* Call the RTP callback to send the last GOB */
5421 s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
5427 #define MERGE(field) dst->field += src->field; src->field=0
5428 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
5429 MERGE(me.scene_change_score);
5430 MERGE(me.mc_mb_var_sum_temp);
5431 MERGE(me.mb_var_sum_temp);
5434 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
5437 MERGE(dct_count[0]); //note, the other dct vars are not part of the context
5438 MERGE(dct_count[1]);
5448 MERGE(padding_bug_score);
5449 MERGE(current_picture.error[0]);
5450 MERGE(current_picture.error[1]);
5451 MERGE(current_picture.error[2]);
5453 if(dst->avctx->noise_reduction){
5454 for(i=0; i<64; i++){
5455 MERGE(dct_error_sum[0][i]);
5456 MERGE(dct_error_sum[1][i]);
5460 assert(put_bits_count(&src->pb) % 8 ==0);
5461 assert(put_bits_count(&dst->pb) % 8 ==0);
5462 ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
5463 flush_put_bits(&dst->pb);
5466 static void estimate_qp(MpegEncContext *s, int dry_run){
5467 if (!s->fixed_qscale)
5468 s->current_picture_ptr->quality=
5469 s->current_picture.quality = ff_rate_estimate_qscale(s, dry_run);
5471 if(s->adaptive_quant){
5472 switch(s->codec_id){
5473 case CODEC_ID_MPEG4:
5474 ff_clean_mpeg4_qscales(s);
5477 case CODEC_ID_H263P:
5479 ff_clean_h263_qscales(s);
5483 s->lambda= s->lambda_table[0];
5486 s->lambda= s->current_picture.quality;
5487 //printf("%d %d\n", s->avctx->global_quality, s->current_picture.quality);
5491 static void encode_picture(MpegEncContext *s, int picture_number)
5496 s->picture_number = picture_number;
5498 /* Reset the average MB variance */
5499 s->me.mb_var_sum_temp =
5500 s->me.mc_mb_var_sum_temp = 0;
5502 /* we need to initialize some time vars before we can encode b-frames */
5503 // RAL: Condition added for MPEG1VIDEO
5504 if (s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->h263_msmpeg4))
5505 ff_set_mpeg4_time(s, s->picture_number); //FIXME rename and use has_b_frames or similar
5507 s->me.scene_change_score=0;
5509 // s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME ratedistoration
5511 if(s->pict_type==I_TYPE){
5512 if(s->msmpeg4_version >= 3) s->no_rounding=1;
5513 else s->no_rounding=0;
5514 }else if(s->pict_type!=B_TYPE){
5515 if(s->flipflop_rounding || s->codec_id == CODEC_ID_H263P || s->codec_id == CODEC_ID_MPEG4)
5516 s->no_rounding ^= 1;
5519 if(s->flags & CODEC_FLAG_PASS2){
5521 ff_get_2pass_fcode(s);
5522 }else if(!(s->flags & CODEC_FLAG_QSCALE)){
5523 if(s->pict_type==B_TYPE)
5524 s->lambda= s->last_lambda_for[s->pict_type];
5526 s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
5530 s->mb_intra=0; //for the rate distortion & bit compare functions
5531 for(i=1; i<s->avctx->thread_count; i++){
5532 ff_update_duplicate_context(s->thread_context[i], s);
5537 /* Estimate motion for every MB */
5538 if(s->pict_type != I_TYPE){
5539 s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
5540 s->lambda2= (s->lambda2* s->avctx->me_penalty_compensation + 128)>>8;
5541 if(s->pict_type != B_TYPE && s->avctx->me_threshold==0){
5542 if((s->avctx->pre_me && s->last_non_b_pict_type==I_TYPE) || s->avctx->pre_me==2){
5543 s->avctx->execute(s->avctx, pre_estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5547 s->avctx->execute(s->avctx, estimate_motion_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5548 }else /* if(s->pict_type == I_TYPE) */{
5550 for(i=0; i<s->mb_stride*s->mb_height; i++)
5551 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
5553 if(!s->fixed_qscale){
5554 /* finding spatial complexity for I-frame rate control */
5555 s->avctx->execute(s->avctx, mb_var_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5558 for(i=1; i<s->avctx->thread_count; i++){
5559 merge_context_after_me(s, s->thread_context[i]);
5561 s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
5562 s->current_picture. mb_var_sum= s->current_picture_ptr-> mb_var_sum= s->me. mb_var_sum_temp;
5565 if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == P_TYPE){
5566 s->pict_type= I_TYPE;
5567 for(i=0; i<s->mb_stride*s->mb_height; i++)
5568 s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
5569 //printf("Scene change detected, encoding as I Frame %d %d\n", s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
5573 if(s->pict_type==P_TYPE || s->pict_type==S_TYPE) {
5574 s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
5576 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5578 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
5579 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
5580 s->f_code= FFMAX(s->f_code, FFMAX(a,b));
5583 ff_fix_long_p_mvs(s);
5584 ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
5585 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5589 ff_fix_long_mvs(s, s->p_field_select_table[i], j,
5590 s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
5595 if(s->pict_type==B_TYPE){
5598 a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
5599 b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5600 s->f_code = FFMAX(a, b);
5602 a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
5603 b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
5604 s->b_code = FFMAX(a, b);
5606 ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
5607 ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
5608 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5609 ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
5610 if(s->flags & CODEC_FLAG_INTERLACED_ME){
5612 for(dir=0; dir<2; dir++){
5615 int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
5616 : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
5617 ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
5618 s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
5628 if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==I_TYPE && !(s->flags & CODEC_FLAG_QSCALE))
5629 s->qscale= 3; //reduce clipping problems
5631 if (s->out_format == FMT_MJPEG) {
5632 /* for mjpeg, we do include qscale in the matrix */
5633 s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
5635 int j= s->dsp.idct_permutation[i];
5637 s->intra_matrix[j] = clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
5639 convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
5640 s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
5644 //FIXME var duplication
5645 s->current_picture_ptr->key_frame=
5646 s->current_picture.key_frame= s->pict_type == I_TYPE; //FIXME pic_ptr
5647 s->current_picture_ptr->pict_type=
5648 s->current_picture.pict_type= s->pict_type;
5650 if(s->current_picture.key_frame)
5651 s->picture_in_gop_number=0;
5653 s->last_bits= put_bits_count(&s->pb);
5654 switch(s->out_format) {
5656 mjpeg_picture_header(s);
5658 #ifdef CONFIG_H261_ENCODER
5660 ff_h261_encode_picture_header(s, picture_number);
5664 if (s->codec_id == CODEC_ID_WMV2)
5665 ff_wmv2_encode_picture_header(s, picture_number);
5666 else if (s->h263_msmpeg4)
5667 msmpeg4_encode_picture_header(s, picture_number);
5668 else if (s->h263_pred)
5669 mpeg4_encode_picture_header(s, picture_number);
5670 #ifdef CONFIG_RV10_ENCODER
5671 else if (s->codec_id == CODEC_ID_RV10)
5672 rv10_encode_picture_header(s, picture_number);
5674 #ifdef CONFIG_RV20_ENCODER
5675 else if (s->codec_id == CODEC_ID_RV20)
5676 rv20_encode_picture_header(s, picture_number);
5678 else if (s->codec_id == CODEC_ID_FLV1)
5679 ff_flv_encode_picture_header(s, picture_number);
5681 h263_encode_picture_header(s, picture_number);
5684 mpeg1_encode_picture_header(s, picture_number);
5691 bits= put_bits_count(&s->pb);
5692 s->header_bits= bits - s->last_bits;
5694 for(i=1; i<s->avctx->thread_count; i++){
5695 update_duplicate_context_after_me(s->thread_context[i], s);
5697 s->avctx->execute(s->avctx, encode_thread, (void**)&(s->thread_context[0]), NULL, s->avctx->thread_count);
5698 for(i=1; i<s->avctx->thread_count; i++){
5699 merge_context_after_encode(s, s->thread_context[i]);
5704 #endif //CONFIG_ENCODERS
5706 static void denoise_dct_c(MpegEncContext *s, DCTELEM *block){
5707 const int intra= s->mb_intra;
5710 s->dct_count[intra]++;
5712 for(i=0; i<64; i++){
5713 int level= block[i];
5717 s->dct_error_sum[intra][i] += level;
5718 level -= s->dct_offset[intra][i];
5719 if(level<0) level=0;
5721 s->dct_error_sum[intra][i] -= level;
5722 level += s->dct_offset[intra][i];
5723 if(level>0) level=0;
5730 #ifdef CONFIG_ENCODERS
5732 static int dct_quantize_trellis_c(MpegEncContext *s,
5733 DCTELEM *block, int n,
5734 int qscale, int *overflow){
5736 const uint8_t *scantable= s->intra_scantable.scantable;
5737 const uint8_t *perm_scantable= s->intra_scantable.permutated;
5739 unsigned int threshold1, threshold2;
5751 int coeff_count[64];
5752 int qmul, qadd, start_i, last_non_zero, i, dc;
5753 const int esc_length= s->ac_esc_length;
5755 uint8_t * last_length;
5756 const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
5758 s->dsp.fdct (block);
5760 if(s->dct_error_sum)
5761 s->denoise_dct(s, block);
5763 qadd= ((qscale-1)|1)*8;
5774 /* For AIC we skip quant/dequant of INTRADC */
5779 /* note: block[0] is assumed to be positive */
5780 block[0] = (block[0] + (q >> 1)) / q;
5783 qmat = s->q_intra_matrix[qscale];
5784 if(s->mpeg_quant || s->out_format == FMT_MPEG1)
5785 bias= 1<<(QMAT_SHIFT-1);
5786 length = s->intra_ac_vlc_length;
5787 last_length= s->intra_ac_vlc_last_length;
5791 qmat = s->q_inter_matrix[qscale];
5792 length = s->inter_ac_vlc_length;
5793 last_length= s->inter_ac_vlc_last_length;
5797 threshold1= (1<<QMAT_SHIFT) - bias - 1;
5798 threshold2= (threshold1<<1);
5800 for(i=63; i>=start_i; i--) {
5801 const int j = scantable[i];
5802 int level = block[j] * qmat[j];
5804 if(((unsigned)(level+threshold1))>threshold2){
5810 for(i=start_i; i<=last_non_zero; i++) {
5811 const int j = scantable[i];
5812 int level = block[j] * qmat[j];
5814 // if( bias+level >= (1<<(QMAT_SHIFT - 3))
5815 // || bias-level >= (1<<(QMAT_SHIFT - 3))){
5816 if(((unsigned)(level+threshold1))>threshold2){
5818 level= (bias + level)>>QMAT_SHIFT;
5820 coeff[1][i]= level-1;
5821 // coeff[2][k]= level-2;
5823 level= (bias - level)>>QMAT_SHIFT;
5824 coeff[0][i]= -level;
5825 coeff[1][i]= -level+1;
5826 // coeff[2][k]= -level+2;
5828 coeff_count[i]= FFMIN(level, 2);
5829 assert(coeff_count[i]);
5832 coeff[0][i]= (level>>31)|1;
5837 *overflow= s->max_qcoeff < max; //overflow might have happened
5839 if(last_non_zero < start_i){
5840 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
5841 return last_non_zero;
5844 score_tab[start_i]= 0;
5845 survivor[0]= start_i;
5848 for(i=start_i; i<=last_non_zero; i++){
5850 const int dct_coeff= ABS(block[ scantable[i] ]);
5851 const int zero_distoration= dct_coeff*dct_coeff;
5852 int best_score=256*256*256*120;
5853 for(level_index=0; level_index < coeff_count[i]; level_index++){
5855 int level= coeff[level_index][i];
5856 const int alevel= ABS(level);
5861 if(s->out_format == FMT_H263){
5862 unquant_coeff= alevel*qmul + qadd;
5864 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
5866 unquant_coeff = (int)( alevel * qscale * s->intra_matrix[j]) >> 3;
5867 unquant_coeff = (unquant_coeff - 1) | 1;
5869 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
5870 unquant_coeff = (unquant_coeff - 1) | 1;
5875 distoration= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distoration;
5877 if((level&(~127)) == 0){
5878 for(j=survivor_count-1; j>=0; j--){
5879 int run= i - survivor[j];
5880 int score= distoration + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5881 score += score_tab[i-run];
5883 if(score < best_score){
5886 level_tab[i+1]= level-64;
5890 if(s->out_format == FMT_H263){
5891 for(j=survivor_count-1; j>=0; j--){
5892 int run= i - survivor[j];
5893 int score= distoration + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
5894 score += score_tab[i-run];
5895 if(score < last_score){
5898 last_level= level-64;
5904 distoration += esc_length*lambda;
5905 for(j=survivor_count-1; j>=0; j--){
5906 int run= i - survivor[j];
5907 int score= distoration + score_tab[i-run];
5909 if(score < best_score){
5912 level_tab[i+1]= level-64;
5916 if(s->out_format == FMT_H263){
5917 for(j=survivor_count-1; j>=0; j--){
5918 int run= i - survivor[j];
5919 int score= distoration + score_tab[i-run];
5920 if(score < last_score){
5923 last_level= level-64;
5931 score_tab[i+1]= best_score;
5933 //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
5934 if(last_non_zero <= 27){
5935 for(; survivor_count; survivor_count--){
5936 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
5940 for(; survivor_count; survivor_count--){
5941 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
5946 survivor[ survivor_count++ ]= i+1;
5949 if(s->out_format != FMT_H263){
5950 last_score= 256*256*256*120;
5951 for(i= survivor[0]; i<=last_non_zero + 1; i++){
5952 int score= score_tab[i];
5953 if(i) score += lambda*2; //FIXME exacter?
5955 if(score < last_score){
5958 last_level= level_tab[i];
5959 last_run= run_tab[i];
5964 s->coded_score[n] = last_score;
5967 last_non_zero= last_i - 1;
5968 memset(block + start_i, 0, (64-start_i)*sizeof(DCTELEM));
5970 if(last_non_zero < start_i)
5971 return last_non_zero;
5973 if(last_non_zero == 0 && start_i == 0){
5975 int best_score= dc * dc;
5977 for(i=0; i<coeff_count[0]; i++){
5978 int level= coeff[i][0];
5979 int alevel= ABS(level);
5980 int unquant_coeff, score, distortion;
5982 if(s->out_format == FMT_H263){
5983 unquant_coeff= (alevel*qmul + qadd)>>3;
5985 unquant_coeff = ((( alevel << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
5986 unquant_coeff = (unquant_coeff - 1) | 1;
5988 unquant_coeff = (unquant_coeff + 4) >> 3;
5989 unquant_coeff<<= 3 + 3;
5991 distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
5993 if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
5994 else score= distortion + esc_length*lambda;
5996 if(score < best_score){
5998 best_level= level - 64;
6001 block[0]= best_level;
6002 s->coded_score[n] = best_score - dc*dc;
6003 if(best_level == 0) return -1;
6004 else return last_non_zero;
6010 block[ perm_scantable[last_non_zero] ]= last_level;
6013 for(; i>start_i; i -= run_tab[i] + 1){
6014 block[ perm_scantable[i-1] ]= level_tab[i];
6017 return last_non_zero;
6020 //#define REFINE_STATS 1
6021 static int16_t basis[64][64];
6023 static void build_basis(uint8_t *perm){
6030 double s= 0.25*(1<<BASIS_SHIFT);
6032 int perm_index= perm[index];
6033 if(i==0) s*= sqrt(0.5);
6034 if(j==0) s*= sqrt(0.5);
6035 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)));
6042 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
6043 DCTELEM *block, int16_t *weight, DCTELEM *orig,
6046 DECLARE_ALIGNED_16(DCTELEM, d1[64]);
6048 const uint8_t *scantable= s->intra_scantable.scantable;
6049 const uint8_t *perm_scantable= s->intra_scantable.permutated;
6050 // unsigned int threshold1, threshold2;
6055 int qmul, qadd, start_i, last_non_zero, i, dc;
6057 uint8_t * last_length;
6059 int rle_index, run, q, sum;
6062 static int after_last=0;
6063 static int to_zero=0;
6064 static int from_zero=0;
6067 static int messed_sign=0;
6070 if(basis[0][0] == 0)
6071 build_basis(s->dsp.idct_permutation);
6082 /* For AIC we skip quant/dequant of INTRADC */
6086 q <<= RECON_SHIFT-3;
6087 /* note: block[0] is assumed to be positive */
6089 // block[0] = (block[0] + (q >> 1)) / q;
6091 qmat = s->q_intra_matrix[qscale];
6092 // if(s->mpeg_quant || s->out_format == FMT_MPEG1)
6093 // bias= 1<<(QMAT_SHIFT-1);
6094 length = s->intra_ac_vlc_length;
6095 last_length= s->intra_ac_vlc_last_length;
6099 qmat = s->q_inter_matrix[qscale];
6100 length = s->inter_ac_vlc_length;
6101 last_length= s->inter_ac_vlc_last_length;
6103 last_non_zero = s->block_last_index[n];
6108 dc += (1<<(RECON_SHIFT-1));
6109 for(i=0; i<64; i++){
6110 rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME use orig dirrectly instead of copying to rem[]
6113 STOP_TIMER("memset rem[]")}
6116 for(i=0; i<64; i++){
6121 w= ABS(weight[i]) + qns*one;
6122 w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
6125 // w=weight[i] = (63*qns + (w/2)) / w;
6131 lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
6137 for(i=start_i; i<=last_non_zero; i++){
6138 int j= perm_scantable[i];
6139 const int level= block[j];
6143 if(level<0) coeff= qmul*level - qadd;
6144 else coeff= qmul*level + qadd;
6145 run_tab[rle_index++]=run;
6148 s->dsp.add_8x8basis(rem, basis[j], coeff);
6154 if(last_non_zero>0){
6155 STOP_TIMER("init rem[]")
6162 int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
6165 int run2, best_unquant_change=0, analyze_gradient;
6169 analyze_gradient = last_non_zero > 2 || s->avctx->quantizer_noise_shaping >= 3;
6171 if(analyze_gradient){
6175 for(i=0; i<64; i++){
6178 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
6181 STOP_TIMER("rem*w*w")}
6191 const int level= block[0];
6192 int change, old_coeff;
6194 assert(s->mb_intra);
6198 for(change=-1; change<=1; change+=2){
6199 int new_level= level + change;
6200 int score, new_coeff;
6202 new_coeff= q*new_level;
6203 if(new_coeff >= 2048 || new_coeff < 0)
6206 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
6207 if(score<best_score){
6210 best_change= change;
6211 best_unquant_change= new_coeff - old_coeff;
6218 run2= run_tab[rle_index++];
6222 for(i=start_i; i<64; i++){
6223 int j= perm_scantable[i];
6224 const int level= block[j];
6225 int change, old_coeff;
6227 if(s->avctx->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
6231 if(level<0) old_coeff= qmul*level - qadd;
6232 else old_coeff= qmul*level + qadd;
6233 run2= run_tab[rle_index++]; //FIXME ! maybe after last
6237 assert(run2>=0 || i >= last_non_zero );
6240 for(change=-1; change<=1; change+=2){
6241 int new_level= level + change;
6242 int score, new_coeff, unquant_change;
6245 if(s->avctx->quantizer_noise_shaping < 2 && ABS(new_level) > ABS(level))
6249 if(new_level<0) new_coeff= qmul*new_level - qadd;
6250 else new_coeff= qmul*new_level + qadd;
6251 if(new_coeff >= 2048 || new_coeff <= -2048)
6253 //FIXME check for overflow
6256 if(level < 63 && level > -63){
6257 if(i < last_non_zero)
6258 score += length[UNI_AC_ENC_INDEX(run, new_level+64)]
6259 - length[UNI_AC_ENC_INDEX(run, level+64)];
6261 score += last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
6262 - last_length[UNI_AC_ENC_INDEX(run, level+64)];
6265 assert(ABS(new_level)==1);
6267 if(analyze_gradient){
6268 int g= d1[ scantable[i] ];
6269 if(g && (g^new_level) >= 0)
6273 if(i < last_non_zero){
6274 int next_i= i + run2 + 1;
6275 int next_level= block[ perm_scantable[next_i] ] + 64;
6277 if(next_level&(~127))
6280 if(next_i < last_non_zero)
6281 score += length[UNI_AC_ENC_INDEX(run, 65)]
6282 + length[UNI_AC_ENC_INDEX(run2, next_level)]
6283 - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
6285 score += length[UNI_AC_ENC_INDEX(run, 65)]
6286 + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
6287 - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
6289 score += last_length[UNI_AC_ENC_INDEX(run, 65)];
6291 score += length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
6292 - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
6298 assert(ABS(level)==1);
6300 if(i < last_non_zero){
6301 int next_i= i + run2 + 1;
6302 int next_level= block[ perm_scantable[next_i] ] + 64;
6304 if(next_level&(~127))
6307 if(next_i < last_non_zero)
6308 score += length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
6309 - length[UNI_AC_ENC_INDEX(run2, next_level)]
6310 - length[UNI_AC_ENC_INDEX(run, 65)];
6312 score += last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
6313 - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
6314 - length[UNI_AC_ENC_INDEX(run, 65)];
6316 score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
6318 score += last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
6319 - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
6326 unquant_change= new_coeff - old_coeff;
6327 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
6329 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
6330 if(score<best_score){
6333 best_change= change;
6334 best_unquant_change= unquant_change;
6338 prev_level= level + 64;
6339 if(prev_level&(~127))
6348 STOP_TIMER("iterative step")}
6352 int j= perm_scantable[ best_coeff ];
6354 block[j] += best_change;
6356 if(best_coeff > last_non_zero){
6357 last_non_zero= best_coeff;
6365 if(block[j] - best_change){
6366 if(ABS(block[j]) > ABS(block[j] - best_change)){
6378 for(; last_non_zero>=start_i; last_non_zero--){
6379 if(block[perm_scantable[last_non_zero]])
6385 if(256*256*256*64 % count == 0){
6386 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);
6391 for(i=start_i; i<=last_non_zero; i++){
6392 int j= perm_scantable[i];
6393 const int level= block[j];
6396 run_tab[rle_index++]=run;
6403 s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
6409 if(last_non_zero>0){
6410 STOP_TIMER("iterative search")
6415 return last_non_zero;
6418 static int dct_quantize_c(MpegEncContext *s,
6419 DCTELEM *block, int n,
6420 int qscale, int *overflow)
6422 int i, j, level, last_non_zero, q, start_i;
6424 const uint8_t *scantable= s->intra_scantable.scantable;
6427 unsigned int threshold1, threshold2;
6429 s->dsp.fdct (block);
6431 if(s->dct_error_sum)
6432 s->denoise_dct(s, block);
6442 /* For AIC we skip quant/dequant of INTRADC */
6445 /* note: block[0] is assumed to be positive */
6446 block[0] = (block[0] + (q >> 1)) / q;
6449 qmat = s->q_intra_matrix[qscale];
6450 bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
6454 qmat = s->q_inter_matrix[qscale];
6455 bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
6457 threshold1= (1<<QMAT_SHIFT) - bias - 1;
6458 threshold2= (threshold1<<1);
6459 for(i=63;i>=start_i;i--) {
6461 level = block[j] * qmat[j];
6463 if(((unsigned)(level+threshold1))>threshold2){
6470 for(i=start_i; i<=last_non_zero; i++) {
6472 level = block[j] * qmat[j];
6474 // if( bias+level >= (1<<QMAT_SHIFT)
6475 // || bias-level >= (1<<QMAT_SHIFT)){
6476 if(((unsigned)(level+threshold1))>threshold2){
6478 level= (bias + level)>>QMAT_SHIFT;
6481 level= (bias - level)>>QMAT_SHIFT;
6489 *overflow= s->max_qcoeff < max; //overflow might have happened
6491 /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
6492 if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
6493 ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
6495 return last_non_zero;
6498 #endif //CONFIG_ENCODERS
6500 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
6501 DCTELEM *block, int n, int qscale)
6503 int i, level, nCoeffs;
6504 const uint16_t *quant_matrix;
6506 nCoeffs= s->block_last_index[n];
6509 block[0] = block[0] * s->y_dc_scale;
6511 block[0] = block[0] * s->c_dc_scale;
6512 /* XXX: only mpeg1 */
6513 quant_matrix = s->intra_matrix;
6514 for(i=1;i<=nCoeffs;i++) {
6515 int j= s->intra_scantable.permutated[i];
6520 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6521 level = (level - 1) | 1;
6524 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6525 level = (level - 1) | 1;
6532 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
6533 DCTELEM *block, int n, int qscale)
6535 int i, level, nCoeffs;
6536 const uint16_t *quant_matrix;
6538 nCoeffs= s->block_last_index[n];
6540 quant_matrix = s->inter_matrix;
6541 for(i=0; i<=nCoeffs; i++) {
6542 int j= s->intra_scantable.permutated[i];
6547 level = (((level << 1) + 1) * qscale *
6548 ((int) (quant_matrix[j]))) >> 4;
6549 level = (level - 1) | 1;
6552 level = (((level << 1) + 1) * qscale *
6553 ((int) (quant_matrix[j]))) >> 4;
6554 level = (level - 1) | 1;
6561 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
6562 DCTELEM *block, int n, int qscale)
6564 int i, level, nCoeffs;
6565 const uint16_t *quant_matrix;
6567 if(s->alternate_scan) nCoeffs= 63;
6568 else nCoeffs= s->block_last_index[n];
6571 block[0] = block[0] * s->y_dc_scale;
6573 block[0] = block[0] * s->c_dc_scale;
6574 quant_matrix = s->intra_matrix;
6575 for(i=1;i<=nCoeffs;i++) {
6576 int j= s->intra_scantable.permutated[i];
6581 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6584 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6591 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
6592 DCTELEM *block, int n, int qscale)
6594 int i, level, nCoeffs;
6595 const uint16_t *quant_matrix;
6598 if(s->alternate_scan) nCoeffs= 63;
6599 else nCoeffs= s->block_last_index[n];
6602 block[0] = block[0] * s->y_dc_scale;
6604 block[0] = block[0] * s->c_dc_scale;
6605 quant_matrix = s->intra_matrix;
6606 for(i=1;i<=nCoeffs;i++) {
6607 int j= s->intra_scantable.permutated[i];
6612 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6615 level = (int)(level * qscale * quant_matrix[j]) >> 3;
6624 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
6625 DCTELEM *block, int n, int qscale)
6627 int i, level, nCoeffs;
6628 const uint16_t *quant_matrix;
6631 if(s->alternate_scan) nCoeffs= 63;
6632 else nCoeffs= s->block_last_index[n];
6634 quant_matrix = s->inter_matrix;
6635 for(i=0; i<=nCoeffs; i++) {
6636 int j= s->intra_scantable.permutated[i];
6641 level = (((level << 1) + 1) * qscale *
6642 ((int) (quant_matrix[j]))) >> 4;
6645 level = (((level << 1) + 1) * qscale *
6646 ((int) (quant_matrix[j]))) >> 4;
6655 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
6656 DCTELEM *block, int n, int qscale)
6658 int i, level, qmul, qadd;
6661 assert(s->block_last_index[n]>=0);
6667 block[0] = block[0] * s->y_dc_scale;
6669 block[0] = block[0] * s->c_dc_scale;
6670 qadd = (qscale - 1) | 1;
6677 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6679 for(i=1; i<=nCoeffs; i++) {
6683 level = level * qmul - qadd;
6685 level = level * qmul + qadd;
6692 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
6693 DCTELEM *block, int n, int qscale)
6695 int i, level, qmul, qadd;
6698 assert(s->block_last_index[n]>=0);
6700 qadd = (qscale - 1) | 1;
6703 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
6705 for(i=0; i<=nCoeffs; i++) {
6709 level = level * qmul - qadd;
6711 level = level * qmul + qadd;
6718 #ifdef CONFIG_ENCODERS
6719 AVCodec h263_encoder = {
6723 sizeof(MpegEncContext),
6727 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6730 AVCodec h263p_encoder = {
6734 sizeof(MpegEncContext),
6738 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6741 AVCodec flv_encoder = {
6745 sizeof(MpegEncContext),
6749 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6752 AVCodec rv10_encoder = {
6756 sizeof(MpegEncContext),
6760 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6763 AVCodec rv20_encoder = {
6767 sizeof(MpegEncContext),
6771 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6774 AVCodec mpeg4_encoder = {
6778 sizeof(MpegEncContext),
6782 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6783 .capabilities= CODEC_CAP_DELAY,
6786 AVCodec msmpeg4v1_encoder = {
6790 sizeof(MpegEncContext),
6794 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6797 AVCodec msmpeg4v2_encoder = {
6801 sizeof(MpegEncContext),
6805 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6808 AVCodec msmpeg4v3_encoder = {
6812 sizeof(MpegEncContext),
6816 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6819 AVCodec wmv1_encoder = {
6823 sizeof(MpegEncContext),
6827 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, -1},
6830 AVCodec mjpeg_encoder = {
6834 sizeof(MpegEncContext),
6838 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUVJ420P, -1},
6841 #endif //CONFIG_ENCODERS