Stowage/ffmpeg
2
0
Fork 0
mirror of https://git.ffmpeg.org/ffmpeg.git synced 2025-10-30 23:30:55 +00:00
Code Issues Projects Releases Packages Wiki Activity
ffmpeg/libavcodec/h264_loopfilter.c

693 lines
32 KiB
C
Raw Normal View History

Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
/*
* H.26L/H.264/AVC/JVT/14496-10/... loop filter
* Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
* @file libavcodec/h264_loopfilter.c
* H.264 / AVC / MPEG4 part10 loop filter.
* @author Michael Niedermayer <michaelni@gmx.at>
*/
#include "internal.h"
#include "dsputil.h"
#include "avcodec.h"
#include "mpegvideo.h"
#include "h264.h"
#include "mathops.h"
#include "rectangle.h"
//#undef NDEBUG
#include <assert.h>
/* Deblocking filter (p153) */
static const uint8_t alpha_table[52*3] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 4, 4, 5, 6,
7, 8, 9, 10, 12, 13, 15, 17, 20, 22,
25, 28, 32, 36, 40, 45, 50, 56, 63, 71,
80, 90,101,113,127,144,162,182,203,226,
255,255,
255,255,255,255,255,255,255,255,255,255,255,255,255,
255,255,255,255,255,255,255,255,255,255,255,255,255,
255,255,255,255,255,255,255,255,255,255,255,255,255,
255,255,255,255,255,255,255,255,255,255,255,255,255,
};
static const uint8_t beta_table[52*3] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 2, 2, 2, 3,
3, 3, 3, 4, 4, 4, 6, 6, 7, 7,
8, 8, 9, 9, 10, 10, 11, 11, 12, 12,
13, 13, 14, 14, 15, 15, 16, 16, 17, 17,
18, 18,
18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
};
static const uint8_t tc0_table[52*3][4] = {
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 },
{-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 0 }, {-1, 0, 0, 1 },
{-1, 0, 0, 1 }, {-1, 0, 0, 1 }, {-1, 0, 0, 1 }, {-1, 0, 1, 1 }, {-1, 0, 1, 1 }, {-1, 1, 1, 1 },
{-1, 1, 1, 1 }, {-1, 1, 1, 1 }, {-1, 1, 1, 1 }, {-1, 1, 1, 2 }, {-1, 1, 1, 2 }, {-1, 1, 1, 2 },
{-1, 1, 1, 2 }, {-1, 1, 2, 3 }, {-1, 1, 2, 3 }, {-1, 2, 2, 3 }, {-1, 2, 2, 4 }, {-1, 2, 3, 4 },
{-1, 2, 3, 4 }, {-1, 3, 3, 5 }, {-1, 3, 4, 6 }, {-1, 3, 4, 6 }, {-1, 4, 5, 7 }, {-1, 4, 5, 8 },
{-1, 4, 6, 9 }, {-1, 5, 7,10 }, {-1, 6, 8,11 }, {-1, 6, 8,13 }, {-1, 7,10,14 }, {-1, 8,11,16 },
{-1, 9,12,18 }, {-1,10,13,20 }, {-1,11,15,23 }, {-1,13,17,25 },
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
{-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 }, {-1,13,17,25 },
};
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
static void av_noinline filter_mb_edgev( uint8_t *pix, int stride, int16_t bS[4], unsigned int qp, H264Context *h) {
Move +52 from the loop filter to the alpha/beta offsets in the context. This should fix a segfault, also it might be faster on systems where the +52 wasnt free. Originally committed as revision 21406 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 18:05:30 +00:00
const unsigned int index_a = qp + h->slice_alpha_c0_offset;
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
const int alpha = alpha_table[index_a];
Move +52 from the loop filter to the alpha/beta offsets in the context. This should fix a segfault, also it might be faster on systems where the +52 wasnt free. Originally committed as revision 21406 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 18:05:30 +00:00
const int beta = beta_table[qp + h->slice_beta_offset];
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
if (alpha ==0 || beta == 0) return;
if( bS[0] < 4 ) {
int8_t tc[4];
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
tc[0] = tc0_table[index_a][bS[0]];
tc[1] = tc0_table[index_a][bS[1]];
tc[2] = tc0_table[index_a][bS[2]];
tc[3] = tc0_table[index_a][bS[3]];
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc);
} else {
h->s.dsp.h264_h_loop_filter_luma_intra(pix, stride, alpha, beta);
}
}
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
static void av_noinline filter_mb_edgecv( uint8_t *pix, int stride, int16_t bS[4], unsigned int qp, H264Context *h ) {
Move +52 from the loop filter to the alpha/beta offsets in the context. This should fix a segfault, also it might be faster on systems where the +52 wasnt free. Originally committed as revision 21406 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 18:05:30 +00:00
const unsigned int index_a = qp + h->slice_alpha_c0_offset;
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
const int alpha = alpha_table[index_a];
Move +52 from the loop filter to the alpha/beta offsets in the context. This should fix a segfault, also it might be faster on systems where the +52 wasnt free. Originally committed as revision 21406 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 18:05:30 +00:00
const int beta = beta_table[qp + h->slice_beta_offset];
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
if (alpha ==0 || beta == 0) return;
if( bS[0] < 4 ) {
int8_t tc[4];
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
tc[0] = tc0_table[index_a][bS[0]]+1;
tc[1] = tc0_table[index_a][bS[1]]+1;
tc[2] = tc0_table[index_a][bS[2]]+1;
tc[3] = tc0_table[index_a][bS[3]]+1;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc);
} else {
h->s.dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta);
}
}
Rather call filter_mb_mbaff_edge*v() more often than do extra calculations in the innerst loop. ~150 cpu cycles faster Originally committed as revision 21299 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-18 21:22:09 +00:00
static void filter_mb_mbaff_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int bsi, int qp ) {
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
int i;
Optimize filter_mb_mbaff_edge*() Originally committed as revision 21397 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 14:50:56 +00:00
int index_a = qp + h->slice_alpha_c0_offset;
Move +52 from the loop filter to the alpha/beta offsets in the context. This should fix a segfault, also it might be faster on systems where the +52 wasnt free. Originally committed as revision 21406 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 18:05:30 +00:00
int alpha = alpha_table[index_a];
int beta = beta_table[qp + h->slice_beta_offset];
Rather call filter_mb_mbaff_edge*v() more often than do extra calculations in the innerst loop. ~150 cpu cycles faster Originally committed as revision 21299 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-18 21:22:09 +00:00
for( i = 0; i < 8; i++, pix += stride) {
const int bS_index = (i >> 1) * bsi;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
if( bS[bS_index] == 0 ) {
continue;
}
if( bS[bS_index] < 4 ) {
Move +52 from the loop filter to the alpha/beta offsets in the context. This should fix a segfault, also it might be faster on systems where the +52 wasnt free. Originally committed as revision 21406 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 18:05:30 +00:00
const int tc0 = tc0_table[index_a][bS[bS_index]];
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
const int p0 = pix[-1];
const int p1 = pix[-2];
const int p2 = pix[-3];
const int q0 = pix[0];
const int q1 = pix[1];
const int q2 = pix[2];
if( FFABS( p0 - q0 ) < alpha &&
FFABS( p1 - p0 ) < beta &&
FFABS( q1 - q0 ) < beta ) {
int tc = tc0;
int i_delta;
if( FFABS( p2 - p0 ) < beta ) {
Optimize filter_mb_mbaff_edge*() Originally committed as revision 21397 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 14:50:56 +00:00
if(tc0)
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
pix[-2] = p1 + av_clip( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -tc0, tc0 );
tc++;
}
if( FFABS( q2 - q0 ) < beta ) {
Optimize filter_mb_mbaff_edge*() Originally committed as revision 21397 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 14:50:56 +00:00
if(tc0)
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
pix[1] = q1 + av_clip( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -tc0, tc0 );
tc++;
}
i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
pix[-1] = av_clip_uint8( p0 + i_delta ); /* p0' */
pix[0] = av_clip_uint8( q0 - i_delta ); /* q0' */
tprintf(h->s.avctx, "filter_mb_mbaff_edgev i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d, tc:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, tc, bS[bS_index], pix[-3], p1, p0, q0, q1, pix[2], p1, pix[-1], pix[0], q1);
}
}else{
const int p0 = pix[-1];
const int p1 = pix[-2];
const int p2 = pix[-3];
const int q0 = pix[0];
const int q1 = pix[1];
const int q2 = pix[2];
if( FFABS( p0 - q0 ) < alpha &&
FFABS( p1 - p0 ) < beta &&
FFABS( q1 - q0 ) < beta ) {
if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
if( FFABS( p2 - p0 ) < beta)
{
const int p3 = pix[-4];
/* p0', p1', p2' */
pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
} else {
/* p0' */
pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
}
if( FFABS( q2 - q0 ) < beta)
{
const int q3 = pix[3];
/* q0', q1', q2' */
pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
} else {
/* q0' */
pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
}
}else{
/* p0', q0' */
pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
}
tprintf(h->s.avctx, "filter_mb_mbaff_edgev i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, p2, p1, p0, q0, q1, q2, pix[-3], pix[-2], pix[-1], pix[0], pix[1], pix[2]);
}
}
}
}
Rather call filter_mb_mbaff_edge*v() more often than do extra calculations in the innerst loop. ~150 cpu cycles faster Originally committed as revision 21299 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-18 21:22:09 +00:00
static void filter_mb_mbaff_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int bsi, int qp ) {
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
int i;
Optimize filter_mb_mbaff_edge*() Originally committed as revision 21397 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 14:50:56 +00:00
int index_a = qp + h->slice_alpha_c0_offset;
Move +52 from the loop filter to the alpha/beta offsets in the context. This should fix a segfault, also it might be faster on systems where the +52 wasnt free. Originally committed as revision 21406 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 18:05:30 +00:00
int alpha = alpha_table[index_a];
int beta = beta_table[qp + h->slice_beta_offset];
Rather call filter_mb_mbaff_edge*v() more often than do extra calculations in the innerst loop. ~150 cpu cycles faster Originally committed as revision 21299 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-18 21:22:09 +00:00
for( i = 0; i < 4; i++, pix += stride) {
const int bS_index = i*bsi;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
if( bS[bS_index] == 0 ) {
continue;
}
if( bS[bS_index] < 4 ) {
Move +52 from the loop filter to the alpha/beta offsets in the context. This should fix a segfault, also it might be faster on systems where the +52 wasnt free. Originally committed as revision 21406 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 18:05:30 +00:00
const int tc = tc0_table[index_a][bS[bS_index]] + 1;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
const int p0 = pix[-1];
const int p1 = pix[-2];
const int q0 = pix[0];
const int q1 = pix[1];
if( FFABS( p0 - q0 ) < alpha &&
FFABS( p1 - p0 ) < beta &&
FFABS( q1 - q0 ) < beta ) {
const int i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
pix[-1] = av_clip_uint8( p0 + i_delta ); /* p0' */
pix[0] = av_clip_uint8( q0 - i_delta ); /* q0' */
tprintf(h->s.avctx, "filter_mb_mbaff_edgecv i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d, tc:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, tc, bS[bS_index], pix[-3], p1, p0, q0, q1, pix[2], p1, pix[-1], pix[0], q1);
}
}else{
const int p0 = pix[-1];
const int p1 = pix[-2];
const int q0 = pix[0];
const int q1 = pix[1];
if( FFABS( p0 - q0 ) < alpha &&
FFABS( p1 - p0 ) < beta &&
FFABS( q1 - q0 ) < beta ) {
pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2; /* p0' */
pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; /* q0' */
tprintf(h->s.avctx, "filter_mb_mbaff_edgecv i:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x, %02x, %02x]\n", i, pix[-3], p1, p0, q0, q1, pix[2], pix[-3], pix[-2], pix[-1], pix[0], pix[1], pix[2]);
}
}
}
}
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
static void av_noinline filter_mb_edgeh( uint8_t *pix, int stride, int16_t bS[4], unsigned int qp, H264Context *h ) {
Move +52 from the loop filter to the alpha/beta offsets in the context. This should fix a segfault, also it might be faster on systems where the +52 wasnt free. Originally committed as revision 21406 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 18:05:30 +00:00
const unsigned int index_a = qp + h->slice_alpha_c0_offset;
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
const int alpha = alpha_table[index_a];
Move +52 from the loop filter to the alpha/beta offsets in the context. This should fix a segfault, also it might be faster on systems where the +52 wasnt free. Originally committed as revision 21406 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 18:05:30 +00:00
const int beta = beta_table[qp + h->slice_beta_offset];
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
if (alpha ==0 || beta == 0) return;
if( bS[0] < 4 ) {
int8_t tc[4];
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
tc[0] = tc0_table[index_a][bS[0]];
tc[1] = tc0_table[index_a][bS[1]];
tc[2] = tc0_table[index_a][bS[2]];
tc[3] = tc0_table[index_a][bS[3]];
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc);
} else {
h->s.dsp.h264_v_loop_filter_luma_intra(pix, stride, alpha, beta);
}
}
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
static void av_noinline filter_mb_edgech( uint8_t *pix, int stride, int16_t bS[4], unsigned int qp, H264Context *h ) {
Move +52 from the loop filter to the alpha/beta offsets in the context. This should fix a segfault, also it might be faster on systems where the +52 wasnt free. Originally committed as revision 21406 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 18:05:30 +00:00
const unsigned int index_a = qp + h->slice_alpha_c0_offset;
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
const int alpha = alpha_table[index_a];
Move +52 from the loop filter to the alpha/beta offsets in the context. This should fix a segfault, also it might be faster on systems where the +52 wasnt free. Originally committed as revision 21406 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 18:05:30 +00:00
const int beta = beta_table[qp + h->slice_beta_offset];
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
if (alpha ==0 || beta == 0) return;
if( bS[0] < 4 ) {
int8_t tc[4];
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
tc[0] = tc0_table[index_a][bS[0]]+1;
tc[1] = tc0_table[index_a][bS[1]]+1;
tc[2] = tc0_table[index_a][bS[2]]+1;
tc[3] = tc0_table[index_a][bS[3]]+1;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc);
} else {
h->s.dsp.h264_v_loop_filter_chroma_intra(pix, stride, alpha, beta);
}
}
void ff_h264_filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize) {
MpegEncContext * const s = &h->s;
Simplify loop filter a little by using top/left_type. Originally committed as revision 21457 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-26 13:39:26 +00:00
int mb_xy;
int mb_type;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh;
mb_xy = h->mb_xy;
Simplify loop filter a little by using top/left_type. Originally committed as revision 21457 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-26 13:39:26 +00:00
if(!h->top_type || !h->left_type[0] || !s->dsp.h264_loop_filter_strength || h->pps.chroma_qp_diff) {
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
ff_h264_filter_mb(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize);
return;
}
assert(!FRAME_MBAFF);
mb_type = s->current_picture.mb_type[mb_xy];
qp = s->current_picture.qscale_table[mb_xy];
qp0 = s->current_picture.qscale_table[mb_xy-1];
qp1 = s->current_picture.qscale_table[h->top_mb_xy];
qpc = get_chroma_qp( h, 0, qp );
qpc0 = get_chroma_qp( h, 0, qp0 );
qpc1 = get_chroma_qp( h, 0, qp1 );
qp0 = (qp + qp0 + 1) >> 1;
qp1 = (qp + qp1 + 1) >> 1;
qpc0 = (qpc + qpc0 + 1) >> 1;
qpc1 = (qpc + qpc1 + 1) >> 1;
Move +52 from the loop filter to the alpha/beta offsets in the context. This should fix a segfault, also it might be faster on systems where the +52 wasnt free. Originally committed as revision 21406 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 18:05:30 +00:00
qp_thresh = 15+52 - h->slice_alpha_c0_offset;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
if(qp <= qp_thresh && qp0 <= qp_thresh && qp1 <= qp_thresh &&
qpc <= qp_thresh && qpc0 <= qp_thresh && qpc1 <= qp_thresh)
return;
if( IS_INTRA(mb_type) ) {
int16_t bS4[4] = {4,4,4,4};
int16_t bS3[4] = {3,3,3,3};
int16_t *bSH = FIELD_PICTURE ? bS3 : bS4;
if( IS_8x8DCT(mb_type) ) {
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
filter_mb_edgev( &img_y[4*0], linesize, bS4, qp0, h);
filter_mb_edgev( &img_y[4*2], linesize, bS3, qp, h);
filter_mb_edgeh( &img_y[4*0*linesize], linesize, bSH, qp1, h);
filter_mb_edgeh( &img_y[4*2*linesize], linesize, bS3, qp, h);
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
} else {
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
filter_mb_edgev( &img_y[4*0], linesize, bS4, qp0, h);
filter_mb_edgev( &img_y[4*1], linesize, bS3, qp, h);
filter_mb_edgev( &img_y[4*2], linesize, bS3, qp, h);
filter_mb_edgev( &img_y[4*3], linesize, bS3, qp, h);
filter_mb_edgeh( &img_y[4*0*linesize], linesize, bSH, qp1, h);
filter_mb_edgeh( &img_y[4*1*linesize], linesize, bS3, qp, h);
filter_mb_edgeh( &img_y[4*2*linesize], linesize, bS3, qp, h);
filter_mb_edgeh( &img_y[4*3*linesize], linesize, bS3, qp, h);
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
}
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
filter_mb_edgecv( &img_cb[2*0], uvlinesize, bS4, qpc0, h);
filter_mb_edgecv( &img_cb[2*2], uvlinesize, bS3, qpc, h);
filter_mb_edgecv( &img_cr[2*0], uvlinesize, bS4, qpc0, h);
filter_mb_edgecv( &img_cr[2*2], uvlinesize, bS3, qpc, h);
filter_mb_edgech( &img_cb[2*0*uvlinesize], uvlinesize, bSH, qpc1, h);
filter_mb_edgech( &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc, h);
filter_mb_edgech( &img_cr[2*0*uvlinesize], uvlinesize, bSH, qpc1, h);
filter_mb_edgech( &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc, h);
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
return;
} else {
Move array specifiers outside DECLARE_ALIGNED() invocations Originally committed as revision 21377 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 03:25:11 +00:00
DECLARE_ALIGNED_8(int16_t, bS)[2][4][4];
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
uint64_t (*bSv)[4] = (uint64_t(*)[4])bS;
int edges;
if( IS_8x8DCT(mb_type) && (h->cbp&7) == 7 ) {
edges = 4;
bSv[0][0] = bSv[0][2] = bSv[1][0] = bSv[1][2] = 0x0002000200020002ULL;
} else {
int mask_edge1 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 :
(mb_type & MB_TYPE_16x8) ? 1 : 0;
int mask_edge0 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16))
Simplify loop filter a little by using top/left_type. Originally committed as revision 21457 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-26 13:39:26 +00:00
&& (h->left_type[0] & (MB_TYPE_16x16 | MB_TYPE_8x16))
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
? 3 : 0;
int step = IS_8x8DCT(mb_type) ? 2 : 1;
edges = (mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4;
s->dsp.h264_loop_filter_strength( bS, h->non_zero_count_cache, h->ref_cache, h->mv_cache,
Remove all uses of slice_type* from the loop filter, also remove its initialization befre the loop filter. Originally committed as revision 21416 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-24 13:20:17 +00:00
h->list_count==2, edges, step, mask_edge0, mask_edge1, FIELD_PICTURE);
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
}
Simplify loop filter a little by using top/left_type. Originally committed as revision 21457 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-26 13:39:26 +00:00
if( IS_INTRA(h->left_type[0]) )
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
bSv[0][0] = 0x0004000400040004ULL;
Simplify loop filter a little by using top/left_type. Originally committed as revision 21457 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-26 13:39:26 +00:00
if( IS_INTRA(h->top_type) )
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
bSv[1][0] = FIELD_PICTURE ? 0x0003000300030003ULL : 0x0004000400040004ULL;
#define FILTER(hv,dir,edge)\
if(bSv[dir][edge]) {\
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
filter_mb_edge##hv( &img_y[4*edge*(dir?linesize:1)], linesize, bS[dir][edge], edge ? qp : qp##dir, h );\
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
if(!(edge&1)) {\
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
filter_mb_edgec##hv( &img_cb[2*edge*(dir?uvlinesize:1)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir, h );\
filter_mb_edgec##hv( &img_cr[2*edge*(dir?uvlinesize:1)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir, h );\
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
}\
}
if( edges == 1 ) {
FILTER(v,0,0);
FILTER(h,1,0);
} else if( IS_8x8DCT(mb_type) ) {
FILTER(v,0,0);
FILTER(v,0,2);
FILTER(h,1,0);
FILTER(h,1,2);
} else {
FILTER(v,0,0);
FILTER(v,0,1);
FILTER(v,0,2);
FILTER(v,0,3);
FILTER(h,1,0);
FILTER(h,1,1);
FILTER(h,1,2);
FILTER(h,1,3);
}
#undef FILTER
}
}
static av_always_inline void filter_mb_dir(H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize, int mb_xy, int mb_type, int mvy_limit, int first_vertical_edge_done, int dir) {
MpegEncContext * const s = &h->s;
int edge;
const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy;
Simplify loop filter a little by using top/left_type. Originally committed as revision 21457 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-26 13:39:26 +00:00
const int mbm_type = dir == 0 ? h->left_type[0] : h->top_type;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
// how often to recheck mv-based bS when iterating between edges
Make calculation of mask_edge free of branches, faster of course but probably little effect overall as this is not that often executed. Originally committed as revision 21366 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-21 16:50:31 +00:00
static const uint8_t mask_edge_tab[2][8]={{0,3,3,3,1,1,1,1},
{0,3,1,1,3,3,3,3}};
const int mask_edge = mask_edge_tab[dir][(mb_type>>3)&7];
Set edges based on cbp and mv partitioning, not just skiped MBs. This is faster for videos that have lots of MBs that fall in this category. Originally committed as revision 21400 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 15:28:34 +00:00
const int edges = mask_edge== 3 && !(h->cbp&15) ? 1 : 4;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
// how often to recheck mv-based bS when iterating along each edge
const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir));
Sightly simplify initialization of int start. No real speed change. Originally committed as revision 21336 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 00:17:16 +00:00
int start = h->slice_table[mbm_xy] == 0xFFFF
|| first_vertical_edge_done
|| (h->deblocking_filter==2 && h->slice_table[mbm_xy] != h->slice_num);
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) && start == 0
Merge multiple IS_* macro uses where possible. Originally committed as revision 21340 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 01:15:30 +00:00
&& IS_INTERLACED(mbm_type&~mb_type)
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
) {
// This is a special case in the norm where the filtering must
// be done twice (one each of the field) even if we are in a
// frame macroblock.
//
unsigned int tmp_linesize = 2 * linesize;
unsigned int tmp_uvlinesize = 2 * uvlinesize;
int mbn_xy = mb_xy - 2 * s->mb_stride;
Simplify/Optimize another of the mbaff loop filter cases. Its faster but too rarely used to make a differnce. Originally committed as revision 21344 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 03:00:08 +00:00
int j;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
for(j=0; j<2; j++, mbn_xy += s->mb_stride){
Move array specifiers outside DECLARE_ALIGNED() invocations Originally committed as revision 21377 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 03:25:11 +00:00
DECLARE_ALIGNED_8(int16_t, bS)[4];
Simplify/Optimize another of the mbaff loop filter cases. Its faster but too rarely used to make a differnce. Originally committed as revision 21344 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 03:00:08 +00:00
int qp;
Merge multiple IS_* macro uses where possible. Originally committed as revision 21340 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 01:15:30 +00:00
if( IS_INTRA(mb_type|s->current_picture.mb_type[mbn_xy]) ) {
Set bS with 64bits at a time. Originally committed as revision 21341 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 01:38:32 +00:00
*(uint64_t*)bS= 0x0003000300030003ULL;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
} else {
Simplify/Optimize another of the mbaff loop filter cases. Its faster but too rarely used to make a differnce. Originally committed as revision 21344 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 03:00:08 +00:00
const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy] + 4+3*8;
int i;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
for( i = 0; i < 4; i++ ) {
Simplify/Optimize another of the mbaff loop filter cases. Its faster but too rarely used to make a differnce. Originally committed as revision 21344 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 03:00:08 +00:00
bS[i] = 1 + !!(h->non_zero_count_cache[scan8[0]+i] | mbn_nnz[i]);
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
}
}
// Do not use s->qscale as luma quantizer because it has not the same
// value in IPCM macroblocks.
qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, tmp_linesize, tmp_uvlinesize);
{ int i; for (i = 0; i < 4; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); }
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
filter_mb_edgeh( &img_y[j*linesize], tmp_linesize, bS, qp, h );
filter_mb_edgech( &img_cb[j*uvlinesize], tmp_uvlinesize, bS,
( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1, h);
filter_mb_edgech( &img_cr[j*uvlinesize], tmp_uvlinesize, bS,
( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1, h);
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
}
start = 1;
}
/* Calculate bS */
for( edge = start; edge < edges; edge++ ) {
/* mbn_xy: neighbor macroblock */
const int mbn_xy = edge > 0 ? mb_xy : mbm_xy;
const int mbn_type = s->current_picture.mb_type[mbn_xy];
Move array specifiers outside DECLARE_ALIGNED() invocations Originally committed as revision 21377 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 03:25:11 +00:00
DECLARE_ALIGNED_8(int16_t, bS)[4];
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
int qp;
Optmize 8x8dct check used to skip some borders in the loop filter. 4 cpu cycles faster. Originally committed as revision 21396 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-23 13:54:02 +00:00
if( IS_8x8DCT(mb_type & (edge<<24)) ) // (edge&1) && IS_8x8DCT(mb_type)
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
continue;
Simplify and optimize intra code in h264_loopfilter.c Originally committed as revision 21339 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 00:44:03 +00:00
if( IS_INTRA(mb_type|mbn_type)) {
*(uint64_t*)bS= 0x0003000300030003ULL;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
if (edge == 0) {
Simplify and optimize intra code in h264_loopfilter.c Originally committed as revision 21339 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 00:44:03 +00:00
if ( (!IS_INTERLACED(mb_type|mbm_type))
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
|| ((FRAME_MBAFF || (s->picture_structure != PICT_FRAME)) && (dir == 0))
Simplify and optimize intra code in h264_loopfilter.c Originally committed as revision 21339 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 00:44:03 +00:00
)
*(uint64_t*)bS= 0x0004000400040004ULL;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
}
} else {
int i, l;
int mv_done;
if( edge & mask_edge ) {
Set bS with 64bits at a time. Originally committed as revision 21341 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 01:38:32 +00:00
*(uint64_t*)bS= 0;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
mv_done = 1;
}
else if( FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbn_type)) {
Set bS with 64bits at a time. Originally committed as revision 21341 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 01:38:32 +00:00
*(uint64_t*)bS= 0x0001000100010001ULL;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
mv_done = 1;
}
else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) {
int b_idx= 8 + 4 + edge * (dir ? 8:1);
int bn_idx= b_idx - (dir ? 8:1);
int v = 0;
Remove all uses of slice_type* from the loop filter, also remove its initialization befre the loop filter. Originally committed as revision 21416 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-24 13:20:17 +00:00
for( l = 0; !v && l < h->list_count; l++ ) {
Perform reference remapping at fill_cache() time instead of in the loop filter. This removes one obstacle of getting ff_h264_filter_mb_fast() bitexact. code is maybe 0.1% faster Originally committed as revision 21280 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-18 05:15:31 +00:00
v |= h->ref_cache[l][b_idx] != h->ref_cache[l][bn_idx] |
Another microopt, 4 cpu cycles for avoidance of FFABS(). Originally committed as revision 21248 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-16 16:14:32 +00:00
h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] + 3 >= 7U |
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit;
}
Remove all uses of slice_type* from the loop filter, also remove its initialization befre the loop filter. Originally committed as revision 21416 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-24 13:20:17 +00:00
if(h->list_count==2 && v){
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
v=0;
for( l = 0; !v && l < 2; l++ ) {
int ln= 1-l;
Perform reference remapping at fill_cache() time instead of in the loop filter. This removes one obstacle of getting ff_h264_filter_mb_fast() bitexact. code is maybe 0.1% faster Originally committed as revision 21280 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-18 05:15:31 +00:00
v |= h->ref_cache[l][b_idx] != h->ref_cache[ln][bn_idx] |
Another microopt, 4 cpu cycles for avoidance of FFABS(). Originally committed as revision 21248 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-16 16:14:32 +00:00
h->mv_cache[l][b_idx][0] - h->mv_cache[ln][bn_idx][0] + 3 >= 7U |
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[ln][bn_idx][1] ) >= mvy_limit;
}
}
bS[0] = bS[1] = bS[2] = bS[3] = v;
mv_done = 1;
}
else
mv_done = 0;
for( i = 0; i < 4; i++ ) {
int x = dir == 0 ? edge : i;
int y = dir == 0 ? i : edge;
int b_idx= 8 + 4 + x + 8*y;
int bn_idx= b_idx - (dir ? 8:1);
if( h->non_zero_count_cache[b_idx] |
h->non_zero_count_cache[bn_idx] ) {
bS[i] = 2;
}
else if(!mv_done)
{
bS[i] = 0;
Remove all uses of slice_type* from the loop filter, also remove its initialization befre the loop filter. Originally committed as revision 21416 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-24 13:20:17 +00:00
for( l = 0; l < h->list_count; l++ ) {
Perform reference remapping at fill_cache() time instead of in the loop filter. This removes one obstacle of getting ff_h264_filter_mb_fast() bitexact. code is maybe 0.1% faster Originally committed as revision 21280 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-18 05:15:31 +00:00
if( h->ref_cache[l][b_idx] != h->ref_cache[l][bn_idx] |
Apply last 2 optimizations to similar code i forgot. Originally committed as revision 21249 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-16 16:21:12 +00:00
h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] + 3 >= 7U |
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit ) {
bS[i] = 1;
break;
}
}
Remove all uses of slice_type* from the loop filter, also remove its initialization befre the loop filter. Originally committed as revision 21416 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-24 13:20:17 +00:00
if(h->list_count == 2 && bS[i]){
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
bS[i] = 0;
for( l = 0; l < 2; l++ ) {
int ln= 1-l;
Perform reference remapping at fill_cache() time instead of in the loop filter. This removes one obstacle of getting ff_h264_filter_mb_fast() bitexact. code is maybe 0.1% faster Originally committed as revision 21280 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-18 05:15:31 +00:00
if( h->ref_cache[l][b_idx] != h->ref_cache[ln][bn_idx] |
Apply last 2 optimizations to similar code i forgot. Originally committed as revision 21249 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-16 16:21:12 +00:00
h->mv_cache[l][b_idx][0] - h->mv_cache[ln][bn_idx][0] + 3 >= 7U |
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[ln][bn_idx][1] ) >= mvy_limit ) {
bS[i] = 1;
break;
}
}
}
}
}
if(bS[0]+bS[1]+bS[2]+bS[3] == 0)
continue;
}
/* Filter edge */
// Do not use s->qscale as luma quantizer because it has not the same
// value in IPCM macroblocks.
qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
Rearchitecturing the stiched up goose part 1 Run loop filter per row instead of per MB, this also should make it much easier to switch to per frame filtering and also doing so in a seperate thread in the future if some volunteer wants to try. Overall decoding speedup of 1.7% (single thread on pentium dual / cathedral sample) This change also allows some optimizations to be tried that would not have been possible before. Originally committed as revision 21270 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-17 20:35:55 +00:00
//tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp[0], s->current_picture.qscale_table[mbn_xy]);
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);
Comment for() ; out ~200 bytes smaller ff_h264_filter_mb() please everyone, NEVER add code with the assumtation that gcc will remove it without checking gcc actually does. Chances are it does not. Originally committed as revision 21251 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-16 17:41:40 +00:00
//{ int i; for (i = 0; i < 4; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); }
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
if( dir == 0 ) {
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
filter_mb_edgev( &img_y[4*edge], linesize, bS, qp, h );
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
if( (edge&1) == 0 ) {
Only calculate the second chroma qp if it differs from the firstin the main loop filter. (a little faster for the common case where they are equal) Originally committed as revision 21342 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 01:49:24 +00:00
int qp= ( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
filter_mb_edgecv( &img_cb[2*edge], uvlinesize, bS, qp, h);
Only calculate the second chroma qp if it differs from the firstin the main loop filter. (a little faster for the common case where they are equal) Originally committed as revision 21342 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 01:49:24 +00:00
if(h->pps.chroma_qp_diff)
qp= ( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
filter_mb_edgecv( &img_cr[2*edge], uvlinesize, bS, qp, h);
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
}
} else {
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
filter_mb_edgeh( &img_y[4*edge*linesize], linesize, bS, qp, h );
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
if( (edge&1) == 0 ) {
Only calculate the second chroma qp if it differs from the firstin the main loop filter. (a little faster for the common case where they are equal) Originally committed as revision 21342 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 01:49:24 +00:00
int qp= ( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
filter_mb_edgech( &img_cb[2*edge*uvlinesize], uvlinesize, bS, qp, h);
Only calculate the second chroma qp if it differs from the firstin the main loop filter. (a little faster for the common case where they are equal) Originally committed as revision 21342 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 01:49:24 +00:00
if(h->pps.chroma_qp_diff)
qp= ( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
Gcc idiocy fixes related to filter_mb_edge*. Change order of operands as gcc uses a hardcoded register per operand it seems even for static functions thus reducing unneeded moved (now functions try to pass the same argument in the same spot). Change signed int to unsigned int for array indexes as signed requires signed extension while unsigned is free. move the +52 up and merge it where it will end as a lea instruction, gcc always splits the 52 out there turning the free +52 into an expensive one otherwise. The changed code becomes a little faster. Originally committed as revision 21375 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 01:59:17 +00:00
filter_mb_edgech( &img_cr[2*edge*uvlinesize], uvlinesize, bS, qp, h);
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
}
}
}
}
void ff_h264_filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize) {
MpegEncContext * const s = &h->s;
const int mb_xy= mb_x + mb_y*s->mb_stride;
const int mb_type = s->current_picture.mb_type[mb_xy];
const int mvy_limit = IS_INTERLACED(mb_type) ? 2 : 4;
int first_vertical_edge_done = 0;
av_unused int dir;
Rearchitecturing the stiched up goose part 1 Run loop filter per row instead of per MB, this also should make it much easier to switch to per frame filtering and also doing so in a seperate thread in the future if some volunteer wants to try. Overall decoding speedup of 1.7% (single thread on pentium dual / cathedral sample) This change also allows some optimizations to be tried that would not have been possible before. Originally committed as revision 21270 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-17 20:35:55 +00:00
int list;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
if (FRAME_MBAFF
// and current and left pair do not have the same interlaced type
Simplify loop filter a little by using top/left_type. Originally committed as revision 21457 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-26 13:39:26 +00:00
&& IS_INTERLACED(mb_type^h->left_type[0])
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
// and left mb is in the same slice if deblocking_filter == 2
Simplify loop filter a little by using top/left_type. Originally committed as revision 21457 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-26 13:39:26 +00:00
&& h->left_type[0]) {
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
/* First vertical edge is different in MBAFF frames
* There are 8 different bS to compute and 2 different Qp
*/
Move array specifiers outside DECLARE_ALIGNED() invocations Originally committed as revision 21377 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-22 03:25:11 +00:00
DECLARE_ALIGNED_8(int16_t, bS)[8];
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
int qp[2];
int bqp[2];
int rqp[2];
int mb_qp, mbn0_qp, mbn1_qp;
int i;
first_vertical_edge_done = 1;
if( IS_INTRA(mb_type) )
Set bS with 64bits at a time. Originally committed as revision 21341 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-20 01:38:32 +00:00
*(uint64_t*)&bS[0]=
*(uint64_t*)&bS[4]= 0x0004000400040004ULL;
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
else {
for( i = 0; i < 8; i++ ) {
Use left_mb_xy from fill_caches instead of recalculating it. Originally committed as revision 21459 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-26 14:57:53 +00:00
int mbn_xy = MB_FIELD ? h->left_mb_xy[i>>2] : h->left_mb_xy[i&1];
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
if( IS_INTRA( s->current_picture.mb_type[mbn_xy] ) )
bS[i] = 4;
else if( h->non_zero_count_cache[12+8*(i>>1)] != 0 ||
((!h->pps.cabac && IS_8x8DCT(s->current_picture.mb_type[mbn_xy])) ?
(h->cbp_table[mbn_xy] & ((MB_FIELD ? (i&2) : (mb_y&1)) ? 8 : 2))
:
Reorganize how values are stored in h->non_zero_count. ~1% faster Originally committed as revision 21273 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-17 23:44:23 +00:00
h->non_zero_count[mbn_xy][7+(MB_FIELD ? (i&3) : (i>>2)+(mb_y&1)*2)*8]))
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
bS[i] = 2;
else
bS[i] = 1;
}
}
mb_qp = s->current_picture.qscale_table[mb_xy];
Use left_mb_xy from fill_caches instead of recalculating it. Originally committed as revision 21459 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-26 14:57:53 +00:00
mbn0_qp = s->current_picture.qscale_table[h->left_mb_xy[0]];
mbn1_qp = s->current_picture.qscale_table[h->left_mb_xy[1]];
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1;
bqp[0] = ( get_chroma_qp( h, 0, mb_qp ) +
get_chroma_qp( h, 0, mbn0_qp ) + 1 ) >> 1;
rqp[0] = ( get_chroma_qp( h, 1, mb_qp ) +
get_chroma_qp( h, 1, mbn0_qp ) + 1 ) >> 1;
qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1;
bqp[1] = ( get_chroma_qp( h, 0, mb_qp ) +
get_chroma_qp( h, 0, mbn1_qp ) + 1 ) >> 1;
rqp[1] = ( get_chroma_qp( h, 1, mb_qp ) +
get_chroma_qp( h, 1, mbn1_qp ) + 1 ) >> 1;
/* Filter edge */
tprintf(s->avctx, "filter mb:%d/%d MBAFF, QPy:%d/%d, QPb:%d/%d QPr:%d/%d ls:%d uvls:%d", mb_x, mb_y, qp[0], qp[1], bqp[0], bqp[1], rqp[0], rqp[1], linesize, uvlinesize);
{ int i; for (i = 0; i < 8; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); }
Rather call filter_mb_mbaff_edge*v() more often than do extra calculations in the innerst loop. ~150 cpu cycles faster Originally committed as revision 21299 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-18 21:22:09 +00:00
if(MB_FIELD){
filter_mb_mbaff_edgev ( h, img_y , linesize, bS , 1, qp [0] );
filter_mb_mbaff_edgev ( h, img_y + 8* linesize, linesize, bS+4, 1, qp [1] );
filter_mb_mbaff_edgecv( h, img_cb, uvlinesize, bS , 1, bqp[0] );
filter_mb_mbaff_edgecv( h, img_cb + 4*uvlinesize, uvlinesize, bS+4, 1, bqp[1] );
filter_mb_mbaff_edgecv( h, img_cr, uvlinesize, bS , 1, rqp[0] );
filter_mb_mbaff_edgecv( h, img_cr + 4*uvlinesize, uvlinesize, bS+4, 1, rqp[1] );
}else{
filter_mb_mbaff_edgev ( h, img_y , 2* linesize, bS , 2, qp [0] );
filter_mb_mbaff_edgev ( h, img_y + linesize, 2* linesize, bS+1, 2, qp [1] );
filter_mb_mbaff_edgecv( h, img_cb, 2*uvlinesize, bS , 2, bqp[0] );
filter_mb_mbaff_edgecv( h, img_cb + uvlinesize, 2*uvlinesize, bS+1, 2, bqp[1] );
filter_mb_mbaff_edgecv( h, img_cr, 2*uvlinesize, bS , 2, rqp[0] );
filter_mb_mbaff_edgecv( h, img_cr + uvlinesize, 2*uvlinesize, bS+1, 2, rqp[1] );
}
Split h264 loop filter off h264.c. No meassureable speed difference on pentium dual & cathedral sample. Originally committed as revision 21159 to svn://svn.ffmpeg.org/ffmpeg/trunk
2010-01-12 06:01:55 +00:00
}
#if CONFIG_SMALL
for( dir = 0; dir < 2; dir++ )
filter_mb_dir(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, mb_xy, mb_type, mvy_limit, dir ? 0 : first_vertical_edge_done, dir);
#else
filter_mb_dir(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, mb_xy, mb_type, mvy_limit, first_vertical_edge_done, 0);
filter_mb_dir(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, mb_xy, mb_type, mvy_limit, 0, 1);
#endif
}
Reference in a new issue Copy permalink