1/* 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> 5 * 6 * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at> 7 * 8 * This file is part of FFmpeg. 9 * 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. 14 * 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. 19 * 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 23 */ 24 25/** 26 * @file 27 * The simplest mpeg encoder (well, it was the simplest!). 28 */ 29 30#include "config_components.h" 31 32#include "libavutil/attributes.h" 33#include "libavutil/avassert.h" 34#include "libavutil/imgutils.h" 35#include "libavutil/internal.h" 36 37#include "avcodec.h" 38#include "blockdsp.h" 39#include "h264chroma.h" 40#include "idctdsp.h" 41#include "mathops.h" 42#include "mpeg_er.h" 43#include "mpegutils.h" 44#include "mpegvideo.h" 45#include "mpeg4videodec.h" 46#include "mpegvideodata.h" 47#include "qpeldsp.h" 48#include "threadframe.h" 49#include "wmv2dec.h" 50#include <limits.h> 51 52static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s, 53 int16_t *block, int n, int qscale) 54{ 55 int i, level, nCoeffs; 56 const uint16_t *quant_matrix; 57 58 nCoeffs= s->block_last_index[n]; 59 60 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale; 61 /* XXX: only MPEG-1 */ 62 quant_matrix = s->intra_matrix; 63 for(i=1;i<=nCoeffs;i++) { 64 int j= s->intra_scantable.permutated[i]; 65 level = block[j]; 66 if (level) { 67 if (level < 0) { 68 level = -level; 69 level = (int)(level * qscale * quant_matrix[j]) >> 3; 70 level = (level - 1) | 1; 71 level = -level; 72 } else { 73 level = (int)(level * qscale * quant_matrix[j]) >> 3; 74 level = (level - 1) | 1; 75 } 76 block[j] = level; 77 } 78 } 79} 80 81static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s, 82 int16_t *block, int n, int qscale) 83{ 84 int i, level, nCoeffs; 85 const uint16_t *quant_matrix; 86 87 nCoeffs= s->block_last_index[n]; 88 89 quant_matrix = s->inter_matrix; 90 for(i=0; i<=nCoeffs; i++) { 91 int j= s->intra_scantable.permutated[i]; 92 level = block[j]; 93 if (level) { 94 if (level < 0) { 95 level = -level; 96 level = (((level << 1) + 1) * qscale * 97 ((int) (quant_matrix[j]))) >> 4; 98 level = (level - 1) | 1; 99 level = -level; 100 } else { 101 level = (((level << 1) + 1) * qscale * 102 ((int) (quant_matrix[j]))) >> 4; 103 level = (level - 1) | 1; 104 } 105 block[j] = level; 106 } 107 } 108} 109 110static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s, 111 int16_t *block, int n, int qscale) 112{ 113 int i, level, nCoeffs; 114 const uint16_t *quant_matrix; 115 116 if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale]; 117 else qscale <<= 1; 118 119 if(s->alternate_scan) nCoeffs= 63; 120 else nCoeffs= s->block_last_index[n]; 121 122 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale; 123 quant_matrix = s->intra_matrix; 124 for(i=1;i<=nCoeffs;i++) { 125 int j= s->intra_scantable.permutated[i]; 126 level = block[j]; 127 if (level) { 128 if (level < 0) { 129 level = -level; 130 level = (int)(level * qscale * quant_matrix[j]) >> 4; 131 level = -level; 132 } else { 133 level = (int)(level * qscale * quant_matrix[j]) >> 4; 134 } 135 block[j] = level; 136 } 137 } 138} 139 140static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s, 141 int16_t *block, int n, int qscale) 142{ 143 int i, level, nCoeffs; 144 const uint16_t *quant_matrix; 145 int sum=-1; 146 147 if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale]; 148 else qscale <<= 1; 149 150 if(s->alternate_scan) nCoeffs= 63; 151 else nCoeffs= s->block_last_index[n]; 152 153 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale; 154 sum += block[0]; 155 quant_matrix = s->intra_matrix; 156 for(i=1;i<=nCoeffs;i++) { 157 int j= s->intra_scantable.permutated[i]; 158 level = block[j]; 159 if (level) { 160 if (level < 0) { 161 level = -level; 162 level = (int)(level * qscale * quant_matrix[j]) >> 4; 163 level = -level; 164 } else { 165 level = (int)(level * qscale * quant_matrix[j]) >> 4; 166 } 167 block[j] = level; 168 sum+=level; 169 } 170 } 171 block[63]^=sum&1; 172} 173 174static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s, 175 int16_t *block, int n, int qscale) 176{ 177 int i, level, nCoeffs; 178 const uint16_t *quant_matrix; 179 int sum=-1; 180 181 if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale]; 182 else qscale <<= 1; 183 184 if(s->alternate_scan) nCoeffs= 63; 185 else nCoeffs= s->block_last_index[n]; 186 187 quant_matrix = s->inter_matrix; 188 for(i=0; i<=nCoeffs; i++) { 189 int j= s->intra_scantable.permutated[i]; 190 level = block[j]; 191 if (level) { 192 if (level < 0) { 193 level = -level; 194 level = (((level << 1) + 1) * qscale * 195 ((int) (quant_matrix[j]))) >> 5; 196 level = -level; 197 } else { 198 level = (((level << 1) + 1) * qscale * 199 ((int) (quant_matrix[j]))) >> 5; 200 } 201 block[j] = level; 202 sum+=level; 203 } 204 } 205 block[63]^=sum&1; 206} 207 208static void dct_unquantize_h263_intra_c(MpegEncContext *s, 209 int16_t *block, int n, int qscale) 210{ 211 int i, level, qmul, qadd; 212 int nCoeffs; 213 214 av_assert2(s->block_last_index[n]>=0 || s->h263_aic); 215 216 qmul = qscale << 1; 217 218 if (!s->h263_aic) { 219 block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale; 220 qadd = (qscale - 1) | 1; 221 }else{ 222 qadd = 0; 223 } 224 if(s->ac_pred) 225 nCoeffs=63; 226 else 227 nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ]; 228 229 for(i=1; i<=nCoeffs; i++) { 230 level = block[i]; 231 if (level) { 232 if (level < 0) { 233 level = level * qmul - qadd; 234 } else { 235 level = level * qmul + qadd; 236 } 237 block[i] = level; 238 } 239 } 240} 241 242static void dct_unquantize_h263_inter_c(MpegEncContext *s, 243 int16_t *block, int n, int qscale) 244{ 245 int i, level, qmul, qadd; 246 int nCoeffs; 247 248 av_assert2(s->block_last_index[n]>=0); 249 250 qadd = (qscale - 1) | 1; 251 qmul = qscale << 1; 252 253 nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ]; 254 255 for(i=0; i<=nCoeffs; i++) { 256 level = block[i]; 257 if (level) { 258 if (level < 0) { 259 level = level * qmul - qadd; 260 } else { 261 level = level * qmul + qadd; 262 } 263 block[i] = level; 264 } 265 } 266} 267 268 269static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h) 270{ 271 while(h--) 272 memset(dst + h*linesize, 128, 16); 273} 274 275static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h) 276{ 277 while(h--) 278 memset(dst + h*linesize, 128, 8); 279} 280 281/* init common dct for both encoder and decoder */ 282static av_cold int dct_init(MpegEncContext *s) 283{ 284 ff_blockdsp_init(&s->bdsp, s->avctx); 285 ff_h264chroma_init(&s->h264chroma, 8); //for lowres 286 ff_hpeldsp_init(&s->hdsp, s->avctx->flags); 287 ff_mpegvideodsp_init(&s->mdsp); 288 ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample); 289 290 if (s->avctx->debug & FF_DEBUG_NOMC) { 291 int i; 292 for (i=0; i<4; i++) { 293 s->hdsp.avg_pixels_tab[0][i] = gray16; 294 s->hdsp.put_pixels_tab[0][i] = gray16; 295 s->hdsp.put_no_rnd_pixels_tab[0][i] = gray16; 296 297 s->hdsp.avg_pixels_tab[1][i] = gray8; 298 s->hdsp.put_pixels_tab[1][i] = gray8; 299 s->hdsp.put_no_rnd_pixels_tab[1][i] = gray8; 300 } 301 } 302 303 s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c; 304 s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c; 305 s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c; 306 s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c; 307 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c; 308 if (s->avctx->flags & AV_CODEC_FLAG_BITEXACT) 309 s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact; 310 s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c; 311 312#if HAVE_INTRINSICS_NEON 313 ff_mpv_common_init_neon(s); 314#endif 315 316#if ARCH_ALPHA 317 ff_mpv_common_init_axp(s); 318#elif ARCH_ARM 319 ff_mpv_common_init_arm(s); 320#elif ARCH_PPC 321 ff_mpv_common_init_ppc(s); 322#elif ARCH_X86 323 ff_mpv_common_init_x86(s); 324#elif ARCH_MIPS 325 ff_mpv_common_init_mips(s); 326#endif 327 328 return 0; 329} 330 331av_cold void ff_mpv_idct_init(MpegEncContext *s) 332{ 333 if (s->codec_id == AV_CODEC_ID_MPEG4) 334 s->idsp.mpeg4_studio_profile = s->studio_profile; 335 ff_idctdsp_init(&s->idsp, s->avctx); 336 337 /* load & permutate scantables 338 * note: only wmv uses different ones 339 */ 340 if (s->alternate_scan) { 341 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan); 342 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan); 343 } else { 344 ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct); 345 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct); 346 } 347 ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan); 348 ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan); 349} 350 351static int init_duplicate_context(MpegEncContext *s) 352{ 353 int y_size = s->b8_stride * (2 * s->mb_height + 1); 354 int c_size = s->mb_stride * (s->mb_height + 1); 355 int yc_size = y_size + 2 * c_size; 356 int i; 357 358 if (s->mb_height & 1) 359 yc_size += 2*s->b8_stride + 2*s->mb_stride; 360 361 if (s->encoding) { 362 if (!FF_ALLOCZ_TYPED_ARRAY(s->me.map, ME_MAP_SIZE) || 363 !FF_ALLOCZ_TYPED_ARRAY(s->me.score_map, ME_MAP_SIZE)) 364 return AVERROR(ENOMEM); 365 366 if (s->noise_reduction) { 367 if (!FF_ALLOCZ_TYPED_ARRAY(s->dct_error_sum, 2)) 368 return AVERROR(ENOMEM); 369 } 370 } 371 if (!FF_ALLOCZ_TYPED_ARRAY(s->blocks, 2)) 372 return AVERROR(ENOMEM); 373 s->block = s->blocks[0]; 374 375 for (i = 0; i < 12; i++) { 376 s->pblocks[i] = &s->block[i]; 377 } 378 379 if (s->avctx->codec_tag == AV_RL32("VCR2")) { 380 // exchange uv 381 FFSWAP(void *, s->pblocks[4], s->pblocks[5]); 382 } 383 384 if (s->out_format == FMT_H263) { 385 /* ac values */ 386 if (!FF_ALLOCZ_TYPED_ARRAY(s->ac_val_base, yc_size)) 387 return AVERROR(ENOMEM); 388 s->ac_val[0] = s->ac_val_base + s->b8_stride + 1; 389 s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1; 390 s->ac_val[2] = s->ac_val[1] + c_size; 391 } 392 393 return 0; 394} 395 396int ff_mpv_init_duplicate_contexts(MpegEncContext *s) 397{ 398 int nb_slices = s->slice_context_count, ret; 399 400 /* We initialize the copies before the original so that 401 * fields allocated in init_duplicate_context are NULL after 402 * copying. This prevents double-frees upon allocation error. */ 403 for (int i = 1; i < nb_slices; i++) { 404 s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext)); 405 if (!s->thread_context[i]) 406 return AVERROR(ENOMEM); 407 if ((ret = init_duplicate_context(s->thread_context[i])) < 0) 408 return ret; 409 s->thread_context[i]->start_mb_y = 410 (s->mb_height * (i ) + nb_slices / 2) / nb_slices; 411 s->thread_context[i]->end_mb_y = 412 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices; 413 } 414 s->start_mb_y = 0; 415 s->end_mb_y = nb_slices > 1 ? (s->mb_height + nb_slices / 2) / nb_slices 416 : s->mb_height; 417 return init_duplicate_context(s); 418} 419 420static void free_duplicate_context(MpegEncContext *s) 421{ 422 if (!s) 423 return; 424 425 av_freep(&s->sc.edge_emu_buffer); 426 av_freep(&s->me.scratchpad); 427 s->me.temp = 428 s->sc.rd_scratchpad = 429 s->sc.b_scratchpad = 430 s->sc.obmc_scratchpad = NULL; 431 432 av_freep(&s->dct_error_sum); 433 av_freep(&s->me.map); 434 av_freep(&s->me.score_map); 435 av_freep(&s->blocks); 436 av_freep(&s->ac_val_base); 437 s->block = NULL; 438} 439 440static void free_duplicate_contexts(MpegEncContext *s) 441{ 442 for (int i = 1; i < s->slice_context_count; i++) { 443 free_duplicate_context(s->thread_context[i]); 444 av_freep(&s->thread_context[i]); 445 } 446 free_duplicate_context(s); 447} 448 449static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src) 450{ 451#define COPY(a) bak->a = src->a 452 COPY(sc.edge_emu_buffer); 453 COPY(me.scratchpad); 454 COPY(me.temp); 455 COPY(sc.rd_scratchpad); 456 COPY(sc.b_scratchpad); 457 COPY(sc.obmc_scratchpad); 458 COPY(me.map); 459 COPY(me.score_map); 460 COPY(blocks); 461 COPY(block); 462 COPY(start_mb_y); 463 COPY(end_mb_y); 464 COPY(me.map_generation); 465 COPY(pb); 466 COPY(dct_error_sum); 467 COPY(dct_count[0]); 468 COPY(dct_count[1]); 469 COPY(ac_val_base); 470 COPY(ac_val[0]); 471 COPY(ac_val[1]); 472 COPY(ac_val[2]); 473#undef COPY 474} 475 476int ff_update_duplicate_context(MpegEncContext *dst, const MpegEncContext *src) 477{ 478 MpegEncContext bak; 479 int i, ret; 480 // FIXME copy only needed parts 481 backup_duplicate_context(&bak, dst); 482 memcpy(dst, src, sizeof(MpegEncContext)); 483 backup_duplicate_context(dst, &bak); 484 for (i = 0; i < 12; i++) { 485 dst->pblocks[i] = &dst->block[i]; 486 } 487 if (dst->avctx->codec_tag == AV_RL32("VCR2")) { 488 // exchange uv 489 FFSWAP(void *, dst->pblocks[4], dst->pblocks[5]); 490 } 491 if (!dst->sc.edge_emu_buffer && 492 (ret = ff_mpeg_framesize_alloc(dst->avctx, &dst->me, 493 &dst->sc, dst->linesize)) < 0) { 494 av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context " 495 "scratch buffers.\n"); 496 return ret; 497 } 498 return 0; 499} 500 501/** 502 * Set the given MpegEncContext to common defaults 503 * (same for encoding and decoding). 504 * The changed fields will not depend upon the 505 * prior state of the MpegEncContext. 506 */ 507void ff_mpv_common_defaults(MpegEncContext *s) 508{ 509 s->y_dc_scale_table = 510 s->c_dc_scale_table = ff_mpeg1_dc_scale_table; 511 s->chroma_qscale_table = ff_default_chroma_qscale_table; 512 s->progressive_frame = 1; 513 s->progressive_sequence = 1; 514 s->picture_structure = PICT_FRAME; 515 516 s->coded_picture_number = 0; 517 s->picture_number = 0; 518 519 s->f_code = 1; 520 s->b_code = 1; 521 522 s->slice_context_count = 1; 523} 524 525int ff_mpv_init_context_frame(MpegEncContext *s) 526{ 527 int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y; 528 529 s->mb_width = (s->width + 15) / 16; 530 s->mb_stride = s->mb_width + 1; 531 s->b8_stride = s->mb_width * 2 + 1; 532 mb_array_size = s->mb_height * s->mb_stride; 533 mv_table_size = (s->mb_height + 2) * s->mb_stride + 1; 534 535 /* set default edge pos, will be overridden 536 * in decode_header if needed */ 537 s->h_edge_pos = s->mb_width * 16; 538 s->v_edge_pos = s->mb_height * 16; 539 540 s->mb_num = s->mb_width * s->mb_height; 541 542 s->block_wrap[0] = 543 s->block_wrap[1] = 544 s->block_wrap[2] = 545 s->block_wrap[3] = s->b8_stride; 546 s->block_wrap[4] = 547 s->block_wrap[5] = s->mb_stride; 548 549 y_size = s->b8_stride * (2 * s->mb_height + 1); 550 c_size = s->mb_stride * (s->mb_height + 1); 551 yc_size = y_size + 2 * c_size; 552 553 if (s->mb_height & 1) 554 yc_size += 2*s->b8_stride + 2*s->mb_stride; 555 556 if (!FF_ALLOCZ_TYPED_ARRAY(s->mb_index2xy, s->mb_num + 1)) 557 return AVERROR(ENOMEM); 558 for (y = 0; y < s->mb_height; y++) 559 for (x = 0; x < s->mb_width; x++) 560 s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride; 561 562 s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed? 563 564 if (s->encoding) { 565 /* Allocate MV tables */ 566 if (!FF_ALLOCZ_TYPED_ARRAY(s->p_mv_table_base, mv_table_size) || 567 !FF_ALLOCZ_TYPED_ARRAY(s->b_forw_mv_table_base, mv_table_size) || 568 !FF_ALLOCZ_TYPED_ARRAY(s->b_back_mv_table_base, mv_table_size) || 569 !FF_ALLOCZ_TYPED_ARRAY(s->b_bidir_forw_mv_table_base, mv_table_size) || 570 !FF_ALLOCZ_TYPED_ARRAY(s->b_bidir_back_mv_table_base, mv_table_size) || 571 !FF_ALLOCZ_TYPED_ARRAY(s->b_direct_mv_table_base, mv_table_size)) 572 return AVERROR(ENOMEM); 573 s->p_mv_table = s->p_mv_table_base + s->mb_stride + 1; 574 s->b_forw_mv_table = s->b_forw_mv_table_base + s->mb_stride + 1; 575 s->b_back_mv_table = s->b_back_mv_table_base + s->mb_stride + 1; 576 s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1; 577 s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1; 578 s->b_direct_mv_table = s->b_direct_mv_table_base + s->mb_stride + 1; 579 580 /* Allocate MB type table */ 581 if (!FF_ALLOCZ_TYPED_ARRAY(s->mb_type, mb_array_size) || 582 !FF_ALLOCZ_TYPED_ARRAY(s->lambda_table, mb_array_size) || 583 !FF_ALLOC_TYPED_ARRAY (s->cplx_tab, mb_array_size) || 584 !FF_ALLOC_TYPED_ARRAY (s->bits_tab, mb_array_size)) 585 return AVERROR(ENOMEM); 586 587#define ALLOCZ_ARRAYS(p, mult, numb) ((p) = av_calloc(numb, mult * sizeof(*(p)))) 588 if (s->codec_id == AV_CODEC_ID_MPEG4 || 589 (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)) { 590 int16_t (*tmp1)[2]; 591 uint8_t *tmp2; 592 if (!(tmp1 = ALLOCZ_ARRAYS(s->b_field_mv_table_base, 8, mv_table_size)) || 593 !(tmp2 = ALLOCZ_ARRAYS(s->b_field_select_table[0][0], 2 * 4, mv_table_size)) || 594 !ALLOCZ_ARRAYS(s->p_field_select_table[0], 2 * 2, mv_table_size)) 595 return AVERROR(ENOMEM); 596 597 s->p_field_select_table[1] = s->p_field_select_table[0] + 2 * mv_table_size; 598 tmp1 += s->mb_stride + 1; 599 600 for (int i = 0; i < 2; i++) { 601 for (int j = 0; j < 2; j++) { 602 for (int k = 0; k < 2; k++) { 603 s->b_field_mv_table[i][j][k] = tmp1; 604 tmp1 += mv_table_size; 605 } 606 s->b_field_select_table[i][j] = tmp2; 607 tmp2 += 2 * mv_table_size; 608 } 609 } 610 } 611 } 612 613 if (s->codec_id == AV_CODEC_ID_MPEG4 || 614 (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)) { 615 int16_t (*tmp)[2]; 616 /* interlaced direct mode decoding tables */ 617 if (!(tmp = ALLOCZ_ARRAYS(s->p_field_mv_table_base, 4, mv_table_size))) 618 return AVERROR(ENOMEM); 619 tmp += s->mb_stride + 1; 620 for (int i = 0; i < 2; i++) { 621 for (int j = 0; j < 2; j++) { 622 s->p_field_mv_table[i][j] = tmp; 623 tmp += mv_table_size; 624 } 625 } 626 } 627 628 if (s->out_format == FMT_H263) { 629 /* cbp values, cbp, ac_pred, pred_dir */ 630 if (!(s->coded_block_base = av_mallocz(y_size + (s->mb_height&1)*2*s->b8_stride)) || 631 !(s->cbp_table = av_mallocz(mb_array_size)) || 632 !(s->pred_dir_table = av_mallocz(mb_array_size))) 633 return AVERROR(ENOMEM); 634 s->coded_block = s->coded_block_base + s->b8_stride + 1; 635 } 636 637 if (s->h263_pred || s->h263_plus || !s->encoding) { 638 /* dc values */ 639 // MN: we need these for error resilience of intra-frames 640 if (!FF_ALLOCZ_TYPED_ARRAY(s->dc_val_base, yc_size)) 641 return AVERROR(ENOMEM); 642 s->dc_val[0] = s->dc_val_base + s->b8_stride + 1; 643 s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1; 644 s->dc_val[2] = s->dc_val[1] + c_size; 645 for (i = 0; i < yc_size; i++) 646 s->dc_val_base[i] = 1024; 647 } 648 649 /* which mb is an intra block, init macroblock skip table */ 650 if (!(s->mbintra_table = av_mallocz(mb_array_size)) || 651 // Note the + 1 is for a quicker MPEG-4 slice_end detection 652 !(s->mbskip_table = av_mallocz(mb_array_size + 2))) 653 return AVERROR(ENOMEM); 654 memset(s->mbintra_table, 1, mb_array_size); 655 656 return !CONFIG_MPEGVIDEODEC || s->encoding ? 0 : ff_mpeg_er_init(s); 657} 658 659static void clear_context(MpegEncContext *s) 660{ 661 int i, j, k; 662 663 memset(&s->next_picture, 0, sizeof(s->next_picture)); 664 memset(&s->last_picture, 0, sizeof(s->last_picture)); 665 memset(&s->current_picture, 0, sizeof(s->current_picture)); 666 memset(&s->new_picture, 0, sizeof(s->new_picture)); 667 668 memset(s->thread_context, 0, sizeof(s->thread_context)); 669 670 s->me.map = NULL; 671 s->me.score_map = NULL; 672 s->dct_error_sum = NULL; 673 s->block = NULL; 674 s->blocks = NULL; 675 memset(s->pblocks, 0, sizeof(s->pblocks)); 676 s->ac_val_base = NULL; 677 s->ac_val[0] = 678 s->ac_val[1] = 679 s->ac_val[2] =NULL; 680 s->sc.edge_emu_buffer = NULL; 681 s->me.scratchpad = NULL; 682 s->me.temp = 683 s->sc.rd_scratchpad = 684 s->sc.b_scratchpad = 685 s->sc.obmc_scratchpad = NULL; 686 687 688 s->bitstream_buffer = NULL; 689 s->allocated_bitstream_buffer_size = 0; 690 s->picture = NULL; 691 s->mb_type = NULL; 692 s->p_mv_table_base = NULL; 693 s->b_forw_mv_table_base = NULL; 694 s->b_back_mv_table_base = NULL; 695 s->b_bidir_forw_mv_table_base = NULL; 696 s->b_bidir_back_mv_table_base = NULL; 697 s->b_direct_mv_table_base = NULL; 698 s->p_mv_table = NULL; 699 s->b_forw_mv_table = NULL; 700 s->b_back_mv_table = NULL; 701 s->b_bidir_forw_mv_table = NULL; 702 s->b_bidir_back_mv_table = NULL; 703 s->b_direct_mv_table = NULL; 704 s->b_field_mv_table_base = NULL; 705 s->p_field_mv_table_base = NULL; 706 for (i = 0; i < 2; i++) { 707 for (j = 0; j < 2; j++) { 708 for (k = 0; k < 2; k++) { 709 s->b_field_mv_table[i][j][k] = NULL; 710 } 711 s->b_field_select_table[i][j] = NULL; 712 s->p_field_mv_table[i][j] = NULL; 713 } 714 s->p_field_select_table[i] = NULL; 715 } 716 717 s->dc_val_base = NULL; 718 s->coded_block_base = NULL; 719 s->mbintra_table = NULL; 720 s->cbp_table = NULL; 721 s->pred_dir_table = NULL; 722 723 s->mbskip_table = NULL; 724 725 s->er.error_status_table = NULL; 726 s->er.er_temp_buffer = NULL; 727 s->mb_index2xy = NULL; 728 s->lambda_table = NULL; 729 730 s->cplx_tab = NULL; 731 s->bits_tab = NULL; 732} 733 734/** 735 * init common structure for both encoder and decoder. 736 * this assumes that some variables like width/height are already set 737 */ 738av_cold int ff_mpv_common_init(MpegEncContext *s) 739{ 740 int i, ret; 741 int nb_slices = (HAVE_THREADS && 742 s->avctx->active_thread_type & FF_THREAD_SLICE) ? 743 s->avctx->thread_count : 1; 744 745 clear_context(s); 746 747 if (s->encoding && s->avctx->slices) 748 nb_slices = s->avctx->slices; 749 750 if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence) 751 s->mb_height = (s->height + 31) / 32 * 2; 752 else 753 s->mb_height = (s->height + 15) / 16; 754 755 if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) { 756 av_log(s->avctx, AV_LOG_ERROR, 757 "decoding to AV_PIX_FMT_NONE is not supported.\n"); 758 return AVERROR(EINVAL); 759 } 760 761 if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) { 762 int max_slices; 763 if (s->mb_height) 764 max_slices = FFMIN(MAX_THREADS, s->mb_height); 765 else 766 max_slices = MAX_THREADS; 767 av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d)," 768 " reducing to %d\n", nb_slices, max_slices); 769 nb_slices = max_slices; 770 } 771 772 if ((s->width || s->height) && 773 av_image_check_size(s->width, s->height, 0, s->avctx)) 774 return AVERROR(EINVAL); 775 776 dct_init(s); 777 778 /* set chroma shifts */ 779 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, 780 &s->chroma_x_shift, 781 &s->chroma_y_shift); 782 if (ret) 783 return ret; 784 785 if (!FF_ALLOCZ_TYPED_ARRAY(s->picture, MAX_PICTURE_COUNT)) 786 return AVERROR(ENOMEM); 787 for (i = 0; i < MAX_PICTURE_COUNT; i++) { 788 s->picture[i].f = av_frame_alloc(); 789 if (!s->picture[i].f) 790 goto fail_nomem; 791 } 792 793 if (!(s->next_picture.f = av_frame_alloc()) || 794 !(s->last_picture.f = av_frame_alloc()) || 795 !(s->current_picture.f = av_frame_alloc()) || 796 !(s->new_picture = av_frame_alloc())) 797 goto fail_nomem; 798 799 if ((ret = ff_mpv_init_context_frame(s))) 800 goto fail; 801 802#if FF_API_FLAG_TRUNCATED 803 s->parse_context.state = -1; 804#endif 805 806 s->context_initialized = 1; 807 memset(s->thread_context, 0, sizeof(s->thread_context)); 808 s->thread_context[0] = s; 809 s->slice_context_count = nb_slices; 810 811// if (s->width && s->height) { 812 ret = ff_mpv_init_duplicate_contexts(s); 813 if (ret < 0) 814 goto fail; 815// } 816 817 return 0; 818 fail_nomem: 819 ret = AVERROR(ENOMEM); 820 fail: 821 ff_mpv_common_end(s); 822 return ret; 823} 824 825void ff_mpv_free_context_frame(MpegEncContext *s) 826{ 827 int i, j, k; 828 829 free_duplicate_contexts(s); 830 831 av_freep(&s->mb_type); 832 av_freep(&s->p_mv_table_base); 833 av_freep(&s->b_forw_mv_table_base); 834 av_freep(&s->b_back_mv_table_base); 835 av_freep(&s->b_bidir_forw_mv_table_base); 836 av_freep(&s->b_bidir_back_mv_table_base); 837 av_freep(&s->b_direct_mv_table_base); 838 s->p_mv_table = NULL; 839 s->b_forw_mv_table = NULL; 840 s->b_back_mv_table = NULL; 841 s->b_bidir_forw_mv_table = NULL; 842 s->b_bidir_back_mv_table = NULL; 843 s->b_direct_mv_table = NULL; 844 av_freep(&s->b_field_mv_table_base); 845 av_freep(&s->b_field_select_table[0][0]); 846 av_freep(&s->p_field_mv_table_base); 847 av_freep(&s->p_field_select_table[0]); 848 for (i = 0; i < 2; i++) { 849 for (j = 0; j < 2; j++) { 850 for (k = 0; k < 2; k++) { 851 s->b_field_mv_table[i][j][k] = NULL; 852 } 853 s->b_field_select_table[i][j] = NULL; 854 s->p_field_mv_table[i][j] = NULL; 855 } 856 s->p_field_select_table[i] = NULL; 857 } 858 859 av_freep(&s->dc_val_base); 860 av_freep(&s->coded_block_base); 861 av_freep(&s->mbintra_table); 862 av_freep(&s->cbp_table); 863 av_freep(&s->pred_dir_table); 864 865 av_freep(&s->mbskip_table); 866 867 av_freep(&s->er.error_status_table); 868 av_freep(&s->er.er_temp_buffer); 869 av_freep(&s->mb_index2xy); 870 av_freep(&s->lambda_table); 871 872 av_freep(&s->cplx_tab); 873 av_freep(&s->bits_tab); 874 875 s->linesize = s->uvlinesize = 0; 876} 877 878/* init common structure for both encoder and decoder */ 879void ff_mpv_common_end(MpegEncContext *s) 880{ 881 if (!s) 882 return; 883 884 ff_mpv_free_context_frame(s); 885 if (s->slice_context_count > 1) 886 s->slice_context_count = 1; 887 888#if FF_API_FLAG_TRUNCATED 889 av_freep(&s->parse_context.buffer); 890 s->parse_context.buffer_size = 0; 891#endif 892 893 av_freep(&s->bitstream_buffer); 894 s->allocated_bitstream_buffer_size = 0; 895 896 if (!s->avctx) 897 return; 898 899 if (s->picture) { 900 for (int i = 0; i < MAX_PICTURE_COUNT; i++) 901 ff_mpv_picture_free(s->avctx, &s->picture[i]); 902 } 903 av_freep(&s->picture); 904 ff_mpv_picture_free(s->avctx, &s->last_picture); 905 ff_mpv_picture_free(s->avctx, &s->current_picture); 906 ff_mpv_picture_free(s->avctx, &s->next_picture); 907 av_frame_free(&s->new_picture); 908 909 s->context_initialized = 0; 910 s->context_reinit = 0; 911 s->last_picture_ptr = 912 s->next_picture_ptr = 913 s->current_picture_ptr = NULL; 914 s->linesize = s->uvlinesize = 0; 915} 916 917 918static inline int hpel_motion_lowres(MpegEncContext *s, 919 uint8_t *dest, uint8_t *src, 920 int field_based, int field_select, 921 int src_x, int src_y, 922 int width, int height, ptrdiff_t stride, 923 int h_edge_pos, int v_edge_pos, 924 int w, int h, h264_chroma_mc_func *pix_op, 925 int motion_x, int motion_y) 926{ 927 const int lowres = s->avctx->lowres; 928 const int op_index = FFMIN(lowres, 3); 929 const int s_mask = (2 << lowres) - 1; 930 int emu = 0; 931 int sx, sy; 932 933 if (s->quarter_sample) { 934 motion_x /= 2; 935 motion_y /= 2; 936 } 937 938 sx = motion_x & s_mask; 939 sy = motion_y & s_mask; 940 src_x += motion_x >> lowres + 1; 941 src_y += motion_y >> lowres + 1; 942 943 src += src_y * stride + src_x; 944 945 if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) || 946 (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) { 947 s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, src, 948 s->linesize, s->linesize, 949 w + 1, (h + 1) << field_based, 950 src_x, src_y << field_based, 951 h_edge_pos, v_edge_pos); 952 src = s->sc.edge_emu_buffer; 953 emu = 1; 954 } 955 956 sx = (sx << 2) >> lowres; 957 sy = (sy << 2) >> lowres; 958 if (field_select) 959 src += s->linesize; 960 pix_op[op_index](dest, src, stride, h, sx, sy); 961 return emu; 962} 963 964/* apply one mpeg motion vector to the three components */ 965static av_always_inline void mpeg_motion_lowres(MpegEncContext *s, 966 uint8_t *dest_y, 967 uint8_t *dest_cb, 968 uint8_t *dest_cr, 969 int field_based, 970 int bottom_field, 971 int field_select, 972 uint8_t **ref_picture, 973 h264_chroma_mc_func *pix_op, 974 int motion_x, int motion_y, 975 int h, int mb_y) 976{ 977 uint8_t *ptr_y, *ptr_cb, *ptr_cr; 978 int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy; 979 ptrdiff_t uvlinesize, linesize; 980 const int lowres = s->avctx->lowres; 981 const int op_index = FFMIN(lowres-1+s->chroma_x_shift, 3); 982 const int block_s = 8>>lowres; 983 const int s_mask = (2 << lowres) - 1; 984 const int h_edge_pos = s->h_edge_pos >> lowres; 985 const int v_edge_pos = s->v_edge_pos >> lowres; 986 linesize = s->current_picture.f->linesize[0] << field_based; 987 uvlinesize = s->current_picture.f->linesize[1] << field_based; 988 989 // FIXME obviously not perfect but qpel will not work in lowres anyway 990 if (s->quarter_sample) { 991 motion_x /= 2; 992 motion_y /= 2; 993 } 994 995 if(field_based){ 996 motion_y += (bottom_field - field_select)*((1 << lowres)-1); 997 } 998 999 sx = motion_x & s_mask; 1000 sy = motion_y & s_mask; 1001 src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1); 1002 src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1); 1003 1004 if (s->out_format == FMT_H263) { 1005 uvsx = ((motion_x >> 1) & s_mask) | (sx & 1); 1006 uvsy = ((motion_y >> 1) & s_mask) | (sy & 1); 1007 uvsrc_x = src_x >> 1; 1008 uvsrc_y = src_y >> 1; 1009 } else if (s->out_format == FMT_H261) { 1010 // even chroma mv's are full pel in H261 1011 mx = motion_x / 4; 1012 my = motion_y / 4; 1013 uvsx = (2 * mx) & s_mask; 1014 uvsy = (2 * my) & s_mask; 1015 uvsrc_x = s->mb_x * block_s + (mx >> lowres); 1016 uvsrc_y = mb_y * block_s + (my >> lowres); 1017 } else { 1018 if(s->chroma_y_shift){ 1019 mx = motion_x / 2; 1020 my = motion_y / 2; 1021 uvsx = mx & s_mask; 1022 uvsy = my & s_mask; 1023 uvsrc_x = s->mb_x * block_s + (mx >> lowres + 1); 1024 uvsrc_y = (mb_y * block_s >> field_based) + (my >> lowres + 1); 1025 } else { 1026 if(s->chroma_x_shift){ 1027 //Chroma422 1028 mx = motion_x / 2; 1029 uvsx = mx & s_mask; 1030 uvsy = motion_y & s_mask; 1031 uvsrc_y = src_y; 1032 uvsrc_x = s->mb_x*block_s + (mx >> (lowres+1)); 1033 } else { 1034 //Chroma444 1035 uvsx = motion_x & s_mask; 1036 uvsy = motion_y & s_mask; 1037 uvsrc_x = src_x; 1038 uvsrc_y = src_y; 1039 } 1040 } 1041 } 1042 1043 ptr_y = ref_picture[0] + src_y * linesize + src_x; 1044 ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x; 1045 ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x; 1046 1047 if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s, 0) || uvsrc_y<0 || 1048 (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) { 1049 s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr_y, 1050 linesize >> field_based, linesize >> field_based, 1051 17, 17 + field_based, 1052 src_x, src_y << field_based, h_edge_pos, 1053 v_edge_pos); 1054 ptr_y = s->sc.edge_emu_buffer; 1055 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) { 1056 uint8_t *ubuf = s->sc.edge_emu_buffer + 18 * s->linesize; 1057 uint8_t *vbuf =ubuf + 10 * s->uvlinesize; 1058 if (s->workaround_bugs & FF_BUG_IEDGE) 1059 vbuf -= s->uvlinesize; 1060 s->vdsp.emulated_edge_mc(ubuf, ptr_cb, 1061 uvlinesize >> field_based, uvlinesize >> field_based, 1062 9, 9 + field_based, 1063 uvsrc_x, uvsrc_y << field_based, 1064 h_edge_pos >> 1, v_edge_pos >> 1); 1065 s->vdsp.emulated_edge_mc(vbuf, ptr_cr, 1066 uvlinesize >> field_based,uvlinesize >> field_based, 1067 9, 9 + field_based, 1068 uvsrc_x, uvsrc_y << field_based, 1069 h_edge_pos >> 1, v_edge_pos >> 1); 1070 ptr_cb = ubuf; 1071 ptr_cr = vbuf; 1072 } 1073 } 1074 1075 // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f->data 1076 if (bottom_field) { 1077 dest_y += s->linesize; 1078 dest_cb += s->uvlinesize; 1079 dest_cr += s->uvlinesize; 1080 } 1081 1082 if (field_select) { 1083 ptr_y += s->linesize; 1084 ptr_cb += s->uvlinesize; 1085 ptr_cr += s->uvlinesize; 1086 } 1087 1088 sx = (sx << 2) >> lowres; 1089 sy = (sy << 2) >> lowres; 1090 pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy); 1091 1092 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) { 1093 int hc = s->chroma_y_shift ? (h+1-bottom_field)>>1 : h; 1094 uvsx = (uvsx << 2) >> lowres; 1095 uvsy = (uvsy << 2) >> lowres; 1096 if (hc) { 1097 pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy); 1098 pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy); 1099 } 1100 } 1101 // FIXME h261 lowres loop filter 1102} 1103 1104static inline void chroma_4mv_motion_lowres(MpegEncContext *s, 1105 uint8_t *dest_cb, uint8_t *dest_cr, 1106 uint8_t **ref_picture, 1107 h264_chroma_mc_func * pix_op, 1108 int mx, int my) 1109{ 1110 const int lowres = s->avctx->lowres; 1111 const int op_index = FFMIN(lowres, 3); 1112 const int block_s = 8 >> lowres; 1113 const int s_mask = (2 << lowres) - 1; 1114 const int h_edge_pos = s->h_edge_pos >> lowres + 1; 1115 const int v_edge_pos = s->v_edge_pos >> lowres + 1; 1116 int emu = 0, src_x, src_y, sx, sy; 1117 ptrdiff_t offset; 1118 uint8_t *ptr; 1119 1120 if (s->quarter_sample) { 1121 mx /= 2; 1122 my /= 2; 1123 } 1124 1125 /* In case of 8X8, we construct a single chroma motion vector 1126 with a special rounding */ 1127 mx = ff_h263_round_chroma(mx); 1128 my = ff_h263_round_chroma(my); 1129 1130 sx = mx & s_mask; 1131 sy = my & s_mask; 1132 src_x = s->mb_x * block_s + (mx >> lowres + 1); 1133 src_y = s->mb_y * block_s + (my >> lowres + 1); 1134 1135 offset = src_y * s->uvlinesize + src_x; 1136 ptr = ref_picture[1] + offset; 1137 if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) || 1138 (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) { 1139 s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr, 1140 s->uvlinesize, s->uvlinesize, 1141 9, 9, 1142 src_x, src_y, h_edge_pos, v_edge_pos); 1143 ptr = s->sc.edge_emu_buffer; 1144 emu = 1; 1145 } 1146 sx = (sx << 2) >> lowres; 1147 sy = (sy << 2) >> lowres; 1148 pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy); 1149 1150 ptr = ref_picture[2] + offset; 1151 if (emu) { 1152 s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr, 1153 s->uvlinesize, s->uvlinesize, 1154 9, 9, 1155 src_x, src_y, h_edge_pos, v_edge_pos); 1156 ptr = s->sc.edge_emu_buffer; 1157 } 1158 pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy); 1159} 1160 1161/** 1162 * motion compensation of a single macroblock 1163 * @param s context 1164 * @param dest_y luma destination pointer 1165 * @param dest_cb chroma cb/u destination pointer 1166 * @param dest_cr chroma cr/v destination pointer 1167 * @param dir direction (0->forward, 1->backward) 1168 * @param ref_picture array[3] of pointers to the 3 planes of the reference picture 1169 * @param pix_op halfpel motion compensation function (average or put normally) 1170 * the motion vectors are taken from s->mv and the MV type from s->mv_type 1171 */ 1172static inline void MPV_motion_lowres(MpegEncContext *s, 1173 uint8_t *dest_y, uint8_t *dest_cb, 1174 uint8_t *dest_cr, 1175 int dir, uint8_t **ref_picture, 1176 h264_chroma_mc_func *pix_op) 1177{ 1178 int mx, my; 1179 int mb_x, mb_y, i; 1180 const int lowres = s->avctx->lowres; 1181 const int block_s = 8 >>lowres; 1182 1183 mb_x = s->mb_x; 1184 mb_y = s->mb_y; 1185 1186 switch (s->mv_type) { 1187 case MV_TYPE_16X16: 1188 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 1189 0, 0, 0, 1190 ref_picture, pix_op, 1191 s->mv[dir][0][0], s->mv[dir][0][1], 1192 2 * block_s, mb_y); 1193 break; 1194 case MV_TYPE_8X8: 1195 mx = 0; 1196 my = 0; 1197 for (i = 0; i < 4; i++) { 1198 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * 1199 s->linesize) * block_s, 1200 ref_picture[0], 0, 0, 1201 (2 * mb_x + (i & 1)) * block_s, 1202 (2 * mb_y + (i >> 1)) * block_s, 1203 s->width, s->height, s->linesize, 1204 s->h_edge_pos >> lowres, s->v_edge_pos >> lowres, 1205 block_s, block_s, pix_op, 1206 s->mv[dir][i][0], s->mv[dir][i][1]); 1207 1208 mx += s->mv[dir][i][0]; 1209 my += s->mv[dir][i][1]; 1210 } 1211 1212 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) 1213 chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, 1214 pix_op, mx, my); 1215 break; 1216 case MV_TYPE_FIELD: 1217 if (s->picture_structure == PICT_FRAME) { 1218 /* top field */ 1219 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 1220 1, 0, s->field_select[dir][0], 1221 ref_picture, pix_op, 1222 s->mv[dir][0][0], s->mv[dir][0][1], 1223 block_s, mb_y); 1224 /* bottom field */ 1225 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 1226 1, 1, s->field_select[dir][1], 1227 ref_picture, pix_op, 1228 s->mv[dir][1][0], s->mv[dir][1][1], 1229 block_s, mb_y); 1230 } else { 1231 if (s->picture_structure != s->field_select[dir][0] + 1 && 1232 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) { 1233 ref_picture = s->current_picture_ptr->f->data; 1234 1235 } 1236 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 1237 0, 0, s->field_select[dir][0], 1238 ref_picture, pix_op, 1239 s->mv[dir][0][0], 1240 s->mv[dir][0][1], 2 * block_s, mb_y >> 1); 1241 } 1242 break; 1243 case MV_TYPE_16X8: 1244 for (i = 0; i < 2; i++) { 1245 uint8_t **ref2picture; 1246 1247 if (s->picture_structure == s->field_select[dir][i] + 1 || 1248 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) { 1249 ref2picture = ref_picture; 1250 } else { 1251 ref2picture = s->current_picture_ptr->f->data; 1252 } 1253 1254 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 1255 0, 0, s->field_select[dir][i], 1256 ref2picture, pix_op, 1257 s->mv[dir][i][0], s->mv[dir][i][1] + 1258 2 * block_s * i, block_s, mb_y >> 1); 1259 1260 dest_y += 2 * block_s * s->linesize; 1261 dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize; 1262 dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize; 1263 } 1264 break; 1265 case MV_TYPE_DMV: 1266 if (s->picture_structure == PICT_FRAME) { 1267 for (i = 0; i < 2; i++) { 1268 int j; 1269 for (j = 0; j < 2; j++) { 1270 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 1271 1, j, j ^ i, 1272 ref_picture, pix_op, 1273 s->mv[dir][2 * i + j][0], 1274 s->mv[dir][2 * i + j][1], 1275 block_s, mb_y); 1276 } 1277 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab; 1278 } 1279 } else { 1280 for (i = 0; i < 2; i++) { 1281 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr, 1282 0, 0, s->picture_structure != i + 1, 1283 ref_picture, pix_op, 1284 s->mv[dir][2 * i][0],s->mv[dir][2 * i][1], 1285 2 * block_s, mb_y >> 1); 1286 1287 // after put we make avg of the same block 1288 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab; 1289 1290 // opposite parity is always in the same 1291 // frame if this is second field 1292 if (!s->first_field) { 1293 ref_picture = s->current_picture_ptr->f->data; 1294 } 1295 } 1296 } 1297 break; 1298 default: 1299 av_assert2(0); 1300 } 1301} 1302 1303/** 1304 * find the lowest MB row referenced in the MVs 1305 */ 1306static int lowest_referenced_row(MpegEncContext *s, int dir) 1307{ 1308 int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample; 1309 int my, off, i, mvs; 1310 1311 if (s->picture_structure != PICT_FRAME || s->mcsel) 1312 goto unhandled; 1313 1314 switch (s->mv_type) { 1315 case MV_TYPE_16X16: 1316 mvs = 1; 1317 break; 1318 case MV_TYPE_16X8: 1319 mvs = 2; 1320 break; 1321 case MV_TYPE_8X8: 1322 mvs = 4; 1323 break; 1324 default: 1325 goto unhandled; 1326 } 1327 1328 for (i = 0; i < mvs; i++) { 1329 my = s->mv[dir][i][1]; 1330 my_max = FFMAX(my_max, my); 1331 my_min = FFMIN(my_min, my); 1332 } 1333 1334 off = ((FFMAX(-my_min, my_max)<<qpel_shift) + 63) >> 6; 1335 1336 return av_clip(s->mb_y + off, 0, s->mb_height - 1); 1337unhandled: 1338 return s->mb_height-1; 1339} 1340 1341/* put block[] to dest[] */ 1342static inline void put_dct(MpegEncContext *s, 1343 int16_t *block, int i, uint8_t *dest, int line_size, int qscale) 1344{ 1345 s->dct_unquantize_intra(s, block, i, qscale); 1346 s->idsp.idct_put(dest, line_size, block); 1347} 1348 1349/* add block[] to dest[] */ 1350static inline void add_dct(MpegEncContext *s, 1351 int16_t *block, int i, uint8_t *dest, int line_size) 1352{ 1353 if (s->block_last_index[i] >= 0) { 1354 s->idsp.idct_add(dest, line_size, block); 1355 } 1356} 1357 1358static inline void add_dequant_dct(MpegEncContext *s, 1359 int16_t *block, int i, uint8_t *dest, int line_size, int qscale) 1360{ 1361 if (s->block_last_index[i] >= 0) { 1362 s->dct_unquantize_inter(s, block, i, qscale); 1363 1364 s->idsp.idct_add(dest, line_size, block); 1365 } 1366} 1367 1368/** 1369 * Clean dc, ac, coded_block for the current non-intra MB. 1370 */ 1371void ff_clean_intra_table_entries(MpegEncContext *s) 1372{ 1373 int wrap = s->b8_stride; 1374 int xy = s->block_index[0]; 1375 1376 s->dc_val[0][xy ] = 1377 s->dc_val[0][xy + 1 ] = 1378 s->dc_val[0][xy + wrap] = 1379 s->dc_val[0][xy + 1 + wrap] = 1024; 1380 /* ac pred */ 1381 memset(s->ac_val[0][xy ], 0, 32 * sizeof(int16_t)); 1382 memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t)); 1383 if (s->msmpeg4_version>=3) { 1384 s->coded_block[xy ] = 1385 s->coded_block[xy + 1 ] = 1386 s->coded_block[xy + wrap] = 1387 s->coded_block[xy + 1 + wrap] = 0; 1388 } 1389 /* chroma */ 1390 wrap = s->mb_stride; 1391 xy = s->mb_x + s->mb_y * wrap; 1392 s->dc_val[1][xy] = 1393 s->dc_val[2][xy] = 1024; 1394 /* ac pred */ 1395 memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t)); 1396 memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t)); 1397 1398 s->mbintra_table[xy]= 0; 1399} 1400 1401/* generic function called after a macroblock has been parsed by the 1402 decoder or after it has been encoded by the encoder. 1403 1404 Important variables used: 1405 s->mb_intra : true if intra macroblock 1406 s->mv_dir : motion vector direction 1407 s->mv_type : motion vector type 1408 s->mv : motion vector 1409 s->interlaced_dct : true if interlaced dct used (mpeg2) 1410 */ 1411static av_always_inline 1412void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64], 1413 int lowres_flag, int is_mpeg12) 1414{ 1415#define IS_ENCODER(s) (CONFIG_MPEGVIDEOENC && !lowres_flag && (s)->encoding) 1416#define IS_MPEG12(s) (CONFIG_SMALL ? ((s)->out_format == FMT_MPEG1) : is_mpeg12) 1417 const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; 1418 1419 s->current_picture.qscale_table[mb_xy] = s->qscale; 1420 1421 /* update DC predictors for P macroblocks */ 1422 if (!s->mb_intra) { 1423 if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) { 1424 if(s->mbintra_table[mb_xy]) 1425 ff_clean_intra_table_entries(s); 1426 } else { 1427 s->last_dc[0] = 1428 s->last_dc[1] = 1429 s->last_dc[2] = 128 << s->intra_dc_precision; 1430 } 1431 } 1432 else if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) 1433 s->mbintra_table[mb_xy]=1; 1434 1435 if (!IS_ENCODER(s) || (s->avctx->flags & AV_CODEC_FLAG_PSNR) || s->frame_skip_threshold || s->frame_skip_factor || 1436 !((s->intra_only || s->pict_type == AV_PICTURE_TYPE_B) && 1437 s->avctx->mb_decision != FF_MB_DECISION_RD)) { // FIXME precalc 1438 uint8_t *dest_y, *dest_cb, *dest_cr; 1439 int dct_linesize, dct_offset; 1440 op_pixels_func (*op_pix)[4]; 1441 qpel_mc_func (*op_qpix)[16]; 1442 const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics 1443 const int uvlinesize = s->current_picture.f->linesize[1]; 1444 const int readable = s->pict_type != AV_PICTURE_TYPE_B || IS_ENCODER(s) || s->avctx->draw_horiz_band || lowres_flag; 1445 const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8; 1446 1447 /* avoid copy if macroblock skipped in last frame too */ 1448 /* skip only during decoding as we might trash the buffers during encoding a bit */ 1449 if (!IS_ENCODER(s)) { 1450 uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy]; 1451 1452 if (s->mb_skipped) { 1453 s->mb_skipped= 0; 1454 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I); 1455 *mbskip_ptr = 1; 1456 } else if(!s->current_picture.reference) { 1457 *mbskip_ptr = 1; 1458 } else{ 1459 *mbskip_ptr = 0; /* not skipped */ 1460 } 1461 } 1462 1463 dct_linesize = linesize << s->interlaced_dct; 1464 dct_offset = s->interlaced_dct ? linesize : linesize * block_size; 1465 1466 if(readable){ 1467 dest_y= s->dest[0]; 1468 dest_cb= s->dest[1]; 1469 dest_cr= s->dest[2]; 1470 }else{ 1471 dest_y = s->sc.b_scratchpad; 1472 dest_cb= s->sc.b_scratchpad+16*linesize; 1473 dest_cr= s->sc.b_scratchpad+32*linesize; 1474 } 1475 1476 if (!s->mb_intra) { 1477 /* motion handling */ 1478 /* decoding or more than one mb_type (MC was already done otherwise) */ 1479 if (!IS_ENCODER(s)) { 1480 1481 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) { 1482 if (s->mv_dir & MV_DIR_FORWARD) { 1483 ff_thread_await_progress(&s->last_picture_ptr->tf, 1484 lowest_referenced_row(s, 0), 1485 0); 1486 } 1487 if (s->mv_dir & MV_DIR_BACKWARD) { 1488 ff_thread_await_progress(&s->next_picture_ptr->tf, 1489 lowest_referenced_row(s, 1), 1490 0); 1491 } 1492 } 1493 1494 if(lowres_flag){ 1495 h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab; 1496 1497 if (s->mv_dir & MV_DIR_FORWARD) { 1498 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix); 1499 op_pix = s->h264chroma.avg_h264_chroma_pixels_tab; 1500 } 1501 if (s->mv_dir & MV_DIR_BACKWARD) { 1502 MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix); 1503 } 1504 }else{ 1505 op_qpix = s->me.qpel_put; 1506 if ((is_mpeg12 || !s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) { 1507 op_pix = s->hdsp.put_pixels_tab; 1508 }else{ 1509 op_pix = s->hdsp.put_no_rnd_pixels_tab; 1510 } 1511 if (s->mv_dir & MV_DIR_FORWARD) { 1512 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix); 1513 op_pix = s->hdsp.avg_pixels_tab; 1514 op_qpix= s->me.qpel_avg; 1515 } 1516 if (s->mv_dir & MV_DIR_BACKWARD) { 1517 ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix); 1518 } 1519 } 1520 } 1521 1522 /* skip dequant / idct if we are really late ;) */ 1523 if(s->avctx->skip_idct){ 1524 if( (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) 1525 ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) 1526 || s->avctx->skip_idct >= AVDISCARD_ALL) 1527 goto skip_idct; 1528 } 1529 1530 /* add dct residue */ 1531 if (IS_ENCODER(s) || !(IS_MPEG12(s) || s->msmpeg4_version 1532 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){ 1533 add_dequant_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale); 1534 add_dequant_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale); 1535 add_dequant_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale); 1536 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale); 1537 1538 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) { 1539 if (s->chroma_y_shift){ 1540 add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); 1541 add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); 1542 }else{ 1543 dct_linesize >>= 1; 1544 dct_offset >>=1; 1545 add_dequant_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale); 1546 add_dequant_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale); 1547 add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale); 1548 add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale); 1549 } 1550 } 1551 } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){ 1552 add_dct(s, block[0], 0, dest_y , dct_linesize); 1553 add_dct(s, block[1], 1, dest_y + block_size, dct_linesize); 1554 add_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize); 1555 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize); 1556 1557 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) { 1558 if(s->chroma_y_shift){//Chroma420 1559 add_dct(s, block[4], 4, dest_cb, uvlinesize); 1560 add_dct(s, block[5], 5, dest_cr, uvlinesize); 1561 }else{ 1562 //chroma422 1563 dct_linesize = uvlinesize << s->interlaced_dct; 1564 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size; 1565 1566 add_dct(s, block[4], 4, dest_cb, dct_linesize); 1567 add_dct(s, block[5], 5, dest_cr, dct_linesize); 1568 add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize); 1569 add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize); 1570 if(!s->chroma_x_shift){//Chroma444 1571 add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize); 1572 add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize); 1573 add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize); 1574 add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize); 1575 } 1576 } 1577 }//fi gray 1578 } else if (CONFIG_WMV2_DECODER) { 1579 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr); 1580 } 1581 } else { 1582 /* Only MPEG-4 Simple Studio Profile is supported in > 8-bit mode. 1583 TODO: Integrate 10-bit properly into mpegvideo.c so that ER works properly */ 1584 if (!is_mpeg12 && CONFIG_MPEG4_DECODER && /* s->codec_id == AV_CODEC_ID_MPEG4 && */ 1585 s->avctx->bits_per_raw_sample > 8) { 1586 ff_mpeg4_decode_studio(s, dest_y, dest_cb, dest_cr, block_size, 1587 uvlinesize, dct_linesize, dct_offset); 1588 } 1589 /* dct only in intra block */ 1590 else if (IS_ENCODER(s) || !IS_MPEG12(s)) { 1591 put_dct(s, block[0], 0, dest_y , dct_linesize, s->qscale); 1592 put_dct(s, block[1], 1, dest_y + block_size, dct_linesize, s->qscale); 1593 put_dct(s, block[2], 2, dest_y + dct_offset , dct_linesize, s->qscale); 1594 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale); 1595 1596 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) { 1597 if(s->chroma_y_shift){ 1598 put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale); 1599 put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale); 1600 }else{ 1601 dct_offset >>=1; 1602 dct_linesize >>=1; 1603 put_dct(s, block[4], 4, dest_cb, dct_linesize, s->chroma_qscale); 1604 put_dct(s, block[5], 5, dest_cr, dct_linesize, s->chroma_qscale); 1605 put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale); 1606 put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale); 1607 } 1608 } 1609 }else{ 1610 s->idsp.idct_put(dest_y, dct_linesize, block[0]); 1611 s->idsp.idct_put(dest_y + block_size, dct_linesize, block[1]); 1612 s->idsp.idct_put(dest_y + dct_offset, dct_linesize, block[2]); 1613 s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]); 1614 1615 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) { 1616 if(s->chroma_y_shift){ 1617 s->idsp.idct_put(dest_cb, uvlinesize, block[4]); 1618 s->idsp.idct_put(dest_cr, uvlinesize, block[5]); 1619 }else{ 1620 1621 dct_linesize = uvlinesize << s->interlaced_dct; 1622 dct_offset = s->interlaced_dct ? uvlinesize : uvlinesize*block_size; 1623 1624 s->idsp.idct_put(dest_cb, dct_linesize, block[4]); 1625 s->idsp.idct_put(dest_cr, dct_linesize, block[5]); 1626 s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]); 1627 s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]); 1628 if(!s->chroma_x_shift){//Chroma444 1629 s->idsp.idct_put(dest_cb + block_size, dct_linesize, block[8]); 1630 s->idsp.idct_put(dest_cr + block_size, dct_linesize, block[9]); 1631 s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]); 1632 s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]); 1633 } 1634 } 1635 }//gray 1636 } 1637 } 1638skip_idct: 1639 if(!readable){ 1640 s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y , linesize,16); 1641 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) { 1642 s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift); 1643 s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift); 1644 } 1645 } 1646 } 1647} 1648 1649void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64]) 1650{ 1651 if (s->avctx->debug & FF_DEBUG_DCT_COEFF) { 1652 /* print DCT coefficients */ 1653 av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y); 1654 for (int i = 0; i < 6; i++) { 1655 for (int j = 0; j < 64; j++) { 1656 av_log(s->avctx, AV_LOG_DEBUG, "%5d", 1657 block[i][s->idsp.idct_permutation[j]]); 1658 } 1659 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 1660 } 1661 } 1662 1663#if !CONFIG_SMALL 1664 if(s->out_format == FMT_MPEG1) { 1665 if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 1); 1666 else mpv_reconstruct_mb_internal(s, block, 0, 1); 1667 } else 1668#endif 1669 if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 0); 1670 else mpv_reconstruct_mb_internal(s, block, 0, 0); 1671} 1672 1673void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename 1674 const int linesize = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics 1675 const int uvlinesize = s->current_picture.f->linesize[1]; 1676 const int width_of_mb = (4 + (s->avctx->bits_per_raw_sample > 8)) - s->avctx->lowres; 1677 const int height_of_mb = 4 - s->avctx->lowres; 1678 1679 s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2; 1680 s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2; 1681 s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2; 1682 s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2; 1683 s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1; 1684 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; 1685 //block_index is not used by mpeg2, so it is not affected by chroma_format 1686 1687 s->dest[0] = s->current_picture.f->data[0] + (int)((s->mb_x - 1U) << width_of_mb); 1688 s->dest[1] = s->current_picture.f->data[1] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift)); 1689 s->dest[2] = s->current_picture.f->data[2] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift)); 1690 1691 if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME)) 1692 { 1693 if(s->picture_structure==PICT_FRAME){ 1694 s->dest[0] += s->mb_y * linesize << height_of_mb; 1695 s->dest[1] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift); 1696 s->dest[2] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift); 1697 }else{ 1698 s->dest[0] += (s->mb_y>>1) * linesize << height_of_mb; 1699 s->dest[1] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift); 1700 s->dest[2] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift); 1701 av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD)); 1702 } 1703 } 1704} 1705 1706/** 1707 * set qscale and update qscale dependent variables. 1708 */ 1709void ff_set_qscale(MpegEncContext * s, int qscale) 1710{ 1711 if (qscale < 1) 1712 qscale = 1; 1713 else if (qscale > 31) 1714 qscale = 31; 1715 1716 s->qscale = qscale; 1717 s->chroma_qscale= s->chroma_qscale_table[qscale]; 1718 1719 s->y_dc_scale= s->y_dc_scale_table[ qscale ]; 1720 s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ]; 1721} 1722