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 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * @file libavcodec/mpegvideo.c
27 * The simplest mpeg encoder (well, it was the simplest!).
32 #include "mpegvideo.h"
33 #include "mpegvideo_common.h"
37 #include "xvmc_internal.h"
43 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
44 DCTELEM *block, int n, int qscale);
45 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
46 DCTELEM *block, int n, int qscale);
47 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
48 DCTELEM *block, int n, int qscale);
49 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
50 DCTELEM *block, int n, int qscale);
51 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
52 DCTELEM *block, int n, int qscale);
53 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
54 DCTELEM *block, int n, int qscale);
55 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
56 DCTELEM *block, int n, int qscale);
59 /* enable all paranoid tests for rounding, overflows, etc... */
65 static const uint8_t ff_default_chroma_qscale_table[32]={
66 // 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
67 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
70 const uint8_t ff_mpeg1_dc_scale_table[128]={
71 // 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
72 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
73 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
74 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
75 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
78 const enum PixelFormat ff_pixfmt_list_420[] = {
83 const enum PixelFormat ff_hwaccel_pixfmt_list_420[] = {
88 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
96 uint32_t tmp= *state << 8;
98 if(tmp == 0x100 || p==end)
103 if (p[-1] > 1 ) p+= 3;
104 else if(p[-2] ) p+= 2;
105 else if(p[-3]|(p[-1]-1)) p++;
118 /* init common dct for both encoder and decoder */
119 av_cold int ff_dct_common_init(MpegEncContext *s)
121 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
122 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
123 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
124 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
125 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
126 if(s->flags & CODEC_FLAG_BITEXACT)
127 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
128 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
131 MPV_common_init_mmx(s);
133 MPV_common_init_axp(s);
135 MPV_common_init_mlib(s);
137 MPV_common_init_mmi(s);
139 MPV_common_init_arm(s);
141 MPV_common_init_altivec(s);
143 MPV_common_init_bfin(s);
146 /* load & permutate scantables
147 note: only wmv uses different ones
149 if(s->alternate_scan){
150 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
151 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
153 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
154 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
156 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
157 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
162 void ff_copy_picture(Picture *dst, Picture *src){
164 dst->type= FF_BUFFER_TYPE_COPY;
168 * allocates a Picture
169 * The pixels are allocated/set by calling get_buffer() if shared=0
171 int alloc_picture(MpegEncContext *s, Picture *pic, int shared){
172 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
173 const int mb_array_size= s->mb_stride*s->mb_height;
174 const int b8_array_size= s->b8_stride*s->mb_height*2;
175 const int b4_array_size= s->b4_stride*s->mb_height*4;
180 assert(pic->data[0]);
181 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
182 pic->type= FF_BUFFER_TYPE_SHARED;
184 assert(!pic->data[0]);
186 r= s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
188 if(r<0 || !pic->age || !pic->type || !pic->data[0]){
189 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
193 if(s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])){
194 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
195 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
199 if(pic->linesize[1] != pic->linesize[2]){
200 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
201 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
205 s->linesize = pic->linesize[0];
206 s->uvlinesize= pic->linesize[1];
209 if(pic->qscale_table==NULL){
211 CHECKED_ALLOCZ(pic->mb_var , mb_array_size * sizeof(int16_t))
212 CHECKED_ALLOCZ(pic->mc_mb_var, mb_array_size * sizeof(int16_t))
213 CHECKED_ALLOCZ(pic->mb_mean , mb_array_size * sizeof(int8_t))
216 CHECKED_ALLOCZ(pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2) //the +2 is for the slice end check
217 CHECKED_ALLOCZ(pic->qscale_table , mb_array_size * sizeof(uint8_t))
218 CHECKED_ALLOCZ(pic->mb_type_base , (big_mb_num + s->mb_stride) * sizeof(uint32_t))
219 pic->mb_type= pic->mb_type_base + 2*s->mb_stride+1;
220 if(s->out_format == FMT_H264){
222 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t))
223 pic->motion_val[i]= pic->motion_val_base[i]+4;
224 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
226 pic->motion_subsample_log2= 2;
227 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
229 CHECKED_ALLOCZ(pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t))
230 pic->motion_val[i]= pic->motion_val_base[i]+4;
231 CHECKED_ALLOCZ(pic->ref_index[i], b8_array_size * sizeof(uint8_t))
233 pic->motion_subsample_log2= 3;
235 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
236 CHECKED_ALLOCZ(pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6)
238 pic->qstride= s->mb_stride;
239 CHECKED_ALLOCZ(pic->pan_scan , 1 * sizeof(AVPanScan))
242 /* It might be nicer if the application would keep track of these
243 * but it would require an API change. */
244 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
245 s->prev_pict_types[0]= s->dropable ? FF_B_TYPE : s->pict_type;
246 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == FF_B_TYPE)
247 pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
250 fail: //for the CHECKED_ALLOCZ macro
252 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
257 * deallocates a picture
259 static void free_picture(MpegEncContext *s, Picture *pic){
262 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
263 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
266 av_freep(&pic->mb_var);
267 av_freep(&pic->mc_mb_var);
268 av_freep(&pic->mb_mean);
269 av_freep(&pic->mbskip_table);
270 av_freep(&pic->qscale_table);
271 av_freep(&pic->mb_type_base);
272 av_freep(&pic->dct_coeff);
273 av_freep(&pic->pan_scan);
276 av_freep(&pic->motion_val_base[i]);
277 av_freep(&pic->ref_index[i]);
280 if(pic->type == FF_BUFFER_TYPE_SHARED){
289 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
292 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
293 CHECKED_ALLOCZ(s->allocated_edge_emu_buffer, (s->width+64)*2*21*2); //(width + edge + align)*interlaced*MBsize*tolerance
294 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
296 //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
297 CHECKED_ALLOCZ(s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t))
298 s->me.temp= s->me.scratchpad;
299 s->rd_scratchpad= s->me.scratchpad;
300 s->b_scratchpad= s->me.scratchpad;
301 s->obmc_scratchpad= s->me.scratchpad + 16;
303 CHECKED_ALLOCZ(s->me.map , ME_MAP_SIZE*sizeof(uint32_t))
304 CHECKED_ALLOCZ(s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t))
305 if(s->avctx->noise_reduction){
306 CHECKED_ALLOCZ(s->dct_error_sum, 2 * 64 * sizeof(int))
309 CHECKED_ALLOCZ(s->blocks, 64*12*2 * sizeof(DCTELEM))
310 s->block= s->blocks[0];
313 s->pblocks[i] = &s->block[i];
317 return -1; //free() through MPV_common_end()
320 static void free_duplicate_context(MpegEncContext *s){
323 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
324 av_freep(&s->me.scratchpad);
328 s->obmc_scratchpad= NULL;
330 av_freep(&s->dct_error_sum);
331 av_freep(&s->me.map);
332 av_freep(&s->me.score_map);
333 av_freep(&s->blocks);
337 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
338 #define COPY(a) bak->a= src->a
339 COPY(allocated_edge_emu_buffer);
340 COPY(edge_emu_buffer);
345 COPY(obmc_scratchpad);
352 COPY(me.map_generation);
360 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
363 //FIXME copy only needed parts
365 backup_duplicate_context(&bak, dst);
366 memcpy(dst, src, sizeof(MpegEncContext));
367 backup_duplicate_context(dst, &bak);
369 dst->pblocks[i] = &dst->block[i];
371 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
375 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
376 * the changed fields will not depend upon the prior state of the MpegEncContext.
378 void MPV_common_defaults(MpegEncContext *s){
380 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
381 s->chroma_qscale_table= ff_default_chroma_qscale_table;
382 s->progressive_frame= 1;
383 s->progressive_sequence= 1;
384 s->picture_structure= PICT_FRAME;
386 s->coded_picture_number = 0;
387 s->picture_number = 0;
388 s->input_picture_number = 0;
390 s->picture_in_gop_number = 0;
397 * sets the given MpegEncContext to defaults for decoding.
398 * the changed fields will not depend upon the prior state of the MpegEncContext.
400 void MPV_decode_defaults(MpegEncContext *s){
401 MPV_common_defaults(s);
405 * init common structure for both encoder and decoder.
406 * this assumes that some variables like width/height are already set
408 av_cold int MPV_common_init(MpegEncContext *s)
410 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
412 s->mb_height = (s->height + 15) / 16;
414 if(s->avctx->pix_fmt == PIX_FMT_NONE){
415 av_log(s->avctx, AV_LOG_ERROR, "decoding to PIX_FMT_NONE is not supported.\n");
419 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
420 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
424 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
427 dsputil_init(&s->dsp, s->avctx);
428 ff_dct_common_init(s);
430 s->flags= s->avctx->flags;
431 s->flags2= s->avctx->flags2;
433 s->mb_width = (s->width + 15) / 16;
434 s->mb_stride = s->mb_width + 1;
435 s->b8_stride = s->mb_width*2 + 1;
436 s->b4_stride = s->mb_width*4 + 1;
437 mb_array_size= s->mb_height * s->mb_stride;
438 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
440 /* set chroma shifts */
441 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
442 &(s->chroma_y_shift) );
444 /* set default edge pos, will be overriden in decode_header if needed */
445 s->h_edge_pos= s->mb_width*16;
446 s->v_edge_pos= s->mb_height*16;
448 s->mb_num = s->mb_width * s->mb_height;
453 s->block_wrap[3]= s->b8_stride;
455 s->block_wrap[5]= s->mb_stride;
457 y_size = s->b8_stride * (2 * s->mb_height + 1);
458 c_size = s->mb_stride * (s->mb_height + 1);
459 yc_size = y_size + 2 * c_size;
461 /* convert fourcc to upper case */
462 s->codec_tag= toupper( s->avctx->codec_tag &0xFF)
463 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
464 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
465 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
467 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
468 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
469 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
470 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
472 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
474 CHECKED_ALLOCZ(s->mb_index2xy, (s->mb_num+1)*sizeof(int)) //error ressilience code looks cleaner with this
475 for(y=0; y<s->mb_height; y++){
476 for(x=0; x<s->mb_width; x++){
477 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
480 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
483 /* Allocate MV tables */
484 CHECKED_ALLOCZ(s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
485 CHECKED_ALLOCZ(s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
486 CHECKED_ALLOCZ(s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
487 CHECKED_ALLOCZ(s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
488 CHECKED_ALLOCZ(s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
489 CHECKED_ALLOCZ(s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t))
490 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
491 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
492 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
493 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
494 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
495 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
497 if(s->msmpeg4_version){
498 CHECKED_ALLOCZ(s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int));
500 CHECKED_ALLOCZ(s->avctx->stats_out, 256);
502 /* Allocate MB type table */
503 CHECKED_ALLOCZ(s->mb_type , mb_array_size * sizeof(uint16_t)) //needed for encoding
505 CHECKED_ALLOCZ(s->lambda_table, mb_array_size * sizeof(int))
507 CHECKED_ALLOCZ(s->q_intra_matrix, 64*32 * sizeof(int))
508 CHECKED_ALLOCZ(s->q_inter_matrix, 64*32 * sizeof(int))
509 CHECKED_ALLOCZ(s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t))
510 CHECKED_ALLOCZ(s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t))
511 CHECKED_ALLOCZ(s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
512 CHECKED_ALLOCZ(s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*))
514 if(s->avctx->noise_reduction){
515 CHECKED_ALLOCZ(s->dct_offset, 2 * 64 * sizeof(uint16_t))
518 CHECKED_ALLOCZ(s->picture, MAX_PICTURE_COUNT * sizeof(Picture))
520 CHECKED_ALLOCZ(s->error_status_table, mb_array_size*sizeof(uint8_t))
522 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
523 /* interlaced direct mode decoding tables */
528 CHECKED_ALLOCZ(s->b_field_mv_table_base[i][j][k] , mv_table_size * 2 * sizeof(int16_t))
529 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
531 CHECKED_ALLOCZ(s->b_field_select_table[i][j] , mb_array_size * 2 * sizeof(uint8_t))
532 CHECKED_ALLOCZ(s->p_field_mv_table_base[i][j] , mv_table_size * 2 * sizeof(int16_t))
533 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
535 CHECKED_ALLOCZ(s->p_field_select_table[i] , mb_array_size * 2 * sizeof(uint8_t))
538 if (s->out_format == FMT_H263) {
540 CHECKED_ALLOCZ(s->ac_val_base, yc_size * sizeof(int16_t) * 16);
541 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
542 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
543 s->ac_val[2] = s->ac_val[1] + c_size;
546 CHECKED_ALLOCZ(s->coded_block_base, y_size);
547 s->coded_block= s->coded_block_base + s->b8_stride + 1;
549 /* cbp, ac_pred, pred_dir */
550 CHECKED_ALLOCZ(s->cbp_table , mb_array_size * sizeof(uint8_t))
551 CHECKED_ALLOCZ(s->pred_dir_table, mb_array_size * sizeof(uint8_t))
554 if (s->h263_pred || s->h263_plus || !s->encoding) {
556 //MN: we need these for error resilience of intra-frames
557 CHECKED_ALLOCZ(s->dc_val_base, yc_size * sizeof(int16_t));
558 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
559 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
560 s->dc_val[2] = s->dc_val[1] + c_size;
561 for(i=0;i<yc_size;i++)
562 s->dc_val_base[i] = 1024;
565 /* which mb is a intra block */
566 CHECKED_ALLOCZ(s->mbintra_table, mb_array_size);
567 memset(s->mbintra_table, 1, mb_array_size);
569 /* init macroblock skip table */
570 CHECKED_ALLOCZ(s->mbskip_table, mb_array_size+2);
571 //Note the +1 is for a quicker mpeg4 slice_end detection
572 CHECKED_ALLOCZ(s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
574 s->parse_context.state= -1;
575 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
576 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
577 s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
578 s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
581 s->context_initialized = 1;
583 s->thread_context[0]= s;
584 threads = s->avctx->thread_count;
586 for(i=1; i<threads; i++){
587 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
588 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
591 for(i=0; i<threads; i++){
592 if(init_duplicate_context(s->thread_context[i], s) < 0)
594 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
595 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
604 /* init common structure for both encoder and decoder */
605 void MPV_common_end(MpegEncContext *s)
609 for(i=0; i<s->avctx->thread_count; i++){
610 free_duplicate_context(s->thread_context[i]);
612 for(i=1; i<s->avctx->thread_count; i++){
613 av_freep(&s->thread_context[i]);
616 av_freep(&s->parse_context.buffer);
617 s->parse_context.buffer_size=0;
619 av_freep(&s->mb_type);
620 av_freep(&s->p_mv_table_base);
621 av_freep(&s->b_forw_mv_table_base);
622 av_freep(&s->b_back_mv_table_base);
623 av_freep(&s->b_bidir_forw_mv_table_base);
624 av_freep(&s->b_bidir_back_mv_table_base);
625 av_freep(&s->b_direct_mv_table_base);
627 s->b_forw_mv_table= NULL;
628 s->b_back_mv_table= NULL;
629 s->b_bidir_forw_mv_table= NULL;
630 s->b_bidir_back_mv_table= NULL;
631 s->b_direct_mv_table= NULL;
635 av_freep(&s->b_field_mv_table_base[i][j][k]);
636 s->b_field_mv_table[i][j][k]=NULL;
638 av_freep(&s->b_field_select_table[i][j]);
639 av_freep(&s->p_field_mv_table_base[i][j]);
640 s->p_field_mv_table[i][j]=NULL;
642 av_freep(&s->p_field_select_table[i]);
645 av_freep(&s->dc_val_base);
646 av_freep(&s->ac_val_base);
647 av_freep(&s->coded_block_base);
648 av_freep(&s->mbintra_table);
649 av_freep(&s->cbp_table);
650 av_freep(&s->pred_dir_table);
652 av_freep(&s->mbskip_table);
653 av_freep(&s->prev_pict_types);
654 av_freep(&s->bitstream_buffer);
655 s->allocated_bitstream_buffer_size=0;
657 av_freep(&s->avctx->stats_out);
658 av_freep(&s->ac_stats);
659 av_freep(&s->error_status_table);
660 av_freep(&s->mb_index2xy);
661 av_freep(&s->lambda_table);
662 av_freep(&s->q_intra_matrix);
663 av_freep(&s->q_inter_matrix);
664 av_freep(&s->q_intra_matrix16);
665 av_freep(&s->q_inter_matrix16);
666 av_freep(&s->input_picture);
667 av_freep(&s->reordered_input_picture);
668 av_freep(&s->dct_offset);
671 for(i=0; i<MAX_PICTURE_COUNT; i++){
672 free_picture(s, &s->picture[i]);
675 av_freep(&s->picture);
676 s->context_initialized = 0;
679 s->current_picture_ptr= NULL;
680 s->linesize= s->uvlinesize= 0;
683 av_freep(&s->visualization_buffer[i]);
685 avcodec_default_free_buffers(s->avctx);
688 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
690 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
691 uint8_t index_run[MAX_RUN+1];
692 int last, run, level, start, end, i;
694 /* If table is static, we can quit if rl->max_level[0] is not NULL */
695 if(static_store && rl->max_level[0])
698 /* compute max_level[], max_run[] and index_run[] */
699 for(last=0;last<2;last++) {
708 memset(max_level, 0, MAX_RUN + 1);
709 memset(max_run, 0, MAX_LEVEL + 1);
710 memset(index_run, rl->n, MAX_RUN + 1);
711 for(i=start;i<end;i++) {
712 run = rl->table_run[i];
713 level = rl->table_level[i];
714 if (index_run[run] == rl->n)
716 if (level > max_level[run])
717 max_level[run] = level;
718 if (run > max_run[level])
719 max_run[level] = run;
722 rl->max_level[last] = static_store[last];
724 rl->max_level[last] = av_malloc(MAX_RUN + 1);
725 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
727 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
729 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
730 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
732 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
734 rl->index_run[last] = av_malloc(MAX_RUN + 1);
735 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
739 void init_vlc_rl(RLTable *rl)
751 for(i=0; i<rl->vlc.table_size; i++){
752 int code= rl->vlc.table[i][0];
753 int len = rl->vlc.table[i][1];
756 if(len==0){ // illegal code
759 }else if(len<0){ //more bits needed
763 if(code==rl->n){ //esc
767 run= rl->table_run [code] + 1;
768 level= rl->table_level[code] * qmul + qadd;
769 if(code >= rl->last) run+=192;
772 rl->rl_vlc[q][i].len= len;
773 rl->rl_vlc[q][i].level= level;
774 rl->rl_vlc[q][i].run= run;
779 int ff_find_unused_picture(MpegEncContext *s, int shared){
783 for(i=0; i<MAX_PICTURE_COUNT; i++){
784 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
787 for(i=0; i<MAX_PICTURE_COUNT; i++){
788 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
790 for(i=0; i<MAX_PICTURE_COUNT; i++){
791 if(s->picture[i].data[0]==NULL) return i;
795 av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
796 /* We could return -1, but the codec would crash trying to draw into a
797 * non-existing frame anyway. This is safer than waiting for a random crash.
798 * Also the return of this is never useful, an encoder must only allocate
799 * as much as allowed in the specification. This has no relationship to how
800 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
801 * enough for such valid streams).
802 * Plus, a decoder has to check stream validity and remove frames if too
803 * many reference frames are around. Waiting for "OOM" is not correct at
804 * all. Similarly, missing reference frames have to be replaced by
805 * interpolated/MC frames, anything else is a bug in the codec ...
811 static void update_noise_reduction(MpegEncContext *s){
814 for(intra=0; intra<2; intra++){
815 if(s->dct_count[intra] > (1<<16)){
817 s->dct_error_sum[intra][i] >>=1;
819 s->dct_count[intra] >>= 1;
823 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);
829 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
831 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
837 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
839 /* mark&release old frames */
840 if (s->pict_type != FF_B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
841 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
842 avctx->release_buffer(avctx, (AVFrame*)s->last_picture_ptr);
844 /* release forgotten pictures */
845 /* if(mpeg124/h263) */
847 for(i=0; i<MAX_PICTURE_COUNT; i++){
848 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
849 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
850 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
858 /* release non reference frames */
859 for(i=0; i<MAX_PICTURE_COUNT; i++){
860 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
861 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
865 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
866 pic= (AVFrame*)s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
868 i= ff_find_unused_picture(s, 0);
869 pic= (AVFrame*)&s->picture[i];
874 if (s->codec_id == CODEC_ID_H264)
875 pic->reference = s->picture_structure;
876 else if (s->pict_type != FF_B_TYPE)
880 pic->coded_picture_number= s->coded_picture_number++;
882 if( alloc_picture(s, (Picture*)pic, 0) < 0)
885 s->current_picture_ptr= (Picture*)pic;
886 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
887 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
890 s->current_picture_ptr->pict_type= s->pict_type;
891 // if(s->flags && CODEC_FLAG_QSCALE)
892 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
893 s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
895 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
897 if (s->pict_type != FF_B_TYPE) {
898 s->last_picture_ptr= s->next_picture_ptr;
900 s->next_picture_ptr= s->current_picture_ptr;
902 /* 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,
903 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
904 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
905 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
906 s->pict_type, s->dropable);*/
908 if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
909 if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
911 if(s->pict_type != FF_I_TYPE && (s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && !s->dropable && s->codec_id != CODEC_ID_H264){
912 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
913 assert(s->pict_type != FF_B_TYPE); //these should have been dropped if we don't have a reference
917 assert(s->pict_type == FF_I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
919 if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
922 if(s->picture_structure == PICT_BOTTOM_FIELD){
923 s->current_picture.data[i] += s->current_picture.linesize[i];
925 s->current_picture.linesize[i] *= 2;
926 s->last_picture.linesize[i] *=2;
927 s->next_picture.linesize[i] *=2;
931 s->hurry_up= s->avctx->hurry_up;
932 s->error_recognition= avctx->error_recognition;
934 /* set dequantizer, we can't do it during init as it might change for mpeg4
935 and we can't do it in the header decode as init is not called for mpeg4 there yet */
936 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
937 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
938 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
939 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
940 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
941 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
943 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
944 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
947 if(s->dct_error_sum){
948 assert(s->avctx->noise_reduction && s->encoding);
950 update_noise_reduction(s);
953 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
954 return ff_xvmc_field_start(s, avctx);
959 /* generic function for encode/decode called after a frame has been coded/decoded */
960 void MPV_frame_end(MpegEncContext *s)
963 /* draw edge for correct motion prediction if outside */
964 //just to make sure that all data is rendered.
965 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
966 ff_xvmc_field_end(s);
967 }else if(!s->avctx->hwaccel
968 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
969 && s->unrestricted_mv
970 && s->current_picture.reference
972 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
973 s->dsp.draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
974 s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
975 s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
979 s->last_pict_type = s->pict_type;
980 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
981 if(s->pict_type!=FF_B_TYPE){
982 s->last_non_b_pict_type= s->pict_type;
985 /* copy back current_picture variables */
986 for(i=0; i<MAX_PICTURE_COUNT; i++){
987 if(s->picture[i].data[0] == s->current_picture.data[0]){
988 s->picture[i]= s->current_picture;
992 assert(i<MAX_PICTURE_COUNT);
996 /* release non-reference frames */
997 for(i=0; i<MAX_PICTURE_COUNT; i++){
998 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
999 s->avctx->release_buffer(s->avctx, (AVFrame*)&s->picture[i]);
1003 // clear copies, to avoid confusion
1005 memset(&s->last_picture, 0, sizeof(Picture));
1006 memset(&s->next_picture, 0, sizeof(Picture));
1007 memset(&s->current_picture, 0, sizeof(Picture));
1009 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1013 * draws an line from (ex, ey) -> (sx, sy).
1014 * @param w width of the image
1015 * @param h height of the image
1016 * @param stride stride/linesize of the image
1017 * @param color color of the arrow
1019 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1022 sx= av_clip(sx, 0, w-1);
1023 sy= av_clip(sy, 0, h-1);
1024 ex= av_clip(ex, 0, w-1);
1025 ey= av_clip(ey, 0, h-1);
1027 buf[sy*stride + sx]+= color;
1029 if(FFABS(ex - sx) > FFABS(ey - sy)){
1031 FFSWAP(int, sx, ex);
1032 FFSWAP(int, sy, ey);
1034 buf+= sx + sy*stride;
1036 f= ((ey-sy)<<16)/ex;
1037 for(x= 0; x <= ex; x++){
1040 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1041 buf[(y+1)*stride + x]+= (color* fr )>>16;
1045 FFSWAP(int, sx, ex);
1046 FFSWAP(int, sy, ey);
1048 buf+= sx + sy*stride;
1050 if(ey) f= ((ex-sx)<<16)/ey;
1052 for(y= 0; y <= ey; y++){
1055 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1056 buf[y*stride + x+1]+= (color* fr )>>16;
1062 * draws an arrow from (ex, ey) -> (sx, sy).
1063 * @param w width of the image
1064 * @param h height of the image
1065 * @param stride stride/linesize of the image
1066 * @param color color of the arrow
1068 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1071 sx= av_clip(sx, -100, w+100);
1072 sy= av_clip(sy, -100, h+100);
1073 ex= av_clip(ex, -100, w+100);
1074 ey= av_clip(ey, -100, h+100);
1079 if(dx*dx + dy*dy > 3*3){
1082 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1084 //FIXME subpixel accuracy
1085 rx= ROUNDED_DIV(rx*3<<4, length);
1086 ry= ROUNDED_DIV(ry*3<<4, length);
1088 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1089 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1091 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1095 * prints debuging info for the given picture.
1097 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1099 if(!pict || !pict->mb_type) return;
1101 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1104 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1105 switch (pict->pict_type) {
1106 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1107 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1108 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1109 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1110 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1111 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1113 for(y=0; y<s->mb_height; y++){
1114 for(x=0; x<s->mb_width; x++){
1115 if(s->avctx->debug&FF_DEBUG_SKIP){
1116 int count= s->mbskip_table[x + y*s->mb_stride];
1117 if(count>9) count=9;
1118 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1120 if(s->avctx->debug&FF_DEBUG_QP){
1121 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1123 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1124 int mb_type= pict->mb_type[x + y*s->mb_stride];
1125 //Type & MV direction
1127 av_log(s->avctx, AV_LOG_DEBUG, "P");
1128 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1129 av_log(s->avctx, AV_LOG_DEBUG, "A");
1130 else if(IS_INTRA4x4(mb_type))
1131 av_log(s->avctx, AV_LOG_DEBUG, "i");
1132 else if(IS_INTRA16x16(mb_type))
1133 av_log(s->avctx, AV_LOG_DEBUG, "I");
1134 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1135 av_log(s->avctx, AV_LOG_DEBUG, "d");
1136 else if(IS_DIRECT(mb_type))
1137 av_log(s->avctx, AV_LOG_DEBUG, "D");
1138 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1139 av_log(s->avctx, AV_LOG_DEBUG, "g");
1140 else if(IS_GMC(mb_type))
1141 av_log(s->avctx, AV_LOG_DEBUG, "G");
1142 else if(IS_SKIP(mb_type))
1143 av_log(s->avctx, AV_LOG_DEBUG, "S");
1144 else if(!USES_LIST(mb_type, 1))
1145 av_log(s->avctx, AV_LOG_DEBUG, ">");
1146 else if(!USES_LIST(mb_type, 0))
1147 av_log(s->avctx, AV_LOG_DEBUG, "<");
1149 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1150 av_log(s->avctx, AV_LOG_DEBUG, "X");
1155 av_log(s->avctx, AV_LOG_DEBUG, "+");
1156 else if(IS_16X8(mb_type))
1157 av_log(s->avctx, AV_LOG_DEBUG, "-");
1158 else if(IS_8X16(mb_type))
1159 av_log(s->avctx, AV_LOG_DEBUG, "|");
1160 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1161 av_log(s->avctx, AV_LOG_DEBUG, " ");
1163 av_log(s->avctx, AV_LOG_DEBUG, "?");
1166 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1167 av_log(s->avctx, AV_LOG_DEBUG, "=");
1169 av_log(s->avctx, AV_LOG_DEBUG, " ");
1171 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1173 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1177 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1178 const int shift= 1 + s->quarter_sample;
1182 int h_chroma_shift, v_chroma_shift, block_height;
1183 const int width = s->avctx->width;
1184 const int height= s->avctx->height;
1185 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1186 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1187 s->low_delay=0; //needed to see the vectors without trashing the buffers
1189 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1191 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1192 pict->data[i]= s->visualization_buffer[i];
1194 pict->type= FF_BUFFER_TYPE_COPY;
1196 block_height = 16>>v_chroma_shift;
1198 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1200 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1201 const int mb_index= mb_x + mb_y*s->mb_stride;
1202 if((s->avctx->debug_mv) && pict->motion_val){
1204 for(type=0; type<3; type++){
1207 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1211 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1215 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1220 if(!USES_LIST(pict->mb_type[mb_index], direction))
1223 if(IS_8X8(pict->mb_type[mb_index])){
1226 int sx= mb_x*16 + 4 + 8*(i&1);
1227 int sy= mb_y*16 + 4 + 8*(i>>1);
1228 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1229 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1230 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1231 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1233 }else if(IS_16X8(pict->mb_type[mb_index])){
1237 int sy=mb_y*16 + 4 + 8*i;
1238 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1239 int mx=(pict->motion_val[direction][xy][0]>>shift);
1240 int my=(pict->motion_val[direction][xy][1]>>shift);
1242 if(IS_INTERLACED(pict->mb_type[mb_index]))
1245 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1247 }else if(IS_8X16(pict->mb_type[mb_index])){
1250 int sx=mb_x*16 + 4 + 8*i;
1252 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1253 int mx=(pict->motion_val[direction][xy][0]>>shift);
1254 int my=(pict->motion_val[direction][xy][1]>>shift);
1256 if(IS_INTERLACED(pict->mb_type[mb_index]))
1259 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1262 int sx= mb_x*16 + 8;
1263 int sy= mb_y*16 + 8;
1264 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1265 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1266 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1267 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1271 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1272 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1274 for(y=0; y<block_height; y++){
1275 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1276 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1279 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1280 int mb_type= pict->mb_type[mb_index];
1283 #define COLOR(theta, r)\
1284 u= (int)(128 + r*cos(theta*3.141592/180));\
1285 v= (int)(128 + r*sin(theta*3.141592/180));
1289 if(IS_PCM(mb_type)){
1291 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1293 }else if(IS_INTRA4x4(mb_type)){
1295 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1297 }else if(IS_DIRECT(mb_type)){
1299 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1301 }else if(IS_GMC(mb_type)){
1303 }else if(IS_SKIP(mb_type)){
1305 }else if(!USES_LIST(mb_type, 1)){
1307 }else if(!USES_LIST(mb_type, 0)){
1310 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1314 u*= 0x0101010101010101ULL;
1315 v*= 0x0101010101010101ULL;
1316 for(y=0; y<block_height; y++){
1317 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1318 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1322 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1323 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1324 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1326 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1328 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1330 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1331 int dm= 1 << (mv_sample_log2-2);
1333 int sx= mb_x*16 + 8*(i&1);
1334 int sy= mb_y*16 + 8*(i>>1);
1335 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1337 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1338 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1340 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1341 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1342 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1346 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1350 s->mbskip_table[mb_index]=0;
1356 static inline int hpel_motion_lowres(MpegEncContext *s,
1357 uint8_t *dest, uint8_t *src,
1358 int field_based, int field_select,
1359 int src_x, int src_y,
1360 int width, int height, int stride,
1361 int h_edge_pos, int v_edge_pos,
1362 int w, int h, h264_chroma_mc_func *pix_op,
1363 int motion_x, int motion_y)
1365 const int lowres= s->avctx->lowres;
1366 const int s_mask= (2<<lowres)-1;
1370 if(s->quarter_sample){
1375 sx= motion_x & s_mask;
1376 sy= motion_y & s_mask;
1377 src_x += motion_x >> (lowres+1);
1378 src_y += motion_y >> (lowres+1);
1380 src += src_y * stride + src_x;
1382 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1383 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1384 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1385 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1386 src= s->edge_emu_buffer;
1394 pix_op[lowres](dest, src, stride, h, sx, sy);
1398 /* apply one mpeg motion vector to the three components */
1399 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1400 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1401 int field_based, int bottom_field, int field_select,
1402 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1403 int motion_x, int motion_y, int h)
1405 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1406 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1407 const int lowres= s->avctx->lowres;
1408 const int block_s= 8>>lowres;
1409 const int s_mask= (2<<lowres)-1;
1410 const int h_edge_pos = s->h_edge_pos >> lowres;
1411 const int v_edge_pos = s->v_edge_pos >> lowres;
1412 linesize = s->current_picture.linesize[0] << field_based;
1413 uvlinesize = s->current_picture.linesize[1] << field_based;
1415 if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1421 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1424 sx= motion_x & s_mask;
1425 sy= motion_y & s_mask;
1426 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1427 src_y =(s->mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1429 if (s->out_format == FMT_H263) {
1430 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1431 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1434 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1437 uvsx = (2*mx) & s_mask;
1438 uvsy = (2*my) & s_mask;
1439 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1440 uvsrc_y = s->mb_y*block_s + (my >> lowres);
1446 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1447 uvsrc_y =(s->mb_y*block_s>>field_based) + (my >> (lowres+1));
1450 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1451 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1452 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1454 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1455 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1456 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1457 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1458 ptr_y = s->edge_emu_buffer;
1459 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1460 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1461 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1462 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1463 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1464 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1470 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1471 dest_y += s->linesize;
1472 dest_cb+= s->uvlinesize;
1473 dest_cr+= s->uvlinesize;
1477 ptr_y += s->linesize;
1478 ptr_cb+= s->uvlinesize;
1479 ptr_cr+= s->uvlinesize;
1484 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1486 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1487 uvsx <<= 2 - lowres;
1488 uvsy <<= 2 - lowres;
1489 pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1490 pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1492 //FIXME h261 lowres loop filter
1495 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1496 uint8_t *dest_cb, uint8_t *dest_cr,
1497 uint8_t **ref_picture,
1498 h264_chroma_mc_func *pix_op,
1500 const int lowres= s->avctx->lowres;
1501 const int block_s= 8>>lowres;
1502 const int s_mask= (2<<lowres)-1;
1503 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1504 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1505 int emu=0, src_x, src_y, offset, sx, sy;
1508 if(s->quarter_sample){
1513 /* In case of 8X8, we construct a single chroma motion vector
1514 with a special rounding */
1515 mx= ff_h263_round_chroma(mx);
1516 my= ff_h263_round_chroma(my);
1520 src_x = s->mb_x*block_s + (mx >> (lowres+1));
1521 src_y = s->mb_y*block_s + (my >> (lowres+1));
1523 offset = src_y * s->uvlinesize + src_x;
1524 ptr = ref_picture[1] + offset;
1525 if(s->flags&CODEC_FLAG_EMU_EDGE){
1526 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1527 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1528 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1529 ptr= s->edge_emu_buffer;
1535 pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1537 ptr = ref_picture[2] + offset;
1539 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1540 ptr= s->edge_emu_buffer;
1542 pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1546 * motion compensation of a single macroblock
1548 * @param dest_y luma destination pointer
1549 * @param dest_cb chroma cb/u destination pointer
1550 * @param dest_cr chroma cr/v destination pointer
1551 * @param dir direction (0->forward, 1->backward)
1552 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1553 * @param pic_op halfpel motion compensation function (average or put normally)
1554 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1556 static inline void MPV_motion_lowres(MpegEncContext *s,
1557 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1558 int dir, uint8_t **ref_picture,
1559 h264_chroma_mc_func *pix_op)
1563 const int lowres= s->avctx->lowres;
1564 const int block_s= 8>>lowres;
1569 switch(s->mv_type) {
1571 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1573 ref_picture, pix_op,
1574 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1580 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1581 ref_picture[0], 0, 0,
1582 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1583 s->width, s->height, s->linesize,
1584 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1585 block_s, block_s, pix_op,
1586 s->mv[dir][i][0], s->mv[dir][i][1]);
1588 mx += s->mv[dir][i][0];
1589 my += s->mv[dir][i][1];
1592 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1593 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1596 if (s->picture_structure == PICT_FRAME) {
1598 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1599 1, 0, s->field_select[dir][0],
1600 ref_picture, pix_op,
1601 s->mv[dir][0][0], s->mv[dir][0][1], block_s);
1603 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1604 1, 1, s->field_select[dir][1],
1605 ref_picture, pix_op,
1606 s->mv[dir][1][0], s->mv[dir][1][1], block_s);
1608 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1609 ref_picture= s->current_picture_ptr->data;
1612 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1613 0, 0, s->field_select[dir][0],
1614 ref_picture, pix_op,
1615 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s);
1620 uint8_t ** ref2picture;
1622 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1623 ref2picture= ref_picture;
1625 ref2picture= s->current_picture_ptr->data;
1628 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1629 0, 0, s->field_select[dir][i],
1630 ref2picture, pix_op,
1631 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s);
1633 dest_y += 2*block_s*s->linesize;
1634 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1635 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1639 if(s->picture_structure == PICT_FRAME){
1643 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1645 ref_picture, pix_op,
1646 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s);
1648 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1652 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1653 0, 0, s->picture_structure != i+1,
1654 ref_picture, pix_op,
1655 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s);
1657 // after put we make avg of the same block
1658 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1660 //opposite parity is always in the same frame if this is second field
1661 if(!s->first_field){
1662 ref_picture = s->current_picture_ptr->data;
1671 /* put block[] to dest[] */
1672 static inline void put_dct(MpegEncContext *s,
1673 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1675 s->dct_unquantize_intra(s, block, i, qscale);
1676 s->dsp.idct_put (dest, line_size, block);
1679 /* add block[] to dest[] */
1680 static inline void add_dct(MpegEncContext *s,
1681 DCTELEM *block, int i, uint8_t *dest, int line_size)
1683 if (s->block_last_index[i] >= 0) {
1684 s->dsp.idct_add (dest, line_size, block);
1688 static inline void add_dequant_dct(MpegEncContext *s,
1689 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1691 if (s->block_last_index[i] >= 0) {
1692 s->dct_unquantize_inter(s, block, i, qscale);
1694 s->dsp.idct_add (dest, line_size, block);
1699 * cleans dc, ac, coded_block for the current non intra MB
1701 void ff_clean_intra_table_entries(MpegEncContext *s)
1703 int wrap = s->b8_stride;
1704 int xy = s->block_index[0];
1707 s->dc_val[0][xy + 1 ] =
1708 s->dc_val[0][xy + wrap] =
1709 s->dc_val[0][xy + 1 + wrap] = 1024;
1711 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1712 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1713 if (s->msmpeg4_version>=3) {
1714 s->coded_block[xy ] =
1715 s->coded_block[xy + 1 ] =
1716 s->coded_block[xy + wrap] =
1717 s->coded_block[xy + 1 + wrap] = 0;
1720 wrap = s->mb_stride;
1721 xy = s->mb_x + s->mb_y * wrap;
1723 s->dc_val[2][xy] = 1024;
1725 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1726 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1728 s->mbintra_table[xy]= 0;
1731 /* generic function called after a macroblock has been parsed by the
1732 decoder or after it has been encoded by the encoder.
1734 Important variables used:
1735 s->mb_intra : true if intra macroblock
1736 s->mv_dir : motion vector direction
1737 s->mv_type : motion vector type
1738 s->mv : motion vector
1739 s->interlaced_dct : true if interlaced dct used (mpeg2)
1741 static av_always_inline
1742 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1743 int lowres_flag, int is_mpeg12)
1746 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1747 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1748 ff_xvmc_decode_mb(s);//xvmc uses pblocks
1755 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1756 /* save DCT coefficients */
1758 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1761 *dct++ = block[i][s->dsp.idct_permutation[j]];
1764 s->current_picture.qscale_table[mb_xy]= s->qscale;
1766 /* update DC predictors for P macroblocks */
1768 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1769 if(s->mbintra_table[mb_xy])
1770 ff_clean_intra_table_entries(s);
1774 s->last_dc[2] = 128 << s->intra_dc_precision;
1777 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1778 s->mbintra_table[mb_xy]=1;
1780 if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==FF_B_TYPE) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
1781 uint8_t *dest_y, *dest_cb, *dest_cr;
1782 int dct_linesize, dct_offset;
1783 op_pixels_func (*op_pix)[4];
1784 qpel_mc_func (*op_qpix)[16];
1785 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1786 const int uvlinesize= s->current_picture.linesize[1];
1787 const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1788 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1790 /* avoid copy if macroblock skipped in last frame too */
1791 /* skip only during decoding as we might trash the buffers during encoding a bit */
1793 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1794 const int age= s->current_picture.age;
1798 if (s->mb_skipped) {
1800 assert(s->pict_type!=FF_I_TYPE);
1802 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1803 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1805 /* if previous was skipped too, then nothing to do ! */
1806 if (*mbskip_ptr >= age && s->current_picture.reference){
1809 } else if(!s->current_picture.reference){
1810 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1811 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1813 *mbskip_ptr = 0; /* not skipped */
1817 dct_linesize = linesize << s->interlaced_dct;
1818 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1822 dest_cb= s->dest[1];
1823 dest_cr= s->dest[2];
1825 dest_y = s->b_scratchpad;
1826 dest_cb= s->b_scratchpad+16*linesize;
1827 dest_cr= s->b_scratchpad+32*linesize;
1831 /* motion handling */
1832 /* decoding or more than one mb_type (MC was already done otherwise) */
1835 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1837 if (s->mv_dir & MV_DIR_FORWARD) {
1838 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1839 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1841 if (s->mv_dir & MV_DIR_BACKWARD) {
1842 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1845 op_qpix= s->me.qpel_put;
1846 if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1847 op_pix = s->dsp.put_pixels_tab;
1849 op_pix = s->dsp.put_no_rnd_pixels_tab;
1851 if (s->mv_dir & MV_DIR_FORWARD) {
1852 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1853 op_pix = s->dsp.avg_pixels_tab;
1854 op_qpix= s->me.qpel_avg;
1856 if (s->mv_dir & MV_DIR_BACKWARD) {
1857 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1862 /* skip dequant / idct if we are really late ;) */
1863 if(s->hurry_up>1) goto skip_idct;
1864 if(s->avctx->skip_idct){
1865 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1866 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1867 || s->avctx->skip_idct >= AVDISCARD_ALL)
1871 /* add dct residue */
1872 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1873 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1874 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1875 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1876 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1877 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1879 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1880 if (s->chroma_y_shift){
1881 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1882 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1886 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1887 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1888 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1889 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1892 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
1893 add_dct(s, block[0], 0, dest_y , dct_linesize);
1894 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
1895 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
1896 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1898 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1899 if(s->chroma_y_shift){//Chroma420
1900 add_dct(s, block[4], 4, dest_cb, uvlinesize);
1901 add_dct(s, block[5], 5, dest_cr, uvlinesize);
1904 dct_linesize = uvlinesize << s->interlaced_dct;
1905 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1907 add_dct(s, block[4], 4, dest_cb, dct_linesize);
1908 add_dct(s, block[5], 5, dest_cr, dct_linesize);
1909 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1910 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1911 if(!s->chroma_x_shift){//Chroma444
1912 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1913 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1914 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1915 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1920 else if (CONFIG_WMV2) {
1921 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1924 /* dct only in intra block */
1925 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1926 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1927 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1928 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1929 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1931 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1932 if(s->chroma_y_shift){
1933 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1934 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1938 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1939 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1940 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1941 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1945 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
1946 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
1947 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
1948 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1950 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1951 if(s->chroma_y_shift){
1952 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
1953 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
1956 dct_linesize = uvlinesize << s->interlaced_dct;
1957 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1959 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
1960 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
1961 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
1962 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
1963 if(!s->chroma_x_shift){//Chroma444
1964 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
1965 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
1966 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
1967 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
1975 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
1976 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
1977 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
1982 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
1984 if(s->out_format == FMT_MPEG1) {
1985 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
1986 else MPV_decode_mb_internal(s, block, 0, 1);
1989 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
1990 else MPV_decode_mb_internal(s, block, 0, 0);
1995 * @param h is the normal height, this will be reduced automatically if needed for the last row
1997 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
1998 if (s->avctx->draw_horiz_band) {
2002 if(s->picture_structure != PICT_FRAME){
2005 if(s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2008 h= FFMIN(h, s->avctx->height - y);
2010 if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2011 src= (AVFrame*)s->current_picture_ptr;
2012 else if(s->last_picture_ptr)
2013 src= (AVFrame*)s->last_picture_ptr;
2017 if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2023 offset[0]= y * s->linesize;
2025 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2031 s->avctx->draw_horiz_band(s->avctx, src, offset,
2032 y, s->picture_structure, h);
2036 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2037 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2038 const int uvlinesize= s->current_picture.linesize[1];
2039 const int mb_size= 4 - s->avctx->lowres;
2041 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2042 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2043 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2044 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2045 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2046 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;
2047 //block_index is not used by mpeg2, so it is not affected by chroma_format
2049 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2050 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2051 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2053 if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2055 s->dest[0] += s->mb_y * linesize << mb_size;
2056 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2057 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2061 void ff_mpeg_flush(AVCodecContext *avctx){
2063 MpegEncContext *s = avctx->priv_data;
2065 if(s==NULL || s->picture==NULL)
2068 for(i=0; i<MAX_PICTURE_COUNT; i++){
2069 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2070 || s->picture[i].type == FF_BUFFER_TYPE_USER))
2071 avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2073 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2075 s->mb_x= s->mb_y= 0;
2077 s->parse_context.state= -1;
2078 s->parse_context.frame_start_found= 0;
2079 s->parse_context.overread= 0;
2080 s->parse_context.overread_index= 0;
2081 s->parse_context.index= 0;
2082 s->parse_context.last_index= 0;
2083 s->bitstream_buffer_size=0;
2087 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2088 DCTELEM *block, int n, int qscale)
2090 int i, level, nCoeffs;
2091 const uint16_t *quant_matrix;
2093 nCoeffs= s->block_last_index[n];
2096 block[0] = block[0] * s->y_dc_scale;
2098 block[0] = block[0] * s->c_dc_scale;
2099 /* XXX: only mpeg1 */
2100 quant_matrix = s->intra_matrix;
2101 for(i=1;i<=nCoeffs;i++) {
2102 int j= s->intra_scantable.permutated[i];
2107 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2108 level = (level - 1) | 1;
2111 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2112 level = (level - 1) | 1;
2119 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2120 DCTELEM *block, int n, int qscale)
2122 int i, level, nCoeffs;
2123 const uint16_t *quant_matrix;
2125 nCoeffs= s->block_last_index[n];
2127 quant_matrix = s->inter_matrix;
2128 for(i=0; i<=nCoeffs; i++) {
2129 int j= s->intra_scantable.permutated[i];
2134 level = (((level << 1) + 1) * qscale *
2135 ((int) (quant_matrix[j]))) >> 4;
2136 level = (level - 1) | 1;
2139 level = (((level << 1) + 1) * qscale *
2140 ((int) (quant_matrix[j]))) >> 4;
2141 level = (level - 1) | 1;
2148 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2149 DCTELEM *block, int n, int qscale)
2151 int i, level, nCoeffs;
2152 const uint16_t *quant_matrix;
2154 if(s->alternate_scan) nCoeffs= 63;
2155 else nCoeffs= s->block_last_index[n];
2158 block[0] = block[0] * s->y_dc_scale;
2160 block[0] = block[0] * s->c_dc_scale;
2161 quant_matrix = s->intra_matrix;
2162 for(i=1;i<=nCoeffs;i++) {
2163 int j= s->intra_scantable.permutated[i];
2168 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2171 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2178 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2179 DCTELEM *block, int n, int qscale)
2181 int i, level, nCoeffs;
2182 const uint16_t *quant_matrix;
2185 if(s->alternate_scan) nCoeffs= 63;
2186 else nCoeffs= s->block_last_index[n];
2189 block[0] = block[0] * s->y_dc_scale;
2191 block[0] = block[0] * s->c_dc_scale;
2192 quant_matrix = s->intra_matrix;
2193 for(i=1;i<=nCoeffs;i++) {
2194 int j= s->intra_scantable.permutated[i];
2199 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2202 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2211 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2212 DCTELEM *block, int n, int qscale)
2214 int i, level, nCoeffs;
2215 const uint16_t *quant_matrix;
2218 if(s->alternate_scan) nCoeffs= 63;
2219 else nCoeffs= s->block_last_index[n];
2221 quant_matrix = s->inter_matrix;
2222 for(i=0; i<=nCoeffs; i++) {
2223 int j= s->intra_scantable.permutated[i];
2228 level = (((level << 1) + 1) * qscale *
2229 ((int) (quant_matrix[j]))) >> 4;
2232 level = (((level << 1) + 1) * qscale *
2233 ((int) (quant_matrix[j]))) >> 4;
2242 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2243 DCTELEM *block, int n, int qscale)
2245 int i, level, qmul, qadd;
2248 assert(s->block_last_index[n]>=0);
2254 block[0] = block[0] * s->y_dc_scale;
2256 block[0] = block[0] * s->c_dc_scale;
2257 qadd = (qscale - 1) | 1;
2264 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2266 for(i=1; i<=nCoeffs; i++) {
2270 level = level * qmul - qadd;
2272 level = level * qmul + qadd;
2279 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2280 DCTELEM *block, int n, int qscale)
2282 int i, level, qmul, qadd;
2285 assert(s->block_last_index[n]>=0);
2287 qadd = (qscale - 1) | 1;
2290 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2292 for(i=0; i<=nCoeffs; i++) {
2296 level = level * qmul - qadd;
2298 level = level * qmul + qadd;
2306 * set qscale and update qscale dependent variables.
2308 void ff_set_qscale(MpegEncContext * s, int qscale)
2312 else if (qscale > 31)
2316 s->chroma_qscale= s->chroma_qscale_table[qscale];
2318 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2319 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];