git.sesse.net Git - ffmpeg/blob - libavcodec/vc1_loopfilter.c

   1 /*
   2  * VC-1 and WMV3 decoder
   3  * Copyright (c) 2011 Mashiat Sarker Shakkhar
   4  * Copyright (c) 2006-2007 Konstantin Shishkov
   5  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
   6  *
   7  * This file is part of FFmpeg.
   8  *
   9  * FFmpeg is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * FFmpeg is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with FFmpeg; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 /**
  25  * @file
  26  * VC-1 and WMV3 loopfilter
  27  */
  28
  29 #include "avcodec.h"
  30 #include "mpegvideo.h"
  31 #include "vc1.h"
  32 #include "vc1dsp.h"
  33
  34 void ff_vc1_loop_filter_iblk(VC1Context *v, int pq)
  35 {
  36     MpegEncContext *s = &v->s;
  37     int j;
  38     if (!s->first_slice_line) {
  39         v->vc1dsp.vc1_v_loop_filter16(s->dest[0], s->linesize, pq);
  40         if (s->mb_x)
  41             v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize, s->linesize, pq);
  42         v->vc1dsp.vc1_h_loop_filter16(s->dest[0] - 16 * s->linesize + 8, s->linesize, pq);
  43         if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY))
  44         for (j = 0; j < 2; j++) {
  45             v->vc1dsp.vc1_v_loop_filter8(s->dest[j + 1], s->uvlinesize, pq);
  46             if (s->mb_x)
  47                 v->vc1dsp.vc1_h_loop_filter8(s->dest[j + 1] - 8 * s->uvlinesize, s->uvlinesize, pq);
  48         }
  49     }
  50     v->vc1dsp.vc1_v_loop_filter16(s->dest[0] + 8 * s->linesize, s->linesize, pq);
  51
  52     if (s->mb_y == s->end_mb_y - 1) {
  53         if (s->mb_x) {
  54             v->vc1dsp.vc1_h_loop_filter16(s->dest[0], s->linesize, pq);
  55             if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
  56             v->vc1dsp.vc1_h_loop_filter8(s->dest[1], s->uvlinesize, pq);
  57             v->vc1dsp.vc1_h_loop_filter8(s->dest[2], s->uvlinesize, pq);
  58             }
  59         }
  60         v->vc1dsp.vc1_h_loop_filter16(s->dest[0] + 8, s->linesize, pq);
  61     }
  62 }
  63
  64 static av_always_inline void vc1_h_overlap_filter(VC1Context *v, int16_t (*left_block)[64],
  65                                                   int16_t (*right_block)[64], int block_num)
  66 {
  67     if (left_block != right_block || (block_num & 5) == 1) {
  68         if (block_num > 3)
  69             v->vc1dsp.vc1_h_s_overlap(left_block[block_num], right_block[block_num]);
  70         else if (block_num & 1)
  71             v->vc1dsp.vc1_h_s_overlap(right_block[block_num - 1], right_block[block_num]);
  72         else
  73             v->vc1dsp.vc1_h_s_overlap(left_block[block_num + 1], right_block[block_num]);
  74     }
  75 }
  76
  77 static av_always_inline void vc1_v_overlap_filter(VC1Context *v, int16_t (*top_block)[64],
  78                                                   int16_t (*bottom_block)[64], int block_num)
  79 {
  80     if (top_block != bottom_block || block_num & 2) {
  81         if (block_num > 3)
  82             v->vc1dsp.vc1_v_s_overlap(top_block[block_num], bottom_block[block_num]);
  83         else if (block_num & 2)
  84             v->vc1dsp.vc1_v_s_overlap(bottom_block[block_num - 2], bottom_block[block_num]);
  85         else
  86             v->vc1dsp.vc1_v_s_overlap(top_block[block_num + 2], bottom_block[block_num]);
  87     }
  88 }
  89
  90 void ff_vc1_i_overlap_filter(VC1Context *v)
  91 {
  92     MpegEncContext *s = &v->s;
  93     int16_t (*topleft_blk)[64], (*top_blk)[64], (*left_blk)[64], (*cur_blk)[64];
  94     int block_count = CONFIG_GRAY && (s->avctx->flags & AV_CODEC_FLAG_GRAY) ? 4 : 6;
  95     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
  96     int i;
  97
  98     topleft_blk = v->block[v->topleft_blk_idx];
  99     top_blk = v->block[v->top_blk_idx];
 100     left_blk = v->block[v->left_blk_idx];
 101     cur_blk = v->block[v->cur_blk_idx];
 102
 103     /* Within a MB, the horizontal overlap always runs before the vertical.
 104      * To accomplish that, we run the H on the left and internal vertical
 105      * borders of the currently decoded MB. Then, we wait for the next overlap
 106      * iteration to do H overlap on the right edge of this MB, before moving
 107      * over and running the V overlap on the top and internal horizontal
 108      * borders. Therefore, the H overlap trails by one MB col and the
 109      * V overlap trails by one MB row. This is reflected in the time at which
 110      * we run the put_pixels loop, i.e. delayed by one row and one column. */
 111     for (i = 0; i < block_count; i++)
 112         if (v->pq >= 9 || v->condover == CONDOVER_ALL ||
 113             (v->over_flags_plane[mb_pos] && ((i & 5) == 1 || (s->mb_x && v->over_flags_plane[mb_pos - 1]))))
 114             vc1_h_overlap_filter(v, s->mb_x ? left_blk : cur_blk, cur_blk, i);
 115
 116     if (v->fcm != ILACE_FRAME)
 117         for (i = 0; i < block_count; i++) {
 118             if (s->mb_x && (v->pq >= 9 || v->condover == CONDOVER_ALL ||
 119                 (v->over_flags_plane[mb_pos - 1] &&
 120                  ((i & 2) || (!s->first_slice_line && v->over_flags_plane[mb_pos - 1 - s->mb_stride])))))
 121                 vc1_v_overlap_filter(v, s->first_slice_line ? left_blk : topleft_blk, left_blk, i);
 122             if (s->mb_x == s->mb_width - 1)
 123                 if (v->pq >= 9 || v->condover == CONDOVER_ALL ||
 124                     (v->over_flags_plane[mb_pos] &&
 125                      ((i & 2) || (!s->first_slice_line && v->over_flags_plane[mb_pos - s->mb_stride]))))
 126                     vc1_v_overlap_filter(v, s->first_slice_line ? cur_blk : top_blk, cur_blk, i);
 127         }
 128 }
 129
 130 void ff_vc1_p_overlap_filter(VC1Context *v)
 131 {
 132     MpegEncContext *s = &v->s;
 133     int16_t (*topleft_blk)[64], (*top_blk)[64], (*left_blk)[64], (*cur_blk)[64];
 134     int block_count = CONFIG_GRAY && (s->avctx->flags & AV_CODEC_FLAG_GRAY) ? 4 : 6;
 135     int i;
 136
 137     topleft_blk = v->block[v->topleft_blk_idx];
 138     top_blk = v->block[v->top_blk_idx];
 139     left_blk = v->block[v->left_blk_idx];
 140     cur_blk = v->block[v->cur_blk_idx];
 141
 142     for (i = 0; i < block_count; i++)
 143         if (v->mb_type[0][s->block_index[i]] && (s->mb_x == 0 || v->mb_type[0][s->block_index[i] - 1]))
 144             vc1_h_overlap_filter(v, s->mb_x ? left_blk : cur_blk, cur_blk, i);
 145
 146     if (v->fcm != ILACE_FRAME)
 147         for (i = 0; i < block_count; i++) {
 148             if (s->mb_x && v->mb_type[0][s->block_index[i] - 1] &&
 149                 (s->first_slice_line || v->mb_type[0][s->block_index[i] - s->block_wrap[i] - 1]))
 150                 vc1_v_overlap_filter(v, s->first_slice_line ? left_blk : topleft_blk, left_blk, i);
 151             if (s->mb_x == s->mb_width - 1)
 152                 if (v->mb_type[0][s->block_index[i]] &&
 153                     (s->first_slice_line || v->mb_type[0][s->block_index[i] - s->block_wrap[i]]))
 154                     vc1_v_overlap_filter(v, s->first_slice_line ? cur_blk : top_blk, cur_blk, i);
 155         }
 156 }
 157
 158 #define LEFT_EDGE   (1 << 0)
 159 #define RIGHT_EDGE  (1 << 1)
 160 #define TOP_EDGE    (1 << 2)
 161 #define BOTTOM_EDGE (1 << 3)
 162
 163 static av_always_inline void vc1_i_h_loop_filter(VC1Context *v, uint8_t *dest,
 164                                                  uint32_t flags, int block_num)
 165 {
 166     MpegEncContext *s  = &v->s;
 167     int pq = v->pq;
 168     uint8_t *dst;
 169
 170     if (block_num & 2)
 171         return;
 172
 173     if (!(flags & LEFT_EDGE) || (block_num & 5) == 1) {
 174         if (block_num > 3)
 175             dst = dest;
 176         else
 177             dst = dest + (block_num & 2) * 4 * s->linesize + (block_num & 1) * 8;
 178
 179         if (v->fcm == ILACE_FRAME)
 180             if (block_num > 3) {
 181                 v->vc1dsp.vc1_h_loop_filter4(dst, 2 * s->uvlinesize, pq);
 182                 v->vc1dsp.vc1_h_loop_filter4(dst + s->uvlinesize, 2 * s->uvlinesize, pq);
 183             } else {
 184                 v->vc1dsp.vc1_h_loop_filter8(dst, 2 * s->linesize, pq);
 185                 v->vc1dsp.vc1_h_loop_filter8(dst + s->linesize, 2 * s->linesize, pq);
 186             }
 187         else
 188             if (block_num > 3)
 189                 v->vc1dsp.vc1_h_loop_filter8(dst, s->uvlinesize, pq);
 190             else
 191                 v->vc1dsp.vc1_h_loop_filter16(dst, s->linesize, pq);
 192     }
 193 }
 194
 195 static av_always_inline void vc1_i_v_loop_filter(VC1Context *v, uint8_t *dest,
 196                                                  uint32_t flags, uint8_t fieldtx,
 197                                                  int block_num)
 198 {
 199     MpegEncContext *s  = &v->s;
 200     int pq = v->pq;
 201     uint8_t *dst;
 202
 203     if ((block_num & 5) == 1)
 204         return;
 205
 206     if (!(flags & TOP_EDGE) || block_num & 2) {
 207         if (block_num > 3)
 208             dst = dest;
 209         else
 210             dst = dest + (block_num & 2) * 4 * s->linesize + (block_num & 1) * 8;
 211
 212         if (v->fcm == ILACE_FRAME) {
 213             if (block_num > 3) {
 214                 v->vc1dsp.vc1_v_loop_filter8(dst, 2 * s->uvlinesize, pq);
 215                 v->vc1dsp.vc1_v_loop_filter8(dst + s->uvlinesize, 2 * s->uvlinesize, pq);
 216             } else if (block_num < 2 || !fieldtx) {
 217                 v->vc1dsp.vc1_v_loop_filter16(dst, 2 * s->linesize, pq);
 218                 v->vc1dsp.vc1_v_loop_filter16(dst + s->linesize, 2 * s->linesize, pq);
 219             }
 220         } else
 221             if (block_num > 3)
 222                 v->vc1dsp.vc1_v_loop_filter8(dst, s->uvlinesize, pq);
 223             else
 224                 v->vc1dsp.vc1_v_loop_filter16(dst, s->linesize, pq);
 225     }
 226 }
 227
 228 void ff_vc1_i_loop_filter(VC1Context *v)
 229 {
 230     MpegEncContext *s = &v->s;
 231     int block_count = CONFIG_GRAY && (s->avctx->flags & AV_CODEC_FLAG_GRAY) ? 4 : 6;
 232     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
 233     uint8_t *dest, fieldtx;
 234     uint32_t flags = 0;
 235     int i;
 236
 237     /* Within a MB, the vertical loop filter always runs before the horizontal.
 238      * To accomplish that, we run the V loop filter on top and internal
 239      * horizontal borders of the last overlap filtered MB. Then, we wait for
 240      * the loop filter iteration on the next row to do V loop filter on the
 241      * bottom edge of this MB, before moving over and running the H loop
 242      * filter on the left and internal vertical borders. Therefore, the loop
 243      * filter trails by one row and one column relative to the overlap filter
 244      * and two rows and two colums relative to the decoding loop. */
 245     if (!s->first_slice_line) {
 246         dest = s->dest[0] - 16 * s->linesize - 16;
 247         flags = s->mb_y == s->start_mb_y + 1 ? TOP_EDGE : 0;
 248         if (s->mb_x) {
 249             fieldtx = v->fieldtx_plane[mb_pos - s->mb_stride - 1];
 250             for (i = 0; i < block_count; i++)
 251                 vc1_i_v_loop_filter(v, i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize - 8 : dest, flags, fieldtx, i);
 252         }
 253         if (s->mb_x == s->mb_width - 1) {
 254             dest += 16;
 255             fieldtx = v->fieldtx_plane[mb_pos - s->mb_stride];
 256             for (i = 0; i < block_count; i++)
 257                 vc1_i_v_loop_filter(v, i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize : dest, flags, fieldtx, i);
 258         }
 259     }
 260     if (s->mb_y == s->end_mb_y - 1) {
 261         dest = s->dest[0] - 16;
 262         flags = s->first_slice_line ? TOP_EDGE | BOTTOM_EDGE : BOTTOM_EDGE;
 263         if (s->mb_x) {
 264             fieldtx = v->fieldtx_plane[mb_pos - 1];
 265             for (i = 0; i < block_count; i++)
 266                 vc1_i_v_loop_filter(v, i > 3 ? s->dest[i - 3] - 8 : dest, flags, fieldtx, i);
 267         }
 268         if (s->mb_x == s->mb_width - 1) {
 269             dest += 16;
 270             fieldtx = v->fieldtx_plane[mb_pos];
 271             for (i = 0; i < block_count; i++)
 272                 vc1_i_v_loop_filter(v, i > 3 ? s->dest[i - 3] : dest, flags, fieldtx, i);
 273         }
 274     }
 275
 276     if (s->mb_y >= s->start_mb_y + 2) {
 277         dest = s->dest[0] - 32 * s->linesize - 16;
 278         if (s->mb_x) {
 279             flags = s->mb_x == 1 ? LEFT_EDGE : 0;
 280             for (i = 0; i < block_count; i++)
 281                 vc1_i_h_loop_filter(v, i > 3 ? s->dest[i - 3] - 16 * s->uvlinesize - 8 : dest, flags, i);
 282         }
 283         if (s->mb_x == s->mb_width - 1) {
 284             dest += 16;
 285             flags = s->mb_x == 0 ? LEFT_EDGE | RIGHT_EDGE : RIGHT_EDGE;
 286             for (i = 0; i < block_count; i++)
 287                 vc1_i_h_loop_filter(v, i > 3 ? s->dest[i - 3] - 16 * s->uvlinesize : dest, flags, i);
 288         }
 289     }
 290     if (s->mb_y == s->end_mb_y - 1) {
 291         if (s->mb_y >= s->start_mb_y + 1) {
 292             dest = s->dest[0] - 16 * s->linesize - 16;
 293             if (s->mb_x) {
 294                 flags = s->mb_x == 1 ? LEFT_EDGE : 0;
 295                 for (i = 0; i < block_count; i++)
 296                     vc1_i_h_loop_filter(v, i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize - 8 : dest, flags, i);
 297             }
 298             if (s->mb_x == s->mb_width - 1) {
 299                 flags = s->mb_x == 0 ? LEFT_EDGE | RIGHT_EDGE : RIGHT_EDGE;
 300                 dest += 16;
 301                 for (i = 0; i < block_count; i++)
 302                     vc1_i_h_loop_filter(v, i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize : dest, flags, i);
 303             }
 304         }
 305         dest = s->dest[0] - 16;
 306         if (s->mb_x) {
 307             flags = s->mb_x == 1 ? LEFT_EDGE : 0;
 308             for (i = 0; i < block_count; i++)
 309                 vc1_i_h_loop_filter(v, i > 3 ? s->dest[i - 3] - 8 : dest, flags, i);
 310         }
 311         if (s->mb_x == s->mb_width - 1) {
 312             dest += 16;
 313             flags = s->mb_x == 0 ? LEFT_EDGE | RIGHT_EDGE : RIGHT_EDGE;
 314             for (i = 0; i < block_count; i++)
 315                 vc1_i_h_loop_filter(v, i > 3 ? s->dest[i - 3] : dest, flags, i);
 316         }
 317     }
 318 }
 319
 320 static av_always_inline void vc1_p_h_loop_filter(VC1Context *v, uint8_t *dest, uint32_t *cbp,
 321                                                  uint8_t *is_intra, int16_t (*mv)[2], uint8_t *mv_f,
 322                                                  int *ttblk, uint32_t flags, int block_num)
 323 {
 324     MpegEncContext *s  = &v->s;
 325     int pq = v->pq;
 326     uint32_t left_cbp = cbp[0] >> (block_num * 4), right_cbp;
 327     uint8_t left_is_intra, right_is_intra;
 328     int tt;
 329     int idx, linesize  = block_num > 3 ? s->uvlinesize : s->linesize;
 330     uint8_t *dst;
 331
 332     if (block_num > 3)
 333         dst = dest;
 334     else
 335         dst = dest + (block_num & 2) * 4 * s->linesize + (block_num & 1) * 8;
 336
 337     if (!(flags & RIGHT_EDGE) || !(block_num & 5)) {
 338         left_is_intra = is_intra[0] & (1 << block_num);
 339
 340         if (block_num > 3) {
 341             right_is_intra = is_intra[1] & (1 << block_num);
 342             right_cbp = cbp[1] >> (block_num * 4);
 343         } else if (block_num & 1) {
 344             right_is_intra = is_intra[1] & (1 << block_num - 1);
 345             right_cbp = cbp[1] >> ((block_num - 1) * 4);
 346         } else {
 347             right_is_intra = is_intra[0] & (1 << block_num + 1);
 348             right_cbp = cbp[0] >> ((block_num + 1) * 4);
 349         }
 350
 351         if (left_is_intra || right_is_intra ||
 352             mv[0][0] != mv[1][0] || mv[0][1] != mv[1][1] ||
 353             (v->fcm == ILACE_FIELD && mv_f[0] != mv_f[1]))
 354             v->vc1dsp.vc1_h_loop_filter8(dst + 8, linesize, pq);
 355         else {
 356             idx = (left_cbp | (right_cbp >> 1)) & 5;
 357             if (idx & 1)
 358                 v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize + 8, linesize, pq);
 359             if (idx & 4)
 360                 v->vc1dsp.vc1_h_loop_filter4(dst + 8, linesize, pq);
 361         }
 362     }
 363
 364     tt = ttblk[0] >> (block_num * 4) & 0xf;
 365     if (tt == TT_4X4 || tt == TT_4X8) {
 366         if (left_cbp & 3)
 367             v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize + 4, linesize, pq);
 368         if (left_cbp & 12)
 369             v->vc1dsp.vc1_h_loop_filter4(dst + 4, linesize, pq);
 370     }
 371 }
 372
 373 static av_always_inline void vc1_p_v_loop_filter(VC1Context *v, uint8_t *dest, uint32_t *cbp,
 374                                                  uint8_t *is_intra, int16_t (*mv)[2], uint8_t *mv_f,
 375                                                  int *ttblk, uint32_t flags, int block_num)
 376 {
 377     MpegEncContext *s  = &v->s;
 378     int pq = v->pq;
 379     uint32_t top_cbp = cbp[0] >> (block_num * 4), bottom_cbp;
 380     uint8_t top_is_intra, bottom_is_intra;
 381     int tt;
 382     int idx, linesize  = block_num > 3 ? s->uvlinesize : s->linesize;
 383     uint8_t *dst;
 384
 385     if (block_num > 3)
 386         dst = dest;
 387     else
 388         dst = dest + (block_num & 2) * 4 * s->linesize + (block_num & 1) * 8;
 389
 390     if(!(flags & BOTTOM_EDGE) || block_num < 2) {
 391         top_is_intra = is_intra[0] & (1 << block_num);
 392
 393         if (block_num > 3) {
 394             bottom_is_intra = is_intra[s->mb_stride] & (1 << block_num);
 395             bottom_cbp = cbp[s->mb_stride] >> (block_num * 4);
 396         } else if (block_num < 2) {
 397             bottom_is_intra = is_intra[0] & (1 << block_num + 2);
 398             bottom_cbp = cbp[0] >> ((block_num + 2) * 4);
 399         } else {
 400             bottom_is_intra = is_intra[s->mb_stride] & (1 << block_num - 2);
 401             bottom_cbp = cbp[s->mb_stride] >> ((block_num - 2) * 4);
 402         }
 403
 404         if (top_is_intra || bottom_is_intra ||
 405             mv[0][0] != mv[block_num > 3 ? s->mb_stride : s->b8_stride][0] ||
 406             mv[0][1] != mv[block_num > 3 ? s->mb_stride : s->b8_stride][1] ||
 407             (v->fcm == ILACE_FIELD && mv_f[0] != mv_f[block_num > 3 ? s->mb_stride : s->b8_stride]))
 408             v->vc1dsp.vc1_v_loop_filter8(dst + 8 * linesize, linesize, pq);
 409         else {
 410             idx = (top_cbp | (bottom_cbp >> 2)) & 3;
 411             if (idx & 1)
 412                 v->vc1dsp.vc1_v_loop_filter4(dst + 8 * linesize + 4, linesize, pq);
 413             if (idx & 2)
 414                 v->vc1dsp.vc1_v_loop_filter4(dst + 8 * linesize, linesize, pq);
 415         }
 416     }
 417
 418     tt = ttblk[0] >> (block_num * 4) & 0xf;
 419     if (tt == TT_4X4 || tt == TT_8X4) {
 420         if (top_cbp & 5)
 421             v->vc1dsp.vc1_v_loop_filter4(dst + 4 * linesize + 4, linesize, pq);
 422         if (top_cbp & 10)
 423             v->vc1dsp.vc1_v_loop_filter4(dst + 4 * linesize, linesize, pq);
 424     }
 425 }
 426
 427 void ff_vc1_p_loop_filter(VC1Context *v)
 428 {
 429     MpegEncContext *s = &v->s;
 430     int block_count = CONFIG_GRAY && (s->avctx->flags & AV_CODEC_FLAG_GRAY) ? 4 : 6;
 431     uint8_t *dest;
 432     uint32_t *cbp;
 433     uint8_t *is_intra;
 434     int16_t (*uvmv)[2];
 435     int *ttblk;
 436     uint32_t flags;
 437     int i;
 438
 439     /* Within a MB, the vertical loop filter always runs before the horizontal.
 440      * To accomplish that, we run the V loop filter on all applicable
 441      * horizontal borders of the MB above the last overlap filtered MB. Then,
 442      * we wait for the next loop filter iteration to do H loop filter on all
 443      * applicable vertical borders of this MB. Therefore, the loop filter
 444      * trails by one row and one column relative to the overlap filter and two
 445      * rows and two colums relative to the decoding loop. */
 446     if (s->mb_y >= s->start_mb_y + 2) {
 447         if (s->mb_x) {
 448             dest = s->dest[0] - 32 * s->linesize - 16;
 449             cbp = &v->cbp[s->mb_x - 2 * s->mb_stride - 1];
 450             is_intra = &v->is_intra[s->mb_x - 2 * s->mb_stride - 1];
 451             uvmv = &v->luma_mv[s->mb_x - 2 * s->mb_stride - 1];
 452             ttblk = &v->ttblk[s->mb_x - 2 * s->mb_stride - 1];
 453             flags = s->mb_y == s->start_mb_y + 2 ? TOP_EDGE : 0;
 454             for (i = 0; i < block_count; i++)
 455                 vc1_p_v_loop_filter(v,
 456                                     i > 3 ? s->dest[i - 3] - 16 * s->uvlinesize - 8 : dest,
 457                                     cbp,
 458                                     is_intra,
 459                                     i > 3 ? uvmv :
 460                                             &s->current_picture.motion_val[0][s->block_index[i] - 4 * s->b8_stride - 2 + v->blocks_off],
 461                                     i > 3 ? &v->mv_f[0][s->block_index[i] - 2 * s->mb_stride - 1 + v->mb_off] :
 462                                             &v->mv_f[0][s->block_index[i] - 4 * s->b8_stride - 2 + v->blocks_off],
 463                                     ttblk,
 464                                     flags,
 465                                     i);
 466         }
 467         if (s->mb_x == s->mb_width - 1) {
 468             dest = s->dest[0] - 32 * s->linesize;
 469             cbp = &v->cbp[s->mb_x - 2 * s->mb_stride];
 470             is_intra = &v->is_intra[s->mb_x - 2 * s->mb_stride];
 471             uvmv = &v->luma_mv[s->mb_x - 2 * s->mb_stride];
 472             ttblk = &v->ttblk[s->mb_x - 2 * s->mb_stride];
 473             flags = s->mb_y == s->start_mb_y + 2 ? TOP_EDGE : 0;
 474             for (i = 0; i < block_count; i++)
 475                 vc1_p_v_loop_filter(v,
 476                                     i > 3 ? s->dest[i - 3] - 16 * s->uvlinesize : dest,
 477                                     cbp,
 478                                     is_intra,
 479                                     i > 3 ? uvmv :
 480                                             &s->current_picture.motion_val[0][s->block_index[i] - 4 * s->b8_stride + v->blocks_off],
 481                                     i > 3 ? &v->mv_f[0][s->block_index[i] - 2 * s->mb_stride + v->mb_off] :
 482                                             &v->mv_f[0][s->block_index[i] - 4 * s->b8_stride + v->blocks_off],
 483                                     ttblk,
 484                                     flags,
 485                                     i);
 486         }
 487     }
 488     if (s->mb_y == s->end_mb_y - 1) {
 489         if (s->mb_x) {
 490             if (s->mb_y >= s->start_mb_y + 1) {
 491                 dest = s->dest[0] - 16 * s->linesize - 16;
 492                 cbp = &v->cbp[s->mb_x - s->mb_stride - 1];
 493                 is_intra = &v->is_intra[s->mb_x - s->mb_stride - 1];
 494                 uvmv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
 495                 ttblk = &v->ttblk[s->mb_x - s->mb_stride - 1];
 496                 flags = s->mb_y == s->start_mb_y + 1 ? TOP_EDGE : 0;
 497                 for (i = 0; i < block_count; i++)
 498                     vc1_p_v_loop_filter(v,
 499                                         i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize - 8 : dest,
 500                                         cbp,
 501                                         is_intra,
 502                                         i > 3 ? uvmv :
 503                                                 &s->current_picture.motion_val[0][s->block_index[i] - 2 * s->b8_stride - 2 + v->blocks_off],
 504                                         i > 3 ? &v->mv_f[0][s->block_index[i] - s->mb_stride - 1 + v->mb_off] :
 505                                                 &v->mv_f[0][s->block_index[i] - 2 * s->b8_stride - 2 + v->blocks_off],
 506                                         ttblk,
 507                                         flags,
 508                                         i);
 509             }
 510             dest = s->dest[0] - 16;
 511             cbp = &v->cbp[s->mb_x - 1];
 512             is_intra = &v->is_intra[s->mb_x - 1];
 513             uvmv = &v->luma_mv[s->mb_x - 1];
 514             ttblk = &v->ttblk[s->mb_x - 1];
 515             flags = s->mb_y == s->start_mb_y ? TOP_EDGE | BOTTOM_EDGE : BOTTOM_EDGE;
 516             for (i = 0; i < block_count; i++)
 517                 vc1_p_v_loop_filter(v,
 518                                     i > 3 ? s->dest[i - 3] - 8 : dest,
 519                                     cbp,
 520                                     is_intra,
 521                                     i > 3 ? uvmv :
 522                                             &s->current_picture.motion_val[0][s->block_index[i] - 2 + v->blocks_off],
 523                                     i > 3 ? &v->mv_f[0][s->block_index[i] - 1 + v->mb_off] :
 524                                             &v->mv_f[0][s->block_index[i] - 2 + v->blocks_off],
 525                                     ttblk,
 526                                     flags,
 527                                     i);
 528         }
 529         if (s->mb_x == s->mb_width - 1) {
 530             if (s->mb_y >= s->start_mb_y + 1) {
 531                 dest = s->dest[0] - 16 * s->linesize;
 532                 cbp = &v->cbp[s->mb_x - s->mb_stride];
 533                 is_intra = &v->is_intra[s->mb_x - s->mb_stride];
 534                 uvmv = &v->luma_mv[s->mb_x - s->mb_stride];
 535                 ttblk = &v->ttblk[s->mb_x - s->mb_stride];
 536                 flags = s->mb_y == s->start_mb_y + 1 ? TOP_EDGE : 0;
 537                 for (i = 0; i < block_count; i++)
 538                     vc1_p_v_loop_filter(v,
 539                                         i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize : dest,
 540                                         cbp,
 541                                         is_intra,
 542                                         i > 3 ? uvmv :
 543                                                 &s->current_picture.motion_val[0][s->block_index[i] - 2 * s->b8_stride + v->blocks_off],
 544                                         i > 3 ? &v->mv_f[0][s->block_index[i] - s->mb_stride + v->mb_off] :
 545                                                 &v->mv_f[0][s->block_index[i] - 2 * s->b8_stride + v->blocks_off],
 546                                         ttblk,
 547                                         flags,
 548                                         i);
 549             }
 550             dest = s->dest[0];
 551             cbp = &v->cbp[s->mb_x];
 552             is_intra = &v->is_intra[s->mb_x];
 553             uvmv = &v->luma_mv[s->mb_x];
 554             ttblk = &v->ttblk[s->mb_x];
 555             flags = s->mb_y == s->start_mb_y ? TOP_EDGE | BOTTOM_EDGE : BOTTOM_EDGE;
 556             for (i = 0; i < block_count; i++)
 557                 vc1_p_v_loop_filter(v,
 558                                     i > 3 ? s->dest[i - 3] : dest,
 559                                     cbp,
 560                                     is_intra,
 561                                     i > 3 ? uvmv :
 562                                             &s->current_picture.motion_val[0][s->block_index[i] + v->blocks_off],
 563                                     i > 3 ? &v->mv_f[0][s->block_index[i] + v->mb_off] :
 564                                             &v->mv_f[0][s->block_index[i] + v->blocks_off],
 565                                     ttblk,
 566                                     flags,
 567                                     i);
 568         }
 569     }
 570
 571     if (s->mb_y >= s->start_mb_y + 2) {
 572         if (s->mb_x >= 2) {
 573             dest = s->dest[0] - 32 * s->linesize - 32;
 574             cbp = &v->cbp[s->mb_x - 2 * s->mb_stride - 2];
 575             is_intra = &v->is_intra[s->mb_x - 2 * s->mb_stride - 2];
 576             uvmv = &v->luma_mv[s->mb_x - 2 * s->mb_stride - 2];
 577             ttblk = &v->ttblk[s->mb_x - 2 * s->mb_stride - 2];
 578             flags = s->mb_x == 2 ? LEFT_EDGE : 0;
 579             for (i = 0; i < block_count; i++)
 580                 vc1_p_h_loop_filter(v,
 581                                     i > 3 ? s->dest[i - 3] - 16 * s->uvlinesize - 16 : dest,
 582                                     cbp,
 583                                     is_intra,
 584                                     i > 3 ? uvmv :
 585                                             &s->current_picture.motion_val[0][s->block_index[i] - 4 * s->b8_stride - 4 + v->blocks_off],
 586                                     i > 3 ? &v->mv_f[0][s->block_index[i] - 2 * s->mb_stride - 2 + v->mb_off] :
 587                                             &v->mv_f[0][s->block_index[i] - 4 * s->b8_stride - 4 + v->blocks_off],
 588                                     ttblk,
 589                                     flags,
 590                                     i);
 591         }
 592         if (s->mb_x == s->mb_width - 1) {
 593             if (s->mb_x >= 1) {
 594                 dest = s->dest[0] - 32 * s->linesize - 16;
 595                 cbp = &v->cbp[s->mb_x - 2 * s->mb_stride - 1];
 596                 is_intra = &v->is_intra[s->mb_x - 2 * s->mb_stride - 1];
 597                 uvmv = &v->luma_mv[s->mb_x - 2 * s->mb_stride - 1];
 598                 ttblk = &v->ttblk[s->mb_x - 2 * s->mb_stride - 1];
 599                 flags = s->mb_x == 1 ? LEFT_EDGE : 0;
 600                 for (i = 0; i < block_count; i++)
 601                         vc1_p_h_loop_filter(v,
 602                                             i > 3 ? s->dest[i - 3] - 16 * s->uvlinesize - 8 : dest,
 603                                             cbp,
 604                                             is_intra,
 605                                             i > 3 ? uvmv :
 606                                                     &s->current_picture.motion_val[0][s->block_index[i] - 4 * s->b8_stride - 2 + v->blocks_off],
 607                                             i > 3 ? &v->mv_f[0][s->block_index[i] - 2 * s->mb_stride - 1 + v->mb_off] :
 608                                                     &v->mv_f[0][s->block_index[i] - 4 * s->b8_stride - 2 + v->blocks_off],
 609                                             ttblk,
 610                                             flags,
 611                                             i);
 612             }
 613             dest = s->dest[0] - 32 * s->linesize;
 614             cbp = &v->cbp[s->mb_x - 2 * s->mb_stride];
 615             is_intra = &v->is_intra[s->mb_x - 2 * s->mb_stride];
 616             uvmv = &v->luma_mv[s->mb_x - 2 * s->mb_stride];
 617             ttblk = &v->ttblk[s->mb_x - 2 * s->mb_stride];
 618             flags = s->mb_x ? RIGHT_EDGE : LEFT_EDGE | RIGHT_EDGE;
 619             for (i = 0; i < block_count; i++)
 620                 vc1_p_h_loop_filter(v,
 621                                     i > 3 ? s->dest[i - 3] - 16 * s->uvlinesize : dest,
 622                                     cbp,
 623                                     is_intra,
 624                                     i > 3 ? uvmv :
 625                                             &s->current_picture.motion_val[0][s->block_index[i] - 4 * s->b8_stride + v->blocks_off],
 626                                     i > 3 ? &v->mv_f[0][s->block_index[i] - 2 * s->mb_stride + v->mb_off] :
 627                                             &v->mv_f[0][s->block_index[i] - 4 * s->b8_stride + v->blocks_off],
 628                                     ttblk,
 629                                     flags,
 630                                     i);
 631         }
 632     }
 633     if (s->mb_y == s->end_mb_y - 1) {
 634         if (s->mb_y >= s->start_mb_y + 1) {
 635             if (s->mb_x >= 2) {
 636                 dest = s->dest[0] - 16 * s->linesize - 32;
 637                 cbp = &v->cbp[s->mb_x - s->mb_stride - 2];
 638                 is_intra = &v->is_intra[s->mb_x - s->mb_stride - 2];
 639                 uvmv = &v->luma_mv[s->mb_x - s->mb_stride - 2];
 640                 ttblk = &v->ttblk[s->mb_x - s->mb_stride - 2];
 641                 flags = s->mb_x == 2 ? LEFT_EDGE : 0;
 642                 for (i = 0; i < block_count; i++)
 643                     vc1_p_h_loop_filter(v,
 644                                         i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize - 16 : dest,
 645                                         cbp,
 646                                         is_intra,
 647                                         i > 3 ? uvmv :
 648                                                 &s->current_picture.motion_val[0][s->block_index[i] - 2 * s->b8_stride - 4 + v->blocks_off],
 649                                         i > 3 ? &v->mv_f[0][s->block_index[i] - s->mb_stride - 2 + v->mb_off] :
 650                                                 &v->mv_f[0][s->block_index[i] - 2 * s->b8_stride - 4 + v->blocks_off],
 651                                         ttblk,
 652                                         flags,
 653                                         i);
 654             }
 655             if (s->mb_x == s->mb_width - 1) {
 656                 if (s->mb_x >= 1) {
 657                     dest = s->dest[0] - 16 * s->linesize - 16;
 658                     cbp = &v->cbp[s->mb_x - s->mb_stride - 1];
 659                     is_intra = &v->is_intra[s->mb_x - s->mb_stride - 1];
 660                     uvmv = &v->luma_mv[s->mb_x - s->mb_stride - 1];
 661                     ttblk = &v->ttblk[s->mb_x - s->mb_stride - 1];
 662                     flags = s->mb_x == 1 ? LEFT_EDGE : 0;
 663                     for (i = 0; i < block_count; i++)
 664                             vc1_p_h_loop_filter(v,
 665                                                 i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize - 8 : dest,
 666                                                 cbp,
 667                                                 is_intra,
 668                                                 i > 3 ? uvmv :
 669                                                         &s->current_picture.motion_val[0][s->block_index[i] - 2 * s->b8_stride - 2 + v->blocks_off],
 670                                                 i > 3 ? &v->mv_f[0][s->block_index[i] - s->mb_stride - 1 + v->mb_off] :
 671                                                         &v->mv_f[0][s->block_index[i] - 2 * s->b8_stride - 2 + v->blocks_off],
 672                                                 ttblk,
 673                                                 flags,
 674                                                 i);
 675                 }
 676                 dest = s->dest[0] - 16 * s->linesize;
 677                 cbp = &v->cbp[s->mb_x - s->mb_stride];
 678                 is_intra = &v->is_intra[s->mb_x - s->mb_stride];
 679                 uvmv = &v->luma_mv[s->mb_x - s->mb_stride];
 680                 ttblk = &v->ttblk[s->mb_x - s->mb_stride];
 681                 flags = s->mb_x ? RIGHT_EDGE : LEFT_EDGE | RIGHT_EDGE;
 682                 for (i = 0; i < block_count; i++)
 683                     vc1_p_h_loop_filter(v,
 684                                         i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize : dest,
 685                                         cbp,
 686                                         is_intra,
 687                                         i > 3 ? uvmv :
 688                                                 &s->current_picture.motion_val[0][s->block_index[i] - 2 * s->b8_stride + v->blocks_off],
 689                                         i > 3 ? &v->mv_f[0][s->block_index[i] - s->mb_stride + v->mb_off] :
 690                                                 &v->mv_f[0][s->block_index[i] - 2 * s->b8_stride + v->blocks_off],
 691                                         ttblk,
 692                                         flags,
 693                                         i);
 694             }
 695         }
 696         if (s->mb_x >= 2) {
 697             dest = s->dest[0] - 32;
 698             cbp = &v->cbp[s->mb_x - 2];
 699             is_intra = &v->is_intra[s->mb_x - 2];
 700             uvmv = &v->luma_mv[s->mb_x - 2];
 701             ttblk = &v->ttblk[s->mb_x - 2];
 702             flags = s->mb_x == 2 ? LEFT_EDGE : 0;
 703             for (i = 0; i < block_count; i++)
 704                 vc1_p_h_loop_filter(v,
 705                                     i > 3 ? s->dest[i - 3] - 16 : dest,
 706                                     cbp,
 707                                     is_intra,
 708                                     i > 3 ? uvmv :
 709                                             &s->current_picture.motion_val[0][s->block_index[i] - 4 + v->blocks_off],
 710                                     i > 3 ? &v->mv_f[0][s->block_index[i] - 2 + v->mb_off] :
 711                                             &v->mv_f[0][s->block_index[i] - 4 + v->blocks_off],
 712                                     ttblk,
 713                                     flags,
 714                                     i);
 715         }
 716         if (s->mb_x == s->mb_width - 1) {
 717             if (s->mb_x >= 1) {
 718                 dest = s->dest[0] - 16;
 719                 cbp = &v->cbp[s->mb_x - 1];
 720                 is_intra = &v->is_intra[s->mb_x - 1];
 721                 uvmv = &v->luma_mv[s->mb_x - 1];
 722                 ttblk = &v->ttblk[s->mb_x - 1];
 723                 flags = s->mb_x == 1 ? LEFT_EDGE : 0;
 724                 for (i = 0; i < block_count; i++)
 725                     vc1_p_h_loop_filter(v,
 726                                         i > 3 ? s->dest[i - 3] - 8 : dest,
 727                                         cbp,
 728                                         is_intra,
 729                                         i > 3 ? uvmv :
 730                                                 &s->current_picture.motion_val[0][s->block_index[i] - 2 + v->blocks_off],
 731                                         i > 3 ? &v->mv_f[0][s->block_index[i] - 1 + v->mb_off] :
 732                                                 &v->mv_f[0][s->block_index[i] - 2 + v->blocks_off],
 733                                         ttblk,
 734                                         flags,
 735                                         i);
 736             }
 737             dest = s->dest[0];
 738             cbp = &v->cbp[s->mb_x];
 739             is_intra = &v->is_intra[s->mb_x];
 740             uvmv = &v->luma_mv[s->mb_x];
 741             ttblk = &v->ttblk[s->mb_x];
 742             flags = s->mb_x ? RIGHT_EDGE : LEFT_EDGE | RIGHT_EDGE;
 743             for (i = 0; i < block_count; i++)
 744                 vc1_p_h_loop_filter(v,
 745                                     i > 3 ? s->dest[i - 3] : dest,
 746                                     cbp,
 747                                     is_intra,
 748                                     i > 3 ? uvmv :
 749                                             &s->current_picture.motion_val[0][s->block_index[i] + v->blocks_off],
 750                                     i > 3 ? &v->mv_f[0][s->block_index[i] + v->mb_off] :
 751                                             &v->mv_f[0][s->block_index[i] + v->blocks_off],
 752                                     ttblk,
 753                                     flags,
 754                                     i);
 755         }
 756     }
 757 }
 758
 759 static av_always_inline void vc1_p_h_intfr_loop_filter(VC1Context *v, uint8_t *dest, int *ttblk,
 760                                                        uint32_t flags, uint8_t fieldtx, int block_num)
 761 {
 762     MpegEncContext *s  = &v->s;
 763     int pq = v->pq;
 764     int tt;
 765     int linesize  = block_num > 3 ? s->uvlinesize : s->linesize;
 766     uint8_t *dst;
 767
 768     if (block_num > 3)
 769         dst = dest;
 770     else
 771         dst = dest + (block_num & 2) * 4 * s->linesize + (block_num & 1) * 8;
 772
 773     tt = ttblk[0] >> (block_num * 4) & 0xf;
 774     if (block_num < 4) {
 775         if (fieldtx) {
 776             if (block_num < 2) {
 777                 if (tt == TT_4X4 || tt == TT_4X8)
 778                     v->vc1dsp.vc1_h_loop_filter8(dst + 4, 2 * linesize, pq);
 779                 if (!(flags & RIGHT_EDGE) || block_num == 0)
 780                     v->vc1dsp.vc1_h_loop_filter8(dst + 8, 2 * linesize, pq);
 781             } else {
 782                 if (tt == TT_4X4 || tt == TT_4X8)
 783                     v->vc1dsp.vc1_h_loop_filter8(dst - 7 * linesize + 4, 2 * linesize, pq);
 784                 if (!(flags & RIGHT_EDGE) || block_num == 2)
 785                     v->vc1dsp.vc1_h_loop_filter8(dst - 7 * linesize + 8, 2 * linesize, pq);
 786             }
 787         } else {
 788             if(tt == TT_4X4 || tt == TT_4X8) {
 789                 v->vc1dsp.vc1_h_loop_filter4(dst + 4, 2 * linesize, pq);
 790                 v->vc1dsp.vc1_h_loop_filter4(dst + linesize + 4, 2 * linesize, pq);
 791             }
 792             if (!(flags & RIGHT_EDGE) || !(block_num & 5)) {
 793                 v->vc1dsp.vc1_h_loop_filter4(dst + 8, 2 * linesize, pq);
 794                 v->vc1dsp.vc1_h_loop_filter4(dst + linesize + 8, 2 * linesize, pq);
 795             }
 796         }
 797     } else {
 798         if (tt == TT_4X4 || tt == TT_4X8) {
 799             v->vc1dsp.vc1_h_loop_filter4(dst + 4, 2 * linesize, pq);
 800             v->vc1dsp.vc1_h_loop_filter4(dst + linesize + 4, 2 * linesize, pq);
 801         }
 802         if (!(flags & RIGHT_EDGE)) {
 803             v->vc1dsp.vc1_h_loop_filter4(dst + 8, 2 * linesize, pq);
 804             v->vc1dsp.vc1_h_loop_filter4(dst + linesize + 8, 2 * linesize, pq);
 805         }
 806     }
 807 }
 808
 809 static av_always_inline void vc1_p_v_intfr_loop_filter(VC1Context *v, uint8_t *dest, int *ttblk,
 810                                                        uint32_t flags, uint8_t fieldtx, int block_num)
 811 {
 812     MpegEncContext *s  = &v->s;
 813     int pq = v->pq;
 814     int tt;
 815     int linesize  = block_num > 3 ? s->uvlinesize : s->linesize;
 816     uint8_t *dst;
 817
 818     if (block_num > 3)
 819         dst = dest;
 820     else
 821         dst = dest + (block_num & 2) * 4 * s->linesize + (block_num & 1) * 8;
 822
 823     tt = ttblk[0] >> (block_num * 4) & 0xf;
 824     if (block_num < 4) {
 825         if (fieldtx) {
 826             if (block_num < 2) {
 827                 if (tt == TT_4X4 || tt == TT_8X4)
 828                     v->vc1dsp.vc1_v_loop_filter8(dst + 8 * linesize, 2 * linesize, pq);
 829                 if (!(flags & BOTTOM_EDGE))
 830                     v->vc1dsp.vc1_v_loop_filter8(dst + 16 * linesize, 2 * linesize, pq);
 831             } else {
 832                 if (tt == TT_4X4 || tt == TT_8X4)
 833                     v->vc1dsp.vc1_v_loop_filter8(dst + linesize, 2 * linesize, pq);
 834                 if (!(flags & BOTTOM_EDGE))
 835                     v->vc1dsp.vc1_v_loop_filter8(dst + 9 * linesize, 2 * linesize, pq);
 836             }
 837         } else {
 838             if (block_num < 2) {
 839                 if (!(flags & TOP_EDGE) && (tt == TT_4X4 || tt == TT_8X4)) {
 840                     v->vc1dsp.vc1_v_loop_filter8(dst + 4 * linesize, 2 * linesize, pq);
 841                     v->vc1dsp.vc1_v_loop_filter8(dst + 5 * linesize, 2 * linesize, pq);
 842                 }
 843                 v->vc1dsp.vc1_v_loop_filter8(dst + 8 * linesize, 2 * linesize, pq);
 844                 v->vc1dsp.vc1_v_loop_filter8(dst + 9 * linesize, 2 * linesize, pq);
 845             } else if (!(flags & BOTTOM_EDGE)) {
 846                 if (tt == TT_4X4 || tt == TT_8X4) {
 847                     v->vc1dsp.vc1_v_loop_filter8(dst + 4 * linesize, 2 * linesize, pq);
 848                     v->vc1dsp.vc1_v_loop_filter8(dst + 5 * linesize, 2 * linesize, pq);
 849                 }
 850                 v->vc1dsp.vc1_v_loop_filter8(dst + 8 * linesize, 2 * linesize, pq);
 851                 v->vc1dsp.vc1_v_loop_filter8(dst + 9 * linesize, 2 * linesize, pq);
 852             }
 853         }
 854     } else {
 855         if (!(flags & BOTTOM_EDGE)) {
 856             if (!(flags & TOP_EDGE) && (tt == TT_4X4 || tt == TT_8X4)) {
 857                 v->vc1dsp.vc1_v_loop_filter8(dst + 4 * linesize, 2 * linesize, pq);
 858                 v->vc1dsp.vc1_v_loop_filter8(dst + 5 * linesize, 2 * linesize, pq);
 859             }
 860                 v->vc1dsp.vc1_v_loop_filter8(dst + 8 * linesize, 2 * linesize, pq);
 861                 v->vc1dsp.vc1_v_loop_filter8(dst + 9 * linesize, 2 * linesize, pq);
 862         }
 863     }
 864 }
 865
 866 void ff_vc1_p_intfr_loop_filter(VC1Context *v)
 867 {
 868     MpegEncContext *s = &v->s;
 869     int block_count = CONFIG_GRAY && (s->avctx->flags & AV_CODEC_FLAG_GRAY) ? 4 : 6;
 870     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
 871     uint8_t *dest;
 872     int *ttblk;
 873     uint32_t flags;
 874     uint8_t fieldtx;
 875     int i;
 876
 877     /* Within a MB, the vertical loop filter always runs before the horizontal.
 878      * To accomplish that, we run the V loop filter on all applicable
 879      * horizontal borders of the MB above the last overlap filtered MB. Then,
 880      * we wait for the loop filter iteration on the next row and next column to
 881      * do H loop filter on all applicable vertical borders of this MB.
 882      * Therefore, the loop filter trails by two rows and one column relative to
 883      * the overlap filter and two rows and two colums relative to the decoding
 884      * loop. */
 885     if (s->mb_x) {
 886         if (s->mb_y >= s->start_mb_y + 1) {
 887             dest = s->dest[0] - 16 * s->linesize - 16;
 888             ttblk = &v->ttblk[s->mb_x - s->mb_stride - 1];
 889             flags = s->mb_y == s->start_mb_y + 1 ? TOP_EDGE : 0;
 890             fieldtx = v->fieldtx_plane[mb_pos - s->mb_stride - 1];
 891             for (i = 0; i < block_count; i++)
 892                 vc1_p_v_intfr_loop_filter(v,
 893                                           i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize - 8 : dest,
 894                                           ttblk,
 895                                           flags,
 896                                           fieldtx,
 897                                           i);
 898         }
 899     }
 900     if (s->mb_x == s->mb_width - 1) {
 901         if (s->mb_y >= s->start_mb_y + 1) {
 902             dest = s->dest[0] - 16 * s->linesize;
 903             ttblk = &v->ttblk[s->mb_x - s->mb_stride];
 904             flags = s->mb_y == s->start_mb_y + 1 ? TOP_EDGE : 0;
 905             fieldtx = v->fieldtx_plane[mb_pos - s->mb_stride];
 906             for (i = 0; i < block_count; i++)
 907                 vc1_p_v_intfr_loop_filter(v,
 908                                           i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize : dest,
 909                                           ttblk,
 910                                           flags,
 911                                           fieldtx,
 912                                           i);
 913         }
 914     }
 915     if (s->mb_y == s->end_mb_y - 1) {
 916         if (s->mb_x) {
 917             dest = s->dest[0] - 16;
 918             ttblk = &v->ttblk[s->mb_x - 1];
 919             flags = s->mb_y == s->start_mb_y ? TOP_EDGE | BOTTOM_EDGE : BOTTOM_EDGE;
 920             fieldtx = v->fieldtx_plane[mb_pos - 1];
 921             for (i = 0; i < block_count; i++)
 922                 vc1_p_v_intfr_loop_filter(v,
 923                                           i > 3 ? s->dest[i - 3] - 8 : dest,
 924                                           ttblk,
 925                                           flags,
 926                                           fieldtx,
 927                                           i);
 928         }
 929         if (s->mb_x == s->mb_width - 1) {
 930             dest = s->dest[0];
 931             ttblk = &v->ttblk[s->mb_x];
 932             flags = s->mb_y == s->start_mb_y ? TOP_EDGE | BOTTOM_EDGE : BOTTOM_EDGE;
 933             fieldtx = v->fieldtx_plane[mb_pos];
 934             for (i = 0; i < block_count; i++)
 935                 vc1_p_v_intfr_loop_filter(v,
 936                                           i > 3 ? s->dest[i - 3] : dest,
 937                                           ttblk,
 938                                           flags,
 939                                           fieldtx,
 940                                           i);
 941         }
 942     }
 943
 944     if (s->mb_y >= s->start_mb_y + 2) {
 945         if (s->mb_x >= 2) {
 946             dest = s->dest[0] - 32 * s->linesize - 32;
 947             ttblk = &v->ttblk[s->mb_x - 2 * s->mb_stride - 2];
 948             flags = s->mb_x == 2 ? LEFT_EDGE : 0;
 949             fieldtx = v->fieldtx_plane[mb_pos - 2 * s->mb_stride - 2];
 950             for (i = 0; i < block_count; i++)
 951                 vc1_p_h_intfr_loop_filter(v,
 952                                           i > 3 ? s->dest[i - 3] - 16 * s->uvlinesize - 16 : dest,
 953                                           ttblk,
 954                                           flags,
 955                                           fieldtx,
 956                                           i);
 957         }
 958         if (s->mb_x == s->mb_width - 1) {
 959             if (s->mb_x >= 1) {
 960                 dest = s->dest[0] - 32 * s->linesize - 16;
 961                 ttblk = &v->ttblk[s->mb_x - 2 * s->mb_stride - 1];
 962                 flags = s->mb_x == 1 ? LEFT_EDGE : 0;
 963                 fieldtx = v->fieldtx_plane[mb_pos - 2 * s->mb_stride - 1];
 964                 for (i = 0; i < block_count; i++)
 965                     vc1_p_h_intfr_loop_filter(v,
 966                                               i > 3 ? s->dest[i - 3] - 16 * s->uvlinesize - 8 : dest,
 967                                               ttblk,
 968                                               flags,
 969                                               fieldtx,
 970                                               i);
 971             }
 972             dest = s->dest[0] - 32 * s->linesize;
 973             ttblk = &v->ttblk[s->mb_x - 2 * s->mb_stride];
 974             flags = s->mb_x ? RIGHT_EDGE : LEFT_EDGE | RIGHT_EDGE;
 975             fieldtx = v->fieldtx_plane[mb_pos - 2 * s->mb_stride];
 976             for (i = 0; i < block_count; i++)
 977                 vc1_p_h_intfr_loop_filter(v,
 978                                           i > 3 ? s->dest[i - 3] - 16 * s->uvlinesize : dest,
 979                                           ttblk,
 980                                           flags,
 981                                           fieldtx,
 982                                           i);
 983         }
 984     }
 985     if (s->mb_y == s->end_mb_y - 1) {
 986         if (s->mb_y >= s->start_mb_y + 1) {
 987             if (s->mb_x >= 2) {
 988                 dest = s->dest[0] - 16 * s->linesize - 32;
 989                 ttblk = &v->ttblk[s->mb_x - s->mb_stride - 2];
 990                 flags = s->mb_x == 2 ? LEFT_EDGE : 0;
 991                 fieldtx = v->fieldtx_plane[mb_pos - s->mb_stride - 2];
 992                 for (i = 0; i < block_count; i++)
 993                     vc1_p_h_intfr_loop_filter(v,
 994                                               i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize - 16 : dest,
 995                                               ttblk,
 996                                               flags,
 997                                               fieldtx,
 998                                               i);
 999             }
1000             if (s->mb_x == s->mb_width - 1) {
1001                 if (s->mb_x >= 1) {
1002                     dest = s->dest[0] - 16 * s->linesize - 16;
1003                     ttblk = &v->ttblk[s->mb_x - s->mb_stride - 1];
1004                     flags = s->mb_x == 1 ? LEFT_EDGE : 0;
1005                     fieldtx = v->fieldtx_plane[mb_pos - s->mb_stride - 1];
1006                     for (i = 0; i < block_count; i++)
1007                         vc1_p_h_intfr_loop_filter(v,
1008                                                   i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize - 8 : dest,
1009                                                   ttblk,
1010                                                   flags,
1011                                                   fieldtx,
1012                                                   i);
1013                 }
1014                 dest = s->dest[0] - 16 * s->linesize;
1015                 ttblk = &v->ttblk[s->mb_x - s->mb_stride];
1016                 flags = s->mb_x ? RIGHT_EDGE : LEFT_EDGE | RIGHT_EDGE;
1017                 fieldtx = v->fieldtx_plane[mb_pos - s->mb_stride];
1018                 for (i = 0; i < block_count; i++)
1019                     vc1_p_h_intfr_loop_filter(v,
1020                                               i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize : dest,
1021                                               ttblk,
1022                                               flags,
1023                                               fieldtx,
1024                                               i);
1025             }
1026         }
1027         if (s->mb_x >= 2) {
1028             dest = s->dest[0] - 32;
1029             ttblk = &v->ttblk[s->mb_x - 2];
1030             flags = s->mb_x == 2 ? LEFT_EDGE : 0;
1031             fieldtx = v->fieldtx_plane[mb_pos - 2];
1032             for (i = 0; i < block_count; i++)
1033                 vc1_p_h_intfr_loop_filter(v,
1034                                           i > 3 ? s->dest[i - 3] - 16 : dest,
1035                                           ttblk,
1036                                           flags,
1037                                           fieldtx,
1038                                           i);
1039         }
1040         if (s->mb_x == s->mb_width - 1) {
1041             if (s->mb_x >= 1) {
1042                 dest = s->dest[0] - 16;
1043                 ttblk = &v->ttblk[s->mb_x - 1];
1044                 flags = s->mb_x == 1 ? LEFT_EDGE : 0;
1045                 fieldtx = v->fieldtx_plane[mb_pos - 1];
1046                 for (i = 0; i < block_count; i++)
1047                     vc1_p_h_intfr_loop_filter(v,
1048                                               i > 3 ? s->dest[i - 3] - 8 : dest,
1049                                               ttblk,
1050                                               flags,
1051                                               fieldtx,
1052                                               i);
1053             }
1054             dest = s->dest[0];
1055             ttblk = &v->ttblk[s->mb_x];
1056             flags = s->mb_x ? RIGHT_EDGE : LEFT_EDGE | RIGHT_EDGE;
1057             fieldtx = v->fieldtx_plane[mb_pos];
1058             for (i = 0; i < block_count; i++)
1059                 vc1_p_h_intfr_loop_filter(v,
1060                                           i > 3 ? s->dest[i - 3] : dest,
1061                                           ttblk,
1062                                           flags,
1063                                           fieldtx,
1064                                           i);
1065         }
1066     }
1067 }
1068
1069 static av_always_inline void vc1_b_h_intfi_loop_filter(VC1Context *v, uint8_t *dest, uint32_t *cbp,
1070                                                        int *ttblk, uint32_t flags, int block_num)
1071 {
1072     MpegEncContext *s  = &v->s;
1073     int pq = v->pq;
1074     uint8_t *dst;
1075     uint32_t block_cbp = cbp[0] >> (block_num * 4);
1076     int tt;
1077     int idx, linesize  = block_num > 3 ? s->uvlinesize : s->linesize;
1078
1079     if (block_num > 3)
1080         dst = dest;
1081     else
1082         dst = dest + (block_num & 2) * 4 * s->linesize + (block_num & 1) * 8;
1083
1084     if (!(flags & RIGHT_EDGE) || !(block_num & 5)) {
1085         if (block_num > 3)
1086             v->vc1dsp.vc1_h_loop_filter8(dst + 8, linesize, pq);
1087         else
1088             v->vc1dsp.vc1_h_loop_filter8(dst + 8, linesize, pq);
1089     }
1090
1091     tt = ttblk[0] >> (block_num * 4) & 0xf;
1092     if (tt == TT_4X4 || tt == TT_4X8) {
1093         idx = (block_cbp | (block_cbp >> 1)) & 5;
1094         if (idx & 1)
1095             v->vc1dsp.vc1_h_loop_filter4(dst + 4 * linesize + 4, linesize, pq);
1096         if (idx & 4)
1097             v->vc1dsp.vc1_h_loop_filter4(dst + 4, linesize, pq);
1098     }
1099 }
1100
1101 static av_always_inline void vc1_b_v_intfi_loop_filter(VC1Context *v, uint8_t *dest, uint32_t *cbp,
1102                                                        int *ttblk, uint32_t flags, int block_num)
1103 {
1104     MpegEncContext *s  = &v->s;
1105     int pq = v->pq;
1106     uint8_t *dst;
1107     uint32_t block_cbp = cbp[0] >> (block_num * 4);
1108     int tt;
1109     int idx, linesize  = block_num > 3 ? s->uvlinesize : s->linesize;
1110
1111     if (block_num > 3)
1112         dst = dest;
1113     else
1114         dst = dest + (block_num & 2) * 4 * s->linesize + (block_num & 1) * 8;
1115
1116     if(!(flags & BOTTOM_EDGE) || block_num < 2)
1117         v->vc1dsp.vc1_v_loop_filter8(dst + 8 * linesize, linesize, pq);
1118
1119     tt = ttblk[0] >> (block_num * 4) & 0xf;
1120     if (tt == TT_4X4 || tt == TT_8X4) {
1121         idx = (block_cbp | (block_cbp >> 2)) & 3;
1122         if (idx & 1)
1123             v->vc1dsp.vc1_v_loop_filter4(dst + 4 * linesize + 4, linesize, pq);
1124         if (idx & 2)
1125             v->vc1dsp.vc1_v_loop_filter4(dst + 4 * linesize, linesize, pq);
1126     }
1127 }
1128
1129 void ff_vc1_b_intfi_loop_filter(VC1Context *v)
1130 {
1131     MpegEncContext *s = &v->s;
1132     int block_count = CONFIG_GRAY && (s->avctx->flags & AV_CODEC_FLAG_GRAY) ? 4 : 6;
1133     uint8_t *dest;
1134     uint32_t *cbp;
1135     int *ttblk;
1136     uint32_t flags = 0;
1137     int i;
1138
1139     /* Within a MB, the vertical loop filter always runs before the horizontal.
1140      * To accomplish that, we run the V loop filter on all applicable
1141      * horizontal borders of the MB above the currently decoded MB. Then,
1142      * we wait for the next loop filter iteration to do H loop filter on all
1143      * applicable vertical borders of this MB. Therefore, the loop filter
1144      * trails by one row and one column relative to the decoding loop. */
1145     if (!s->first_slice_line) {
1146         dest = s->dest[0] - 16 * s->linesize;
1147         cbp = &v->cbp[s->mb_x - s->mb_stride];
1148         ttblk = &v->ttblk[s->mb_x - s->mb_stride];
1149         flags = s->mb_y == s->start_mb_y + 1 ? TOP_EDGE : 0;
1150         for (i = 0; i < block_count; i++)
1151             vc1_b_v_intfi_loop_filter(v, i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize : dest, cbp, ttblk, flags, i);
1152     }
1153     if (s->mb_y == s->end_mb_y - 1) {
1154         dest = s->dest[0];
1155         cbp = &v->cbp[s->mb_x];
1156         ttblk = &v->ttblk[s->mb_x];
1157         flags = s->first_slice_line ? TOP_EDGE | BOTTOM_EDGE : BOTTOM_EDGE;
1158         for (i = 0; i < block_count; i++)
1159             vc1_b_v_intfi_loop_filter(v, i > 3 ? s->dest[i - 3] : dest, cbp, ttblk, flags, i);
1160     }
1161
1162     if (!s->first_slice_line) {
1163         dest = s->dest[0] - 16 * s->linesize - 16;
1164         cbp = &v->cbp[s->mb_x - s->mb_stride - 1];
1165         ttblk = &v->ttblk[s->mb_x - s->mb_stride - 1];
1166         if (s->mb_x) {
1167             flags = s->mb_x == 1 ? LEFT_EDGE : 0;
1168             for (i = 0; i < block_count; i++)
1169                 vc1_b_h_intfi_loop_filter(v, i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize - 8 : dest, cbp, ttblk, flags, i);
1170         }
1171         if (s->mb_x == s->mb_width - 1) {
1172             dest += 16;
1173             cbp++;
1174             ttblk++;
1175             flags = s->mb_x == 0 ? LEFT_EDGE | RIGHT_EDGE : RIGHT_EDGE;
1176             for (i = 0; i < block_count; i++)
1177                 vc1_b_h_intfi_loop_filter(v, i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize : dest, cbp, ttblk, flags, i);
1178         }
1179     }
1180     if (s->mb_y == s->end_mb_y - 1) {
1181         dest = s->dest[0] - 16;
1182         cbp = &v->cbp[s->mb_x - 1];
1183         ttblk = &v->ttblk[s->mb_x - 1];
1184         if (s->mb_x) {
1185             flags = s->mb_x == 1 ? LEFT_EDGE : 0;
1186             for (i = 0; i < block_count; i++)
1187                 vc1_b_h_intfi_loop_filter(v, i > 3 ? s->dest[i - 3] - 8 : dest, cbp, ttblk, flags, i);
1188         }
1189         if (s->mb_x == s->mb_width - 1) {
1190             dest += 16;
1191             cbp++;
1192             ttblk++;
1193             flags = s->mb_x == 0 ? LEFT_EDGE | RIGHT_EDGE : RIGHT_EDGE;
1194             for (i = 0; i < block_count; i++)
1195                 vc1_b_h_intfi_loop_filter(v, i > 3 ? s->dest[i - 3] : dest, cbp, ttblk, flags, i);
1196         }
1197     }
1198 }