falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
90859 Commits
32 Branches
293MB
Tree: 02e4970bc9
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '02e4970bc9'
${ noResults }
FFmpeg/libavcodec/vc1_loopfilter.c

1199 lines
55KB
Raw Blame History 

  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. }