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[] = {
89 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
97 uint32_t tmp= *state << 8;
99 if(tmp == 0x100 || p==end)
104 if (p[-1] > 1 ) p+= 3;
105 else if(p[-2] ) p+= 2;
106 else if(p[-3]|(p[-1]-1)) p++;
119 /* init common dct for both encoder and decoder */
120 av_cold int ff_dct_common_init(MpegEncContext *s)
122 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
123 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
124 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
125 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
126 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
127 if(s->flags & CODEC_FLAG_BITEXACT)
128 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
129 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
132 MPV_common_init_mmx(s);
134 MPV_common_init_axp(s);
136 MPV_common_init_mlib(s);
138 MPV_common_init_mmi(s);
140 MPV_common_init_arm(s);
142 MPV_common_init_altivec(s);
144 MPV_common_init_bfin(s);
147 /* load & permutate scantables
148 note: only wmv uses different ones
150 if(s->alternate_scan){
151 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_alternate_vertical_scan);
152 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_alternate_vertical_scan);
154 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , ff_zigzag_direct);
155 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , ff_zigzag_direct);
157 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
158 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
163 void ff_copy_picture(Picture *dst, Picture *src){
165 dst->type= FF_BUFFER_TYPE_COPY;
169 * Releases a frame buffer
171 static void free_frame_buffer(MpegEncContext *s, Picture *pic)
173 s->avctx->release_buffer(s->avctx, (AVFrame*)pic);
174 av_freep(&pic->hwaccel_picture_private);
178 * Allocates a frame buffer
180 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
184 if (s->avctx->hwaccel) {
185 assert(!pic->hwaccel_picture_private);
186 if (s->avctx->hwaccel->priv_data_size) {
187 pic->hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
188 if (!pic->hwaccel_picture_private) {
189 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
195 r = s->avctx->get_buffer(s->avctx, (AVFrame*)pic);
197 if (r<0 || !pic->age || !pic->type || !pic->data[0]) {
198 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
199 av_freep(&pic->hwaccel_picture_private);
203 if (s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])) {
204 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
205 free_frame_buffer(s, pic);
209 if (pic->linesize[1] != pic->linesize[2]) {
210 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
211 free_frame_buffer(s, pic);
219 * allocates a Picture
220 * The pixels are allocated/set by calling get_buffer() if shared=0
222 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared){
223 const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
224 const int mb_array_size= s->mb_stride*s->mb_height;
225 const int b8_array_size= s->b8_stride*s->mb_height*2;
226 const int b4_array_size= s->b4_stride*s->mb_height*4;
231 assert(pic->data[0]);
232 assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
233 pic->type= FF_BUFFER_TYPE_SHARED;
235 assert(!pic->data[0]);
237 if (alloc_frame_buffer(s, pic) < 0)
240 s->linesize = pic->linesize[0];
241 s->uvlinesize= pic->linesize[1];
244 if(pic->qscale_table==NULL){
246 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var , mb_array_size * sizeof(int16_t) , fail)
247 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var, mb_array_size * sizeof(int16_t) , fail)
248 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean , mb_array_size * sizeof(int8_t ) , fail)
251 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2, fail) //the +2 is for the slice end check
252 FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table , mb_array_size * sizeof(uint8_t) , fail)
253 FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base , (big_mb_num + s->mb_stride) * sizeof(uint32_t), fail)
254 pic->mb_type= pic->mb_type_base + 2*s->mb_stride+1;
255 if(s->out_format == FMT_H264){
257 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i], 2 * (b4_array_size+4) * sizeof(int16_t), fail)
258 pic->motion_val[i]= pic->motion_val_base[i]+4;
259 FF_ALLOCZ_OR_GOTO(s->avctx, pic->ref_index[i], b8_array_size * sizeof(uint8_t), fail)
261 pic->motion_subsample_log2= 2;
262 }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
264 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t), fail)
265 pic->motion_val[i]= pic->motion_val_base[i]+4;
266 FF_ALLOCZ_OR_GOTO(s->avctx, pic->ref_index[i], b8_array_size * sizeof(uint8_t), fail)
268 pic->motion_subsample_log2= 3;
270 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
271 FF_ALLOCZ_OR_GOTO(s->avctx, pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6, fail)
273 pic->qstride= s->mb_stride;
274 FF_ALLOCZ_OR_GOTO(s->avctx, pic->pan_scan , 1 * sizeof(AVPanScan), fail)
277 /* It might be nicer if the application would keep track of these
278 * but it would require an API change. */
279 memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
280 s->prev_pict_types[0]= s->dropable ? FF_B_TYPE : s->pict_type;
281 if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == FF_B_TYPE)
282 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.
285 fail: //for the FF_ALLOCZ_OR_GOTO macro
287 free_frame_buffer(s, pic);
292 * deallocates a picture
294 static void free_picture(MpegEncContext *s, Picture *pic){
297 if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
298 free_frame_buffer(s, pic);
301 av_freep(&pic->mb_var);
302 av_freep(&pic->mc_mb_var);
303 av_freep(&pic->mb_mean);
304 av_freep(&pic->mbskip_table);
305 av_freep(&pic->qscale_table);
306 av_freep(&pic->mb_type_base);
307 av_freep(&pic->dct_coeff);
308 av_freep(&pic->pan_scan);
311 av_freep(&pic->motion_val_base[i]);
312 av_freep(&pic->ref_index[i]);
315 if(pic->type == FF_BUFFER_TYPE_SHARED){
324 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
327 // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
328 FF_ALLOCZ_OR_GOTO(s->avctx, s->allocated_edge_emu_buffer, (s->width+64)*2*21*2, fail); //(width + edge + align)*interlaced*MBsize*tolerance
329 s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
331 //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
332 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad, (s->width+64)*4*16*2*sizeof(uint8_t), fail)
333 s->me.temp= s->me.scratchpad;
334 s->rd_scratchpad= s->me.scratchpad;
335 s->b_scratchpad= s->me.scratchpad;
336 s->obmc_scratchpad= s->me.scratchpad + 16;
338 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map , ME_MAP_SIZE*sizeof(uint32_t), fail)
339 FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t), fail)
340 if(s->avctx->noise_reduction){
341 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum, 2 * 64 * sizeof(int), fail)
344 FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64*12*2 * sizeof(DCTELEM), fail)
345 s->block= s->blocks[0];
348 s->pblocks[i] = &s->block[i];
352 return -1; //free() through MPV_common_end()
355 static void free_duplicate_context(MpegEncContext *s){
358 av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
359 av_freep(&s->me.scratchpad);
363 s->obmc_scratchpad= NULL;
365 av_freep(&s->dct_error_sum);
366 av_freep(&s->me.map);
367 av_freep(&s->me.score_map);
368 av_freep(&s->blocks);
372 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
373 #define COPY(a) bak->a= src->a
374 COPY(allocated_edge_emu_buffer);
375 COPY(edge_emu_buffer);
380 COPY(obmc_scratchpad);
387 COPY(me.map_generation);
395 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
398 //FIXME copy only needed parts
400 backup_duplicate_context(&bak, dst);
401 memcpy(dst, src, sizeof(MpegEncContext));
402 backup_duplicate_context(dst, &bak);
404 dst->pblocks[i] = &dst->block[i];
406 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
410 * sets the given MpegEncContext to common defaults (same for encoding and decoding).
411 * the changed fields will not depend upon the prior state of the MpegEncContext.
413 void MPV_common_defaults(MpegEncContext *s){
415 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
416 s->chroma_qscale_table= ff_default_chroma_qscale_table;
417 s->progressive_frame= 1;
418 s->progressive_sequence= 1;
419 s->picture_structure= PICT_FRAME;
421 s->coded_picture_number = 0;
422 s->picture_number = 0;
423 s->input_picture_number = 0;
425 s->picture_in_gop_number = 0;
432 * sets the given MpegEncContext to defaults for decoding.
433 * the changed fields will not depend upon the prior state of the MpegEncContext.
435 void MPV_decode_defaults(MpegEncContext *s){
436 MPV_common_defaults(s);
440 * init common structure for both encoder and decoder.
441 * this assumes that some variables like width/height are already set
443 av_cold int MPV_common_init(MpegEncContext *s)
445 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
447 if(s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
448 s->mb_height = (s->height + 31) / 32 * 2;
450 s->mb_height = (s->height + 15) / 16;
452 if(s->avctx->pix_fmt == PIX_FMT_NONE){
453 av_log(s->avctx, AV_LOG_ERROR, "decoding to PIX_FMT_NONE is not supported.\n");
457 if(s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height)){
458 av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
462 if((s->width || s->height) && avcodec_check_dimensions(s->avctx, s->width, s->height))
465 dsputil_init(&s->dsp, s->avctx);
466 ff_dct_common_init(s);
468 s->flags= s->avctx->flags;
469 s->flags2= s->avctx->flags2;
471 s->mb_width = (s->width + 15) / 16;
472 s->mb_stride = s->mb_width + 1;
473 s->b8_stride = s->mb_width*2 + 1;
474 s->b4_stride = s->mb_width*4 + 1;
475 mb_array_size= s->mb_height * s->mb_stride;
476 mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
478 /* set chroma shifts */
479 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
480 &(s->chroma_y_shift) );
482 /* set default edge pos, will be overriden in decode_header if needed */
483 s->h_edge_pos= s->mb_width*16;
484 s->v_edge_pos= s->mb_height*16;
486 s->mb_num = s->mb_width * s->mb_height;
491 s->block_wrap[3]= s->b8_stride;
493 s->block_wrap[5]= s->mb_stride;
495 y_size = s->b8_stride * (2 * s->mb_height + 1);
496 c_size = s->mb_stride * (s->mb_height + 1);
497 yc_size = y_size + 2 * c_size;
499 /* convert fourcc to upper case */
500 s->codec_tag= toupper( s->avctx->codec_tag &0xFF)
501 + (toupper((s->avctx->codec_tag>>8 )&0xFF)<<8 )
502 + (toupper((s->avctx->codec_tag>>16)&0xFF)<<16)
503 + (toupper((s->avctx->codec_tag>>24)&0xFF)<<24);
505 s->stream_codec_tag= toupper( s->avctx->stream_codec_tag &0xFF)
506 + (toupper((s->avctx->stream_codec_tag>>8 )&0xFF)<<8 )
507 + (toupper((s->avctx->stream_codec_tag>>16)&0xFF)<<16)
508 + (toupper((s->avctx->stream_codec_tag>>24)&0xFF)<<24);
510 s->avctx->coded_frame= (AVFrame*)&s->current_picture;
512 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num+1)*sizeof(int), fail) //error ressilience code looks cleaner with this
513 for(y=0; y<s->mb_height; y++){
514 for(x=0; x<s->mb_width; x++){
515 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
518 s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
521 /* Allocate MV tables */
522 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
523 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
524 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
525 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
526 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
527 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
528 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1;
529 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1;
530 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1;
531 s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
532 s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
533 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1;
535 if(s->msmpeg4_version){
536 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
538 FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
540 /* Allocate MB type table */
541 FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
543 FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
545 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix , 64*32 * sizeof(int), fail)
546 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix , 64*32 * sizeof(int), fail)
547 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
548 FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t), fail)
549 FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
550 FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
552 if(s->avctx->noise_reduction){
553 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
556 FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, MAX_PICTURE_COUNT * sizeof(Picture), fail)
557 for(i = 0; i < MAX_PICTURE_COUNT; i++) {
558 avcodec_get_frame_defaults((AVFrame *)&s->picture[i]);
561 FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
563 if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
564 /* interlaced direct mode decoding tables */
569 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_mv_table_base[i][j][k], mv_table_size * 2 * sizeof(int16_t), fail)
570 s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
572 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
573 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
574 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]+ s->mb_stride + 1;
576 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
579 if (s->out_format == FMT_H263) {
581 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base, yc_size * sizeof(int16_t) * 16, fail);
582 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
583 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
584 s->ac_val[2] = s->ac_val[1] + c_size;
587 FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
588 s->coded_block= s->coded_block_base + s->b8_stride + 1;
590 /* cbp, ac_pred, pred_dir */
591 FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table , mb_array_size * sizeof(uint8_t), fail)
592 FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail)
595 if (s->h263_pred || s->h263_plus || !s->encoding) {
597 //MN: we need these for error resilience of intra-frames
598 FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
599 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
600 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
601 s->dc_val[2] = s->dc_val[1] + c_size;
602 for(i=0;i<yc_size;i++)
603 s->dc_val_base[i] = 1024;
606 /* which mb is a intra block */
607 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
608 memset(s->mbintra_table, 1, mb_array_size);
610 /* init macroblock skip table */
611 FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size+2, fail);
612 //Note the +1 is for a quicker mpeg4 slice_end detection
613 FF_ALLOCZ_OR_GOTO(s->avctx, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE, fail);
615 s->parse_context.state= -1;
616 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
617 s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
618 s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
619 s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
622 s->context_initialized = 1;
624 s->thread_context[0]= s;
625 threads = s->avctx->thread_count;
627 for(i=1; i<threads; i++){
628 s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
629 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
632 for(i=0; i<threads; i++){
633 if(init_duplicate_context(s->thread_context[i], s) < 0)
635 s->thread_context[i]->start_mb_y= (s->mb_height*(i ) + s->avctx->thread_count/2) / s->avctx->thread_count;
636 s->thread_context[i]->end_mb_y = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
645 /* init common structure for both encoder and decoder */
646 void MPV_common_end(MpegEncContext *s)
650 for(i=0; i<s->avctx->thread_count; i++){
651 free_duplicate_context(s->thread_context[i]);
653 for(i=1; i<s->avctx->thread_count; i++){
654 av_freep(&s->thread_context[i]);
657 av_freep(&s->parse_context.buffer);
658 s->parse_context.buffer_size=0;
660 av_freep(&s->mb_type);
661 av_freep(&s->p_mv_table_base);
662 av_freep(&s->b_forw_mv_table_base);
663 av_freep(&s->b_back_mv_table_base);
664 av_freep(&s->b_bidir_forw_mv_table_base);
665 av_freep(&s->b_bidir_back_mv_table_base);
666 av_freep(&s->b_direct_mv_table_base);
668 s->b_forw_mv_table= NULL;
669 s->b_back_mv_table= NULL;
670 s->b_bidir_forw_mv_table= NULL;
671 s->b_bidir_back_mv_table= NULL;
672 s->b_direct_mv_table= NULL;
676 av_freep(&s->b_field_mv_table_base[i][j][k]);
677 s->b_field_mv_table[i][j][k]=NULL;
679 av_freep(&s->b_field_select_table[i][j]);
680 av_freep(&s->p_field_mv_table_base[i][j]);
681 s->p_field_mv_table[i][j]=NULL;
683 av_freep(&s->p_field_select_table[i]);
686 av_freep(&s->dc_val_base);
687 av_freep(&s->ac_val_base);
688 av_freep(&s->coded_block_base);
689 av_freep(&s->mbintra_table);
690 av_freep(&s->cbp_table);
691 av_freep(&s->pred_dir_table);
693 av_freep(&s->mbskip_table);
694 av_freep(&s->prev_pict_types);
695 av_freep(&s->bitstream_buffer);
696 s->allocated_bitstream_buffer_size=0;
698 av_freep(&s->avctx->stats_out);
699 av_freep(&s->ac_stats);
700 av_freep(&s->error_status_table);
701 av_freep(&s->mb_index2xy);
702 av_freep(&s->lambda_table);
703 av_freep(&s->q_intra_matrix);
704 av_freep(&s->q_inter_matrix);
705 av_freep(&s->q_intra_matrix16);
706 av_freep(&s->q_inter_matrix16);
707 av_freep(&s->input_picture);
708 av_freep(&s->reordered_input_picture);
709 av_freep(&s->dct_offset);
712 for(i=0; i<MAX_PICTURE_COUNT; i++){
713 free_picture(s, &s->picture[i]);
716 av_freep(&s->picture);
717 s->context_initialized = 0;
720 s->current_picture_ptr= NULL;
721 s->linesize= s->uvlinesize= 0;
724 av_freep(&s->visualization_buffer[i]);
726 avcodec_default_free_buffers(s->avctx);
729 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
731 int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
732 uint8_t index_run[MAX_RUN+1];
733 int last, run, level, start, end, i;
735 /* If table is static, we can quit if rl->max_level[0] is not NULL */
736 if(static_store && rl->max_level[0])
739 /* compute max_level[], max_run[] and index_run[] */
740 for(last=0;last<2;last++) {
749 memset(max_level, 0, MAX_RUN + 1);
750 memset(max_run, 0, MAX_LEVEL + 1);
751 memset(index_run, rl->n, MAX_RUN + 1);
752 for(i=start;i<end;i++) {
753 run = rl->table_run[i];
754 level = rl->table_level[i];
755 if (index_run[run] == rl->n)
757 if (level > max_level[run])
758 max_level[run] = level;
759 if (run > max_run[level])
760 max_run[level] = run;
763 rl->max_level[last] = static_store[last];
765 rl->max_level[last] = av_malloc(MAX_RUN + 1);
766 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
768 rl->max_run[last] = static_store[last] + MAX_RUN + 1;
770 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
771 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
773 rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
775 rl->index_run[last] = av_malloc(MAX_RUN + 1);
776 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
780 void init_vlc_rl(RLTable *rl)
792 for(i=0; i<rl->vlc.table_size; i++){
793 int code= rl->vlc.table[i][0];
794 int len = rl->vlc.table[i][1];
797 if(len==0){ // illegal code
800 }else if(len<0){ //more bits needed
804 if(code==rl->n){ //esc
808 run= rl->table_run [code] + 1;
809 level= rl->table_level[code] * qmul + qadd;
810 if(code >= rl->last) run+=192;
813 rl->rl_vlc[q][i].len= len;
814 rl->rl_vlc[q][i].level= level;
815 rl->rl_vlc[q][i].run= run;
820 int ff_find_unused_picture(MpegEncContext *s, int shared){
824 for(i=0; i<MAX_PICTURE_COUNT; i++){
825 if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
828 for(i=0; i<MAX_PICTURE_COUNT; i++){
829 if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
831 for(i=0; i<MAX_PICTURE_COUNT; i++){
832 if(s->picture[i].data[0]==NULL) return i;
836 av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
837 /* We could return -1, but the codec would crash trying to draw into a
838 * non-existing frame anyway. This is safer than waiting for a random crash.
839 * Also the return of this is never useful, an encoder must only allocate
840 * as much as allowed in the specification. This has no relationship to how
841 * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
842 * enough for such valid streams).
843 * Plus, a decoder has to check stream validity and remove frames if too
844 * many reference frames are around. Waiting for "OOM" is not correct at
845 * all. Similarly, missing reference frames have to be replaced by
846 * interpolated/MC frames, anything else is a bug in the codec ...
852 static void update_noise_reduction(MpegEncContext *s){
855 for(intra=0; intra<2; intra++){
856 if(s->dct_count[intra] > (1<<16)){
858 s->dct_error_sum[intra][i] >>=1;
860 s->dct_count[intra] >>= 1;
864 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);
870 * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
872 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
878 assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
880 /* mark&release old frames */
881 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]) {
882 if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
883 free_frame_buffer(s, s->last_picture_ptr);
885 /* release forgotten pictures */
886 /* if(mpeg124/h263) */
888 for(i=0; i<MAX_PICTURE_COUNT; i++){
889 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
890 av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
891 free_frame_buffer(s, &s->picture[i]);
899 /* release non reference frames */
900 for(i=0; i<MAX_PICTURE_COUNT; i++){
901 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
902 free_frame_buffer(s, &s->picture[i]);
906 if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
907 pic= s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
909 i= ff_find_unused_picture(s, 0);
915 if (s->codec_id == CODEC_ID_H264)
916 pic->reference = s->picture_structure;
917 else if (s->pict_type != FF_B_TYPE)
921 pic->coded_picture_number= s->coded_picture_number++;
923 if(ff_alloc_picture(s, pic, 0) < 0)
926 s->current_picture_ptr= pic;
927 s->current_picture_ptr->top_field_first= s->top_field_first; //FIXME use only the vars from current_pic
928 s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
931 s->current_picture_ptr->pict_type= s->pict_type;
932 // if(s->flags && CODEC_FLAG_QSCALE)
933 // s->current_picture_ptr->quality= s->new_picture_ptr->quality;
934 s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
936 ff_copy_picture(&s->current_picture, s->current_picture_ptr);
938 if (s->pict_type != FF_B_TYPE) {
939 s->last_picture_ptr= s->next_picture_ptr;
941 s->next_picture_ptr= s->current_picture_ptr;
943 /* 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,
944 s->last_picture_ptr ? s->last_picture_ptr->data[0] : NULL,
945 s->next_picture_ptr ? s->next_picture_ptr->data[0] : NULL,
946 s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
947 s->pict_type, s->dropable);*/
949 if(s->codec_id != CODEC_ID_H264){
950 if((s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && s->pict_type!=FF_I_TYPE){
951 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
952 /* Allocate a dummy frame */
953 i= ff_find_unused_picture(s, 0);
954 s->last_picture_ptr= &s->picture[i];
955 if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
958 if((s->next_picture_ptr==NULL || s->next_picture_ptr->data[0]==NULL) && s->pict_type==FF_B_TYPE){
959 /* Allocate a dummy frame */
960 i= ff_find_unused_picture(s, 0);
961 s->next_picture_ptr= &s->picture[i];
962 if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
967 if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
968 if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
970 assert(s->pict_type == FF_I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
972 if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
975 if(s->picture_structure == PICT_BOTTOM_FIELD){
976 s->current_picture.data[i] += s->current_picture.linesize[i];
978 s->current_picture.linesize[i] *= 2;
979 s->last_picture.linesize[i] *=2;
980 s->next_picture.linesize[i] *=2;
984 s->hurry_up= s->avctx->hurry_up;
985 s->error_recognition= avctx->error_recognition;
987 /* set dequantizer, we can't do it during init as it might change for mpeg4
988 and we can't do it in the header decode as init is not called for mpeg4 there yet */
989 if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
990 s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
991 s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
992 }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
993 s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
994 s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
996 s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
997 s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1000 if(s->dct_error_sum){
1001 assert(s->avctx->noise_reduction && s->encoding);
1003 update_noise_reduction(s);
1006 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1007 return ff_xvmc_field_start(s, avctx);
1012 /* generic function for encode/decode called after a frame has been coded/decoded */
1013 void MPV_frame_end(MpegEncContext *s)
1016 /* draw edge for correct motion prediction if outside */
1017 //just to make sure that all data is rendered.
1018 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1019 ff_xvmc_field_end(s);
1020 }else if(!s->avctx->hwaccel
1021 && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1022 && s->unrestricted_mv
1023 && s->current_picture.reference
1025 && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1026 s->dsp.draw_edges(s->current_picture.data[0], s->linesize , s->h_edge_pos , s->v_edge_pos , EDGE_WIDTH );
1027 s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1028 s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1032 s->last_pict_type = s->pict_type;
1033 s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1034 if(s->pict_type!=FF_B_TYPE){
1035 s->last_non_b_pict_type= s->pict_type;
1038 /* copy back current_picture variables */
1039 for(i=0; i<MAX_PICTURE_COUNT; i++){
1040 if(s->picture[i].data[0] == s->current_picture.data[0]){
1041 s->picture[i]= s->current_picture;
1045 assert(i<MAX_PICTURE_COUNT);
1049 /* release non-reference frames */
1050 for(i=0; i<MAX_PICTURE_COUNT; i++){
1051 if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1052 free_frame_buffer(s, &s->picture[i]);
1056 // clear copies, to avoid confusion
1058 memset(&s->last_picture, 0, sizeof(Picture));
1059 memset(&s->next_picture, 0, sizeof(Picture));
1060 memset(&s->current_picture, 0, sizeof(Picture));
1062 s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1066 * draws an line from (ex, ey) -> (sx, sy).
1067 * @param w width of the image
1068 * @param h height of the image
1069 * @param stride stride/linesize of the image
1070 * @param color color of the arrow
1072 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1075 sx= av_clip(sx, 0, w-1);
1076 sy= av_clip(sy, 0, h-1);
1077 ex= av_clip(ex, 0, w-1);
1078 ey= av_clip(ey, 0, h-1);
1080 buf[sy*stride + sx]+= color;
1082 if(FFABS(ex - sx) > FFABS(ey - sy)){
1084 FFSWAP(int, sx, ex);
1085 FFSWAP(int, sy, ey);
1087 buf+= sx + sy*stride;
1089 f= ((ey-sy)<<16)/ex;
1090 for(x= 0; x <= ex; x++){
1093 buf[ y *stride + x]+= (color*(0x10000-fr))>>16;
1094 buf[(y+1)*stride + x]+= (color* fr )>>16;
1098 FFSWAP(int, sx, ex);
1099 FFSWAP(int, sy, ey);
1101 buf+= sx + sy*stride;
1103 if(ey) f= ((ex-sx)<<16)/ey;
1105 for(y= 0; y <= ey; y++){
1108 buf[y*stride + x ]+= (color*(0x10000-fr))>>16;
1109 buf[y*stride + x+1]+= (color* fr )>>16;
1115 * draws an arrow from (ex, ey) -> (sx, sy).
1116 * @param w width of the image
1117 * @param h height of the image
1118 * @param stride stride/linesize of the image
1119 * @param color color of the arrow
1121 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1124 sx= av_clip(sx, -100, w+100);
1125 sy= av_clip(sy, -100, h+100);
1126 ex= av_clip(ex, -100, w+100);
1127 ey= av_clip(ey, -100, h+100);
1132 if(dx*dx + dy*dy > 3*3){
1135 int length= ff_sqrt((rx*rx + ry*ry)<<8);
1137 //FIXME subpixel accuracy
1138 rx= ROUNDED_DIV(rx*3<<4, length);
1139 ry= ROUNDED_DIV(ry*3<<4, length);
1141 draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1142 draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1144 draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1148 * prints debuging info for the given picture.
1150 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1152 if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1154 if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1157 av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1158 switch (pict->pict_type) {
1159 case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1160 case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1161 case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1162 case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1163 case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1164 case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1166 for(y=0; y<s->mb_height; y++){
1167 for(x=0; x<s->mb_width; x++){
1168 if(s->avctx->debug&FF_DEBUG_SKIP){
1169 int count= s->mbskip_table[x + y*s->mb_stride];
1170 if(count>9) count=9;
1171 av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1173 if(s->avctx->debug&FF_DEBUG_QP){
1174 av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1176 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1177 int mb_type= pict->mb_type[x + y*s->mb_stride];
1178 //Type & MV direction
1180 av_log(s->avctx, AV_LOG_DEBUG, "P");
1181 else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1182 av_log(s->avctx, AV_LOG_DEBUG, "A");
1183 else if(IS_INTRA4x4(mb_type))
1184 av_log(s->avctx, AV_LOG_DEBUG, "i");
1185 else if(IS_INTRA16x16(mb_type))
1186 av_log(s->avctx, AV_LOG_DEBUG, "I");
1187 else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1188 av_log(s->avctx, AV_LOG_DEBUG, "d");
1189 else if(IS_DIRECT(mb_type))
1190 av_log(s->avctx, AV_LOG_DEBUG, "D");
1191 else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1192 av_log(s->avctx, AV_LOG_DEBUG, "g");
1193 else if(IS_GMC(mb_type))
1194 av_log(s->avctx, AV_LOG_DEBUG, "G");
1195 else if(IS_SKIP(mb_type))
1196 av_log(s->avctx, AV_LOG_DEBUG, "S");
1197 else if(!USES_LIST(mb_type, 1))
1198 av_log(s->avctx, AV_LOG_DEBUG, ">");
1199 else if(!USES_LIST(mb_type, 0))
1200 av_log(s->avctx, AV_LOG_DEBUG, "<");
1202 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1203 av_log(s->avctx, AV_LOG_DEBUG, "X");
1208 av_log(s->avctx, AV_LOG_DEBUG, "+");
1209 else if(IS_16X8(mb_type))
1210 av_log(s->avctx, AV_LOG_DEBUG, "-");
1211 else if(IS_8X16(mb_type))
1212 av_log(s->avctx, AV_LOG_DEBUG, "|");
1213 else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1214 av_log(s->avctx, AV_LOG_DEBUG, " ");
1216 av_log(s->avctx, AV_LOG_DEBUG, "?");
1219 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1220 av_log(s->avctx, AV_LOG_DEBUG, "=");
1222 av_log(s->avctx, AV_LOG_DEBUG, " ");
1224 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1226 av_log(s->avctx, AV_LOG_DEBUG, "\n");
1230 if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1231 const int shift= 1 + s->quarter_sample;
1235 int h_chroma_shift, v_chroma_shift, block_height;
1236 const int width = s->avctx->width;
1237 const int height= s->avctx->height;
1238 const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1239 const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1240 s->low_delay=0; //needed to see the vectors without trashing the buffers
1242 avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1244 memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1245 pict->data[i]= s->visualization_buffer[i];
1247 pict->type= FF_BUFFER_TYPE_COPY;
1249 block_height = 16>>v_chroma_shift;
1251 for(mb_y=0; mb_y<s->mb_height; mb_y++){
1253 for(mb_x=0; mb_x<s->mb_width; mb_x++){
1254 const int mb_index= mb_x + mb_y*s->mb_stride;
1255 if((s->avctx->debug_mv) && pict->motion_val){
1257 for(type=0; type<3; type++){
1260 case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1264 case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1268 case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1273 if(!USES_LIST(pict->mb_type[mb_index], direction))
1276 if(IS_8X8(pict->mb_type[mb_index])){
1279 int sx= mb_x*16 + 4 + 8*(i&1);
1280 int sy= mb_y*16 + 4 + 8*(i>>1);
1281 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1282 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1283 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1284 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1286 }else if(IS_16X8(pict->mb_type[mb_index])){
1290 int sy=mb_y*16 + 4 + 8*i;
1291 int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1292 int mx=(pict->motion_val[direction][xy][0]>>shift);
1293 int my=(pict->motion_val[direction][xy][1]>>shift);
1295 if(IS_INTERLACED(pict->mb_type[mb_index]))
1298 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1300 }else if(IS_8X16(pict->mb_type[mb_index])){
1303 int sx=mb_x*16 + 4 + 8*i;
1305 int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1306 int mx=(pict->motion_val[direction][xy][0]>>shift);
1307 int my=(pict->motion_val[direction][xy][1]>>shift);
1309 if(IS_INTERLACED(pict->mb_type[mb_index]))
1312 draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1315 int sx= mb_x*16 + 8;
1316 int sy= mb_y*16 + 8;
1317 int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1318 int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1319 int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1320 draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1324 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1325 uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1327 for(y=0; y<block_height; y++){
1328 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1329 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1332 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1333 int mb_type= pict->mb_type[mb_index];
1336 #define COLOR(theta, r)\
1337 u= (int)(128 + r*cos(theta*3.141592/180));\
1338 v= (int)(128 + r*sin(theta*3.141592/180));
1342 if(IS_PCM(mb_type)){
1344 }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1346 }else if(IS_INTRA4x4(mb_type)){
1348 }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1350 }else if(IS_DIRECT(mb_type)){
1352 }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1354 }else if(IS_GMC(mb_type)){
1356 }else if(IS_SKIP(mb_type)){
1358 }else if(!USES_LIST(mb_type, 1)){
1360 }else if(!USES_LIST(mb_type, 0)){
1363 assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1367 u*= 0x0101010101010101ULL;
1368 v*= 0x0101010101010101ULL;
1369 for(y=0; y<block_height; y++){
1370 *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1371 *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1375 if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1376 *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1377 *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1379 if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1381 pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1383 if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1384 int dm= 1 << (mv_sample_log2-2);
1386 int sx= mb_x*16 + 8*(i&1);
1387 int sy= mb_y*16 + 8*(i>>1);
1388 int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1390 int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1391 if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1393 pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1394 if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1395 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1399 if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1403 s->mbskip_table[mb_index]=0;
1409 static inline int hpel_motion_lowres(MpegEncContext *s,
1410 uint8_t *dest, uint8_t *src,
1411 int field_based, int field_select,
1412 int src_x, int src_y,
1413 int width, int height, int stride,
1414 int h_edge_pos, int v_edge_pos,
1415 int w, int h, h264_chroma_mc_func *pix_op,
1416 int motion_x, int motion_y)
1418 const int lowres= s->avctx->lowres;
1419 const int op_index= FFMIN(lowres, 2);
1420 const int s_mask= (2<<lowres)-1;
1424 if(s->quarter_sample){
1429 sx= motion_x & s_mask;
1430 sy= motion_y & s_mask;
1431 src_x += motion_x >> (lowres+1);
1432 src_y += motion_y >> (lowres+1);
1434 src += src_y * stride + src_x;
1436 if( (unsigned)src_x > h_edge_pos - (!!sx) - w
1437 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1438 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1439 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1440 src= s->edge_emu_buffer;
1444 sx= (sx << 2) >> lowres;
1445 sy= (sy << 2) >> lowres;
1448 pix_op[op_index](dest, src, stride, h, sx, sy);
1452 /* apply one mpeg motion vector to the three components */
1453 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1454 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1455 int field_based, int bottom_field, int field_select,
1456 uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1457 int motion_x, int motion_y, int h, int mb_y)
1459 uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1460 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1461 const int lowres= s->avctx->lowres;
1462 const int op_index= FFMIN(lowres, 2);
1463 const int block_s= 8>>lowres;
1464 const int s_mask= (2<<lowres)-1;
1465 const int h_edge_pos = s->h_edge_pos >> lowres;
1466 const int v_edge_pos = s->v_edge_pos >> lowres;
1467 linesize = s->current_picture.linesize[0] << field_based;
1468 uvlinesize = s->current_picture.linesize[1] << field_based;
1470 if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1476 motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1479 sx= motion_x & s_mask;
1480 sy= motion_y & s_mask;
1481 src_x = s->mb_x*2*block_s + (motion_x >> (lowres+1));
1482 src_y =( mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1484 if (s->out_format == FMT_H263) {
1485 uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1486 uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1489 }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1492 uvsx = (2*mx) & s_mask;
1493 uvsy = (2*my) & s_mask;
1494 uvsrc_x = s->mb_x*block_s + (mx >> lowres);
1495 uvsrc_y = mb_y*block_s + (my >> lowres);
1501 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1));
1502 uvsrc_y =( mb_y*block_s>>field_based) + (my >> (lowres+1));
1505 ptr_y = ref_picture[0] + src_y * linesize + src_x;
1506 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1507 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1509 if( (unsigned)src_x > h_edge_pos - (!!sx) - 2*block_s
1510 || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1511 ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1512 src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1513 ptr_y = s->edge_emu_buffer;
1514 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1515 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1516 ff_emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9, 9+field_based,
1517 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1518 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1519 uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1525 if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1526 dest_y += s->linesize;
1527 dest_cb+= s->uvlinesize;
1528 dest_cr+= s->uvlinesize;
1532 ptr_y += s->linesize;
1533 ptr_cb+= s->uvlinesize;
1534 ptr_cr+= s->uvlinesize;
1537 sx= (sx << 2) >> lowres;
1538 sy= (sy << 2) >> lowres;
1539 pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1541 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1542 uvsx= (uvsx << 2) >> lowres;
1543 uvsy= (uvsy << 2) >> lowres;
1544 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1545 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1547 //FIXME h261 lowres loop filter
1550 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1551 uint8_t *dest_cb, uint8_t *dest_cr,
1552 uint8_t **ref_picture,
1553 h264_chroma_mc_func *pix_op,
1555 const int lowres= s->avctx->lowres;
1556 const int op_index= FFMIN(lowres, 2);
1557 const int block_s= 8>>lowres;
1558 const int s_mask= (2<<lowres)-1;
1559 const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1560 const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1561 int emu=0, src_x, src_y, offset, sx, sy;
1564 if(s->quarter_sample){
1569 /* In case of 8X8, we construct a single chroma motion vector
1570 with a special rounding */
1571 mx= ff_h263_round_chroma(mx);
1572 my= ff_h263_round_chroma(my);
1576 src_x = s->mb_x*block_s + (mx >> (lowres+1));
1577 src_y = s->mb_y*block_s + (my >> (lowres+1));
1579 offset = src_y * s->uvlinesize + src_x;
1580 ptr = ref_picture[1] + offset;
1581 if(s->flags&CODEC_FLAG_EMU_EDGE){
1582 if( (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1583 || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1584 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1585 ptr= s->edge_emu_buffer;
1589 sx= (sx << 2) >> lowres;
1590 sy= (sy << 2) >> lowres;
1591 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1593 ptr = ref_picture[2] + offset;
1595 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1596 ptr= s->edge_emu_buffer;
1598 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1602 * motion compensation of a single macroblock
1604 * @param dest_y luma destination pointer
1605 * @param dest_cb chroma cb/u destination pointer
1606 * @param dest_cr chroma cr/v destination pointer
1607 * @param dir direction (0->forward, 1->backward)
1608 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1609 * @param pic_op halfpel motion compensation function (average or put normally)
1610 * the motion vectors are taken from s->mv and the MV type from s->mv_type
1612 static inline void MPV_motion_lowres(MpegEncContext *s,
1613 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1614 int dir, uint8_t **ref_picture,
1615 h264_chroma_mc_func *pix_op)
1619 const int lowres= s->avctx->lowres;
1620 const int block_s= 8>>lowres;
1625 switch(s->mv_type) {
1627 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1629 ref_picture, pix_op,
1630 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
1636 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1637 ref_picture[0], 0, 0,
1638 (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1639 s->width, s->height, s->linesize,
1640 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1641 block_s, block_s, pix_op,
1642 s->mv[dir][i][0], s->mv[dir][i][1]);
1644 mx += s->mv[dir][i][0];
1645 my += s->mv[dir][i][1];
1648 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1649 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1652 if (s->picture_structure == PICT_FRAME) {
1654 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1655 1, 0, s->field_select[dir][0],
1656 ref_picture, pix_op,
1657 s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
1659 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1660 1, 1, s->field_select[dir][1],
1661 ref_picture, pix_op,
1662 s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
1664 if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1665 ref_picture= s->current_picture_ptr->data;
1668 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1669 0, 0, s->field_select[dir][0],
1670 ref_picture, pix_op,
1671 s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
1676 uint8_t ** ref2picture;
1678 if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1679 ref2picture= ref_picture;
1681 ref2picture= s->current_picture_ptr->data;
1684 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1685 0, 0, s->field_select[dir][i],
1686 ref2picture, pix_op,
1687 s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
1689 dest_y += 2*block_s*s->linesize;
1690 dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1691 dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1695 if(s->picture_structure == PICT_FRAME){
1699 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1701 ref_picture, pix_op,
1702 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
1704 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1708 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1709 0, 0, s->picture_structure != i+1,
1710 ref_picture, pix_op,
1711 s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
1713 // after put we make avg of the same block
1714 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1716 //opposite parity is always in the same frame if this is second field
1717 if(!s->first_field){
1718 ref_picture = s->current_picture_ptr->data;
1727 /* put block[] to dest[] */
1728 static inline void put_dct(MpegEncContext *s,
1729 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1731 s->dct_unquantize_intra(s, block, i, qscale);
1732 s->dsp.idct_put (dest, line_size, block);
1735 /* add block[] to dest[] */
1736 static inline void add_dct(MpegEncContext *s,
1737 DCTELEM *block, int i, uint8_t *dest, int line_size)
1739 if (s->block_last_index[i] >= 0) {
1740 s->dsp.idct_add (dest, line_size, block);
1744 static inline void add_dequant_dct(MpegEncContext *s,
1745 DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1747 if (s->block_last_index[i] >= 0) {
1748 s->dct_unquantize_inter(s, block, i, qscale);
1750 s->dsp.idct_add (dest, line_size, block);
1755 * cleans dc, ac, coded_block for the current non intra MB
1757 void ff_clean_intra_table_entries(MpegEncContext *s)
1759 int wrap = s->b8_stride;
1760 int xy = s->block_index[0];
1763 s->dc_val[0][xy + 1 ] =
1764 s->dc_val[0][xy + wrap] =
1765 s->dc_val[0][xy + 1 + wrap] = 1024;
1767 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t));
1768 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1769 if (s->msmpeg4_version>=3) {
1770 s->coded_block[xy ] =
1771 s->coded_block[xy + 1 ] =
1772 s->coded_block[xy + wrap] =
1773 s->coded_block[xy + 1 + wrap] = 0;
1776 wrap = s->mb_stride;
1777 xy = s->mb_x + s->mb_y * wrap;
1779 s->dc_val[2][xy] = 1024;
1781 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1782 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1784 s->mbintra_table[xy]= 0;
1787 /* generic function called after a macroblock has been parsed by the
1788 decoder or after it has been encoded by the encoder.
1790 Important variables used:
1791 s->mb_intra : true if intra macroblock
1792 s->mv_dir : motion vector direction
1793 s->mv_type : motion vector type
1794 s->mv : motion vector
1795 s->interlaced_dct : true if interlaced dct used (mpeg2)
1797 static av_always_inline
1798 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1799 int lowres_flag, int is_mpeg12)
1801 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1802 if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1803 ff_xvmc_decode_mb(s);//xvmc uses pblocks
1807 if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1808 /* save DCT coefficients */
1810 DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1813 *dct++ = block[i][s->dsp.idct_permutation[j]];
1816 s->current_picture.qscale_table[mb_xy]= s->qscale;
1818 /* update DC predictors for P macroblocks */
1820 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1821 if(s->mbintra_table[mb_xy])
1822 ff_clean_intra_table_entries(s);
1826 s->last_dc[2] = 128 << s->intra_dc_precision;
1829 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1830 s->mbintra_table[mb_xy]=1;
1832 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
1833 uint8_t *dest_y, *dest_cb, *dest_cr;
1834 int dct_linesize, dct_offset;
1835 op_pixels_func (*op_pix)[4];
1836 qpel_mc_func (*op_qpix)[16];
1837 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1838 const int uvlinesize= s->current_picture.linesize[1];
1839 const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1840 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1842 /* avoid copy if macroblock skipped in last frame too */
1843 /* skip only during decoding as we might trash the buffers during encoding a bit */
1845 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1846 const int age= s->current_picture.age;
1850 if (s->mb_skipped) {
1852 assert(s->pict_type!=FF_I_TYPE);
1854 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1855 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1857 /* if previous was skipped too, then nothing to do ! */
1858 if (*mbskip_ptr >= age && s->current_picture.reference){
1861 } else if(!s->current_picture.reference){
1862 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1863 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1865 *mbskip_ptr = 0; /* not skipped */
1869 dct_linesize = linesize << s->interlaced_dct;
1870 dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1874 dest_cb= s->dest[1];
1875 dest_cr= s->dest[2];
1877 dest_y = s->b_scratchpad;
1878 dest_cb= s->b_scratchpad+16*linesize;
1879 dest_cr= s->b_scratchpad+32*linesize;
1883 /* motion handling */
1884 /* decoding or more than one mb_type (MC was already done otherwise) */
1887 h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1889 if (s->mv_dir & MV_DIR_FORWARD) {
1890 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1891 op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1893 if (s->mv_dir & MV_DIR_BACKWARD) {
1894 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1897 op_qpix= s->me.qpel_put;
1898 if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1899 op_pix = s->dsp.put_pixels_tab;
1901 op_pix = s->dsp.put_no_rnd_pixels_tab;
1903 if (s->mv_dir & MV_DIR_FORWARD) {
1904 MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1905 op_pix = s->dsp.avg_pixels_tab;
1906 op_qpix= s->me.qpel_avg;
1908 if (s->mv_dir & MV_DIR_BACKWARD) {
1909 MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1914 /* skip dequant / idct if we are really late ;) */
1915 if(s->hurry_up>1) goto skip_idct;
1916 if(s->avctx->skip_idct){
1917 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1918 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1919 || s->avctx->skip_idct >= AVDISCARD_ALL)
1923 /* add dct residue */
1924 if(s->encoding || !( s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1925 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1926 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1927 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1928 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1929 add_dequant_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 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1934 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1938 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1939 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1940 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1941 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1944 } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
1945 add_dct(s, block[0], 0, dest_y , dct_linesize);
1946 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize);
1947 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize);
1948 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1950 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1951 if(s->chroma_y_shift){//Chroma420
1952 add_dct(s, block[4], 4, dest_cb, uvlinesize);
1953 add_dct(s, block[5], 5, dest_cr, uvlinesize);
1956 dct_linesize = uvlinesize << s->interlaced_dct;
1957 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1959 add_dct(s, block[4], 4, dest_cb, dct_linesize);
1960 add_dct(s, block[5], 5, dest_cr, dct_linesize);
1961 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1962 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1963 if(!s->chroma_x_shift){//Chroma444
1964 add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1965 add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1966 add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1967 add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1972 else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
1973 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1976 /* dct only in intra block */
1977 if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1978 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale);
1979 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale);
1980 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale);
1981 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1983 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1984 if(s->chroma_y_shift){
1985 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1986 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1990 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale);
1991 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale);
1992 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1993 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1997 s->dsp.idct_put(dest_y , dct_linesize, block[0]);
1998 s->dsp.idct_put(dest_y + block_size, dct_linesize, block[1]);
1999 s->dsp.idct_put(dest_y + dct_offset , dct_linesize, block[2]);
2000 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2002 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2003 if(s->chroma_y_shift){
2004 s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2005 s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2008 dct_linesize = uvlinesize << s->interlaced_dct;
2009 dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2011 s->dsp.idct_put(dest_cb, dct_linesize, block[4]);
2012 s->dsp.idct_put(dest_cr, dct_linesize, block[5]);
2013 s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2014 s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2015 if(!s->chroma_x_shift){//Chroma444
2016 s->dsp.idct_put(dest_cb + 8, dct_linesize, block[8]);
2017 s->dsp.idct_put(dest_cr + 8, dct_linesize, block[9]);
2018 s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2019 s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2027 s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16);
2028 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2029 s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2034 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2036 if(s->out_format == FMT_MPEG1) {
2037 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2038 else MPV_decode_mb_internal(s, block, 0, 1);
2041 if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2042 else MPV_decode_mb_internal(s, block, 0, 0);
2047 * @param h is the normal height, this will be reduced automatically if needed for the last row
2049 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2050 if (s->avctx->draw_horiz_band) {
2052 const int field_pic= s->picture_structure != PICT_FRAME;
2055 h= FFMIN(h, (s->avctx->height>>field_pic) - y);
2057 if(field_pic && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)){
2060 if(s->first_field) return;
2063 if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2064 src= (AVFrame*)s->current_picture_ptr;
2065 else if(s->last_picture_ptr)
2066 src= (AVFrame*)s->last_picture_ptr;
2070 if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2076 offset[0]= y * s->linesize;
2078 offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2084 s->avctx->draw_horiz_band(s->avctx, src, offset,
2085 y, s->picture_structure, h);
2089 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2090 const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2091 const int uvlinesize= s->current_picture.linesize[1];
2092 const int mb_size= 4 - s->avctx->lowres;
2094 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
2095 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
2096 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2097 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2098 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2099 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;
2100 //block_index is not used by mpeg2, so it is not affected by chroma_format
2102 s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2103 s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2104 s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2106 if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2108 if(s->picture_structure==PICT_FRAME){
2109 s->dest[0] += s->mb_y * linesize << mb_size;
2110 s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2111 s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2113 s->dest[0] += (s->mb_y>>1) * linesize << mb_size;
2114 s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2115 s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2116 assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2121 void ff_mpeg_flush(AVCodecContext *avctx){
2123 MpegEncContext *s = avctx->priv_data;
2125 if(s==NULL || s->picture==NULL)
2128 for(i=0; i<MAX_PICTURE_COUNT; i++){
2129 if(s->picture[i].data[0] && ( s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2130 || s->picture[i].type == FF_BUFFER_TYPE_USER))
2131 free_frame_buffer(s, &s->picture[i]);
2133 s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2135 s->mb_x= s->mb_y= 0;
2138 s->parse_context.state= -1;
2139 s->parse_context.frame_start_found= 0;
2140 s->parse_context.overread= 0;
2141 s->parse_context.overread_index= 0;
2142 s->parse_context.index= 0;
2143 s->parse_context.last_index= 0;
2144 s->bitstream_buffer_size=0;
2148 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2149 DCTELEM *block, int n, int qscale)
2151 int i, level, nCoeffs;
2152 const uint16_t *quant_matrix;
2154 nCoeffs= s->block_last_index[n];
2157 block[0] = block[0] * s->y_dc_scale;
2159 block[0] = block[0] * s->c_dc_scale;
2160 /* XXX: only mpeg1 */
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;
2169 level = (level - 1) | 1;
2172 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2173 level = (level - 1) | 1;
2180 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2181 DCTELEM *block, int n, int qscale)
2183 int i, level, nCoeffs;
2184 const uint16_t *quant_matrix;
2186 nCoeffs= s->block_last_index[n];
2188 quant_matrix = s->inter_matrix;
2189 for(i=0; i<=nCoeffs; i++) {
2190 int j= s->intra_scantable.permutated[i];
2195 level = (((level << 1) + 1) * qscale *
2196 ((int) (quant_matrix[j]))) >> 4;
2197 level = (level - 1) | 1;
2200 level = (((level << 1) + 1) * qscale *
2201 ((int) (quant_matrix[j]))) >> 4;
2202 level = (level - 1) | 1;
2209 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2210 DCTELEM *block, int n, int qscale)
2212 int i, level, nCoeffs;
2213 const uint16_t *quant_matrix;
2215 if(s->alternate_scan) nCoeffs= 63;
2216 else nCoeffs= s->block_last_index[n];
2219 block[0] = block[0] * s->y_dc_scale;
2221 block[0] = block[0] * s->c_dc_scale;
2222 quant_matrix = s->intra_matrix;
2223 for(i=1;i<=nCoeffs;i++) {
2224 int j= s->intra_scantable.permutated[i];
2229 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2232 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2239 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2240 DCTELEM *block, int n, int qscale)
2242 int i, level, nCoeffs;
2243 const uint16_t *quant_matrix;
2246 if(s->alternate_scan) nCoeffs= 63;
2247 else nCoeffs= s->block_last_index[n];
2250 block[0] = block[0] * s->y_dc_scale;
2252 block[0] = block[0] * s->c_dc_scale;
2253 quant_matrix = s->intra_matrix;
2254 for(i=1;i<=nCoeffs;i++) {
2255 int j= s->intra_scantable.permutated[i];
2260 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2263 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2272 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2273 DCTELEM *block, int n, int qscale)
2275 int i, level, nCoeffs;
2276 const uint16_t *quant_matrix;
2279 if(s->alternate_scan) nCoeffs= 63;
2280 else nCoeffs= s->block_last_index[n];
2282 quant_matrix = s->inter_matrix;
2283 for(i=0; i<=nCoeffs; i++) {
2284 int j= s->intra_scantable.permutated[i];
2289 level = (((level << 1) + 1) * qscale *
2290 ((int) (quant_matrix[j]))) >> 4;
2293 level = (((level << 1) + 1) * qscale *
2294 ((int) (quant_matrix[j]))) >> 4;
2303 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2304 DCTELEM *block, int n, int qscale)
2306 int i, level, qmul, qadd;
2309 assert(s->block_last_index[n]>=0);
2315 block[0] = block[0] * s->y_dc_scale;
2317 block[0] = block[0] * s->c_dc_scale;
2318 qadd = (qscale - 1) | 1;
2325 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2327 for(i=1; i<=nCoeffs; i++) {
2331 level = level * qmul - qadd;
2333 level = level * qmul + qadd;
2340 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2341 DCTELEM *block, int n, int qscale)
2343 int i, level, qmul, qadd;
2346 assert(s->block_last_index[n]>=0);
2348 qadd = (qscale - 1) | 1;
2351 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2353 for(i=0; i<=nCoeffs; i++) {
2357 level = level * qmul - qadd;
2359 level = level * qmul + qadd;
2367 * set qscale and update qscale dependent variables.
2369 void ff_set_qscale(MpegEncContext * s, int qscale)
2373 else if (qscale > 31)
2377 s->chroma_qscale= s->chroma_qscale_table[qscale];
2379 s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2380 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];