h264: merge _internal & template files.
seems git missed them and we temporary lost our improvments in them. Signed-off-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer
parent
3b6bbfa063
commit
d18e243f62
File diff suppressed because it is too large
Load Diff
|
|
@ -5,20 +5,20 @@
|
|||
*
|
||||
* gmc & q-pel & 32/64 bit based MC by Michael Niedermayer <michaelni@gmx.at>
|
||||
*
|
||||
* This file is part of Libav.
|
||||
* This file is part of FFmpeg.
|
||||
*
|
||||
* Libav is free software; you can redistribute it and/or
|
||||
* 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.
|
||||
*
|
||||
* Libav is distributed in the hope that it will be useful,
|
||||
* 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 Libav; if not, write to the Free Software
|
||||
* License along with FFmpeg; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
|
|
@ -79,10 +79,10 @@ static inline void FUNC(copy_block16)(uint8_t *dst, const uint8_t *src, int dstS
|
|||
|
||||
/* draw the edges of width 'w' of an image of size width, height */
|
||||
//FIXME check that this is ok for mpeg4 interlaced
|
||||
static void FUNCC(draw_edges)(uint8_t *_buf, int _wrap, int width, int height, int w, int sides)
|
||||
static void FUNCC(draw_edges)(uint8_t *p_buf, int p_wrap, int width, int height, int w, int sides)
|
||||
{
|
||||
pixel *buf = (pixel*)_buf;
|
||||
int wrap = _wrap / sizeof(pixel);
|
||||
pixel *buf = (pixel*)p_buf;
|
||||
int wrap = p_wrap / sizeof(pixel);
|
||||
pixel *ptr, *last_line;
|
||||
int i;
|
||||
|
||||
|
|
@ -192,12 +192,12 @@ void FUNC(ff_emulated_edge_mc)(uint8_t *buf, const uint8_t *src, int linesize, i
|
|||
}
|
||||
}
|
||||
|
||||
static void FUNCC(add_pixels8)(uint8_t *restrict _pixels, DCTELEM *_block, int line_size)
|
||||
static void FUNCC(add_pixels8)(uint8_t *restrict p_pixels, DCTELEM *p_block, int line_size)
|
||||
{
|
||||
int i;
|
||||
pixel *restrict pixels = (pixel *restrict)_pixels;
|
||||
dctcoef *block = (dctcoef*)_block;
|
||||
line_size /= sizeof(pixel);
|
||||
pixel *restrict pixels = (pixel *restrict)p_pixels;
|
||||
dctcoef *block = (dctcoef*)p_block;
|
||||
line_size >>= sizeof(pixel)-1;
|
||||
|
||||
for(i=0;i<8;i++) {
|
||||
pixels[0] += block[0];
|
||||
|
|
@ -213,12 +213,12 @@ static void FUNCC(add_pixels8)(uint8_t *restrict _pixels, DCTELEM *_block, int l
|
|||
}
|
||||
}
|
||||
|
||||
static void FUNCC(add_pixels4)(uint8_t *restrict _pixels, DCTELEM *_block, int line_size)
|
||||
static void FUNCC(add_pixels4)(uint8_t *restrict p_pixels, DCTELEM *p_block, int line_size)
|
||||
{
|
||||
int i;
|
||||
pixel *restrict pixels = (pixel *restrict)_pixels;
|
||||
dctcoef *block = (dctcoef*)_block;
|
||||
line_size /= sizeof(pixel);
|
||||
pixel *restrict pixels = (pixel *restrict)p_pixels;
|
||||
dctcoef *block = (dctcoef*)p_block;
|
||||
line_size >>= sizeof(pixel)-1;
|
||||
|
||||
for(i=0;i<4;i++) {
|
||||
pixels[0] += block[0];
|
||||
|
|
@ -582,12 +582,12 @@ static inline void FUNC(OPNAME ## _no_rnd_pixels16_l4)(uint8_t *dst, const uint8
|
|||
FUNC(OPNAME ## _no_rnd_pixels8_l4)(dst+8*sizeof(pixel), src1+8*sizeof(pixel), src2+8*sizeof(pixel), src3+8*sizeof(pixel), src4+8*sizeof(pixel), dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\
|
||||
}\
|
||||
\
|
||||
static inline void FUNCC(OPNAME ## _pixels2_xy2)(uint8_t *_block, const uint8_t *_pixels, int line_size, int h)\
|
||||
static inline void FUNCC(OPNAME ## _pixels2_xy2)(uint8_t *p_block, const uint8_t *p_pixels, int line_size, int h)\
|
||||
{\
|
||||
int i, a0, b0, a1, b1;\
|
||||
pixel *block = (pixel*)_block;\
|
||||
const pixel *pixels = (const pixel*)_pixels;\
|
||||
line_size /= sizeof(pixel);\
|
||||
pixel *block = (pixel*)p_block;\
|
||||
const pixel *pixels = (const pixel*)p_pixels;\
|
||||
line_size >>= sizeof(pixel)-1;\
|
||||
a0= pixels[0];\
|
||||
b0= pixels[1] + 2;\
|
||||
a0 += b0;\
|
||||
|
|
@ -769,15 +769,15 @@ static void FUNCC(put_no_rnd_pixels8_l2)(uint8_t *dst, const uint8_t *a, const u
|
|||
}
|
||||
|
||||
#define H264_CHROMA_MC(OPNAME, OP)\
|
||||
static void FUNCC(OPNAME ## h264_chroma_mc2)(uint8_t *_dst/*align 8*/, uint8_t *_src/*align 1*/, int stride, int h, int x, int y){\
|
||||
pixel *dst = (pixel*)_dst;\
|
||||
pixel *src = (pixel*)_src;\
|
||||
static void FUNCC(OPNAME ## h264_chroma_mc2)(uint8_t *p_dst/*align 8*/, uint8_t *p_src/*align 1*/, int stride, int h, int x, int y){\
|
||||
pixel *dst = (pixel*)p_dst;\
|
||||
pixel *src = (pixel*)p_src;\
|
||||
const int A=(8-x)*(8-y);\
|
||||
const int B=( x)*(8-y);\
|
||||
const int C=(8-x)*( y);\
|
||||
const int D=( x)*( y);\
|
||||
int i;\
|
||||
stride /= sizeof(pixel);\
|
||||
stride >>= sizeof(pixel)-1;\
|
||||
\
|
||||
assert(x<8 && y<8 && x>=0 && y>=0);\
|
||||
\
|
||||
|
|
@ -800,15 +800,15 @@ static void FUNCC(OPNAME ## h264_chroma_mc2)(uint8_t *_dst/*align 8*/, uint8_t *
|
|||
}\
|
||||
}\
|
||||
\
|
||||
static void FUNCC(OPNAME ## h264_chroma_mc4)(uint8_t *_dst/*align 8*/, uint8_t *_src/*align 1*/, int stride, int h, int x, int y){\
|
||||
pixel *dst = (pixel*)_dst;\
|
||||
pixel *src = (pixel*)_src;\
|
||||
static void FUNCC(OPNAME ## h264_chroma_mc4)(uint8_t *p_dst/*align 8*/, uint8_t *p_src/*align 1*/, int stride, int h, int x, int y){\
|
||||
pixel *dst = (pixel*)p_dst;\
|
||||
pixel *src = (pixel*)p_src;\
|
||||
const int A=(8-x)*(8-y);\
|
||||
const int B=( x)*(8-y);\
|
||||
const int C=(8-x)*( y);\
|
||||
const int D=( x)*( y);\
|
||||
int i;\
|
||||
stride /= sizeof(pixel);\
|
||||
stride >>= sizeof(pixel)-1;\
|
||||
\
|
||||
assert(x<8 && y<8 && x>=0 && y>=0);\
|
||||
\
|
||||
|
|
@ -835,15 +835,15 @@ static void FUNCC(OPNAME ## h264_chroma_mc4)(uint8_t *_dst/*align 8*/, uint8_t *
|
|||
}\
|
||||
}\
|
||||
\
|
||||
static void FUNCC(OPNAME ## h264_chroma_mc8)(uint8_t *_dst/*align 8*/, uint8_t *_src/*align 1*/, int stride, int h, int x, int y){\
|
||||
pixel *dst = (pixel*)_dst;\
|
||||
pixel *src = (pixel*)_src;\
|
||||
static void FUNCC(OPNAME ## h264_chroma_mc8)(uint8_t *p_dst/*align 8*/, uint8_t *p_src/*align 1*/, int stride, int h, int x, int y){\
|
||||
pixel *dst = (pixel*)p_dst;\
|
||||
pixel *src = (pixel*)p_src;\
|
||||
const int A=(8-x)*(8-y);\
|
||||
const int B=( x)*(8-y);\
|
||||
const int C=(8-x)*( y);\
|
||||
const int D=( x)*( y);\
|
||||
int i;\
|
||||
stride /= sizeof(pixel);\
|
||||
stride >>= sizeof(pixel)-1;\
|
||||
\
|
||||
assert(x<8 && y<8 && x>=0 && y>=0);\
|
||||
\
|
||||
|
|
@ -887,14 +887,14 @@ H264_CHROMA_MC(avg_ , op_avg)
|
|||
#undef op_put
|
||||
|
||||
#define H264_LOWPASS(OPNAME, OP, OP2) \
|
||||
static av_unused void FUNC(OPNAME ## h264_qpel2_h_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
|
||||
static av_unused void FUNC(OPNAME ## h264_qpel2_h_lowpass)(uint8_t *p_dst, uint8_t *p_src, int dstStride, int srcStride){\
|
||||
const int h=2;\
|
||||
INIT_CLIP\
|
||||
int i;\
|
||||
pixel *dst = (pixel*)_dst;\
|
||||
pixel *src = (pixel*)_src;\
|
||||
dstStride /= sizeof(pixel);\
|
||||
srcStride /= sizeof(pixel);\
|
||||
pixel *dst = (pixel*)p_dst;\
|
||||
pixel *src = (pixel*)p_src;\
|
||||
dstStride >>= sizeof(pixel)-1;\
|
||||
srcStride >>= sizeof(pixel)-1;\
|
||||
for(i=0; i<h; i++)\
|
||||
{\
|
||||
OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]));\
|
||||
|
|
@ -904,14 +904,14 @@ static av_unused void FUNC(OPNAME ## h264_qpel2_h_lowpass)(uint8_t *_dst, uint8_
|
|||
}\
|
||||
}\
|
||||
\
|
||||
static av_unused void FUNC(OPNAME ## h264_qpel2_v_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
|
||||
static av_unused void FUNC(OPNAME ## h264_qpel2_v_lowpass)(uint8_t *p_dst, uint8_t *p_src, int dstStride, int srcStride){\
|
||||
const int w=2;\
|
||||
INIT_CLIP\
|
||||
int i;\
|
||||
pixel *dst = (pixel*)_dst;\
|
||||
pixel *src = (pixel*)_src;\
|
||||
dstStride /= sizeof(pixel);\
|
||||
srcStride /= sizeof(pixel);\
|
||||
pixel *dst = (pixel*)p_dst;\
|
||||
pixel *src = (pixel*)p_src;\
|
||||
dstStride >>= sizeof(pixel)-1;\
|
||||
srcStride >>= sizeof(pixel)-1;\
|
||||
for(i=0; i<w; i++)\
|
||||
{\
|
||||
const int srcB= src[-2*srcStride];\
|
||||
|
|
@ -928,16 +928,16 @@ static av_unused void FUNC(OPNAME ## h264_qpel2_v_lowpass)(uint8_t *_dst, uint8_
|
|||
}\
|
||||
}\
|
||||
\
|
||||
static av_unused void FUNC(OPNAME ## h264_qpel2_hv_lowpass)(uint8_t *_dst, int16_t *tmp, uint8_t *_src, int dstStride, int tmpStride, int srcStride){\
|
||||
static av_unused void FUNC(OPNAME ## h264_qpel2_hv_lowpass)(uint8_t *p_dst, int16_t *tmp, uint8_t *p_src, int dstStride, int tmpStride, int srcStride){\
|
||||
const int h=2;\
|
||||
const int w=2;\
|
||||
const int pad = (BIT_DEPTH > 9) ? (-10 * ((1<<BIT_DEPTH)-1)) : 0;\
|
||||
INIT_CLIP\
|
||||
int i;\
|
||||
pixel *dst = (pixel*)_dst;\
|
||||
pixel *src = (pixel*)_src;\
|
||||
dstStride /= sizeof(pixel);\
|
||||
srcStride /= sizeof(pixel);\
|
||||
pixel *dst = (pixel*)p_dst;\
|
||||
pixel *src = (pixel*)p_src;\
|
||||
dstStride >>= sizeof(pixel)-1;\
|
||||
srcStride >>= sizeof(pixel)-1;\
|
||||
src -= 2*srcStride;\
|
||||
for(i=0; i<h+5; i++)\
|
||||
{\
|
||||
|
|
@ -962,14 +962,14 @@ static av_unused void FUNC(OPNAME ## h264_qpel2_hv_lowpass)(uint8_t *_dst, int16
|
|||
tmp++;\
|
||||
}\
|
||||
}\
|
||||
static void FUNC(OPNAME ## h264_qpel4_h_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
|
||||
static void FUNC(OPNAME ## h264_qpel4_h_lowpass)(uint8_t *p_dst, uint8_t *p_src, int dstStride, int srcStride){\
|
||||
const int h=4;\
|
||||
INIT_CLIP\
|
||||
int i;\
|
||||
pixel *dst = (pixel*)_dst;\
|
||||
pixel *src = (pixel*)_src;\
|
||||
dstStride /= sizeof(pixel);\
|
||||
srcStride /= sizeof(pixel);\
|
||||
pixel *dst = (pixel*)p_dst;\
|
||||
pixel *src = (pixel*)p_src;\
|
||||
dstStride >>= sizeof(pixel)-1;\
|
||||
srcStride >>= sizeof(pixel)-1;\
|
||||
for(i=0; i<h; i++)\
|
||||
{\
|
||||
OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]));\
|
||||
|
|
@ -981,14 +981,14 @@ static void FUNC(OPNAME ## h264_qpel4_h_lowpass)(uint8_t *_dst, uint8_t *_src, i
|
|||
}\
|
||||
}\
|
||||
\
|
||||
static void FUNC(OPNAME ## h264_qpel4_v_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
|
||||
static void FUNC(OPNAME ## h264_qpel4_v_lowpass)(uint8_t *p_dst, uint8_t *p_src, int dstStride, int srcStride){\
|
||||
const int w=4;\
|
||||
INIT_CLIP\
|
||||
int i;\
|
||||
pixel *dst = (pixel*)_dst;\
|
||||
pixel *src = (pixel*)_src;\
|
||||
dstStride /= sizeof(pixel);\
|
||||
srcStride /= sizeof(pixel);\
|
||||
pixel *dst = (pixel*)p_dst;\
|
||||
pixel *src = (pixel*)p_src;\
|
||||
dstStride >>= sizeof(pixel)-1;\
|
||||
srcStride >>= sizeof(pixel)-1;\
|
||||
for(i=0; i<w; i++)\
|
||||
{\
|
||||
const int srcB= src[-2*srcStride];\
|
||||
|
|
@ -1009,16 +1009,16 @@ static void FUNC(OPNAME ## h264_qpel4_v_lowpass)(uint8_t *_dst, uint8_t *_src, i
|
|||
}\
|
||||
}\
|
||||
\
|
||||
static void FUNC(OPNAME ## h264_qpel4_hv_lowpass)(uint8_t *_dst, int16_t *tmp, uint8_t *_src, int dstStride, int tmpStride, int srcStride){\
|
||||
static void FUNC(OPNAME ## h264_qpel4_hv_lowpass)(uint8_t *p_dst, int16_t *tmp, uint8_t *p_src, int dstStride, int tmpStride, int srcStride){\
|
||||
const int h=4;\
|
||||
const int w=4;\
|
||||
const int pad = (BIT_DEPTH > 9) ? (-10 * ((1<<BIT_DEPTH)-1)) : 0;\
|
||||
INIT_CLIP\
|
||||
int i;\
|
||||
pixel *dst = (pixel*)_dst;\
|
||||
pixel *src = (pixel*)_src;\
|
||||
dstStride /= sizeof(pixel);\
|
||||
srcStride /= sizeof(pixel);\
|
||||
pixel *dst = (pixel*)p_dst;\
|
||||
pixel *src = (pixel*)p_src;\
|
||||
dstStride >>= sizeof(pixel)-1;\
|
||||
srcStride >>= sizeof(pixel)-1;\
|
||||
src -= 2*srcStride;\
|
||||
for(i=0; i<h+5; i++)\
|
||||
{\
|
||||
|
|
@ -1050,14 +1050,14 @@ static void FUNC(OPNAME ## h264_qpel4_hv_lowpass)(uint8_t *_dst, int16_t *tmp, u
|
|||
}\
|
||||
}\
|
||||
\
|
||||
static void FUNC(OPNAME ## h264_qpel8_h_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
|
||||
static void FUNC(OPNAME ## h264_qpel8_h_lowpass)(uint8_t *p_dst, uint8_t *p_src, int dstStride, int srcStride){\
|
||||
const int h=8;\
|
||||
INIT_CLIP\
|
||||
int i;\
|
||||
pixel *dst = (pixel*)_dst;\
|
||||
pixel *src = (pixel*)_src;\
|
||||
dstStride /= sizeof(pixel);\
|
||||
srcStride /= sizeof(pixel);\
|
||||
pixel *dst = (pixel*)p_dst;\
|
||||
pixel *src = (pixel*)p_src;\
|
||||
dstStride >>= sizeof(pixel)-1;\
|
||||
srcStride >>= sizeof(pixel)-1;\
|
||||
for(i=0; i<h; i++)\
|
||||
{\
|
||||
OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ]));\
|
||||
|
|
@ -1073,14 +1073,14 @@ static void FUNC(OPNAME ## h264_qpel8_h_lowpass)(uint8_t *_dst, uint8_t *_src, i
|
|||
}\
|
||||
}\
|
||||
\
|
||||
static void FUNC(OPNAME ## h264_qpel8_v_lowpass)(uint8_t *_dst, uint8_t *_src, int dstStride, int srcStride){\
|
||||
static void FUNC(OPNAME ## h264_qpel8_v_lowpass)(uint8_t *p_dst, uint8_t *p_src, int dstStride, int srcStride){\
|
||||
const int w=8;\
|
||||
INIT_CLIP\
|
||||
int i;\
|
||||
pixel *dst = (pixel*)_dst;\
|
||||
pixel *src = (pixel*)_src;\
|
||||
dstStride /= sizeof(pixel);\
|
||||
srcStride /= sizeof(pixel);\
|
||||
pixel *dst = (pixel*)p_dst;\
|
||||
pixel *src = (pixel*)p_src;\
|
||||
dstStride >>= sizeof(pixel)-1;\
|
||||
srcStride >>= sizeof(pixel)-1;\
|
||||
for(i=0; i<w; i++)\
|
||||
{\
|
||||
const int srcB= src[-2*srcStride];\
|
||||
|
|
@ -1109,16 +1109,16 @@ static void FUNC(OPNAME ## h264_qpel8_v_lowpass)(uint8_t *_dst, uint8_t *_src, i
|
|||
}\
|
||||
}\
|
||||
\
|
||||
static void FUNC(OPNAME ## h264_qpel8_hv_lowpass)(uint8_t *_dst, int16_t *tmp, uint8_t *_src, int dstStride, int tmpStride, int srcStride){\
|
||||
static void FUNC(OPNAME ## h264_qpel8_hv_lowpass)(uint8_t *p_dst, int16_t *tmp, uint8_t *p_src, int dstStride, int tmpStride, int srcStride){\
|
||||
const int h=8;\
|
||||
const int w=8;\
|
||||
const int pad = (BIT_DEPTH > 9) ? (-10 * ((1<<BIT_DEPTH)-1)) : 0;\
|
||||
INIT_CLIP\
|
||||
int i;\
|
||||
pixel *dst = (pixel*)_dst;\
|
||||
pixel *src = (pixel*)_src;\
|
||||
dstStride /= sizeof(pixel);\
|
||||
srcStride /= sizeof(pixel);\
|
||||
pixel *dst = (pixel*)p_dst;\
|
||||
pixel *src = (pixel*)p_src;\
|
||||
dstStride >>= sizeof(pixel)-1;\
|
||||
srcStride >>= sizeof(pixel)-1;\
|
||||
src -= 2*srcStride;\
|
||||
for(i=0; i<h+5; i++)\
|
||||
{\
|
||||
|
|
@ -1389,3 +1389,4 @@ static void FUNCC(clear_blocks)(DCTELEM *blocks)
|
|||
{
|
||||
memset(blocks, 0, sizeof(dctcoef)*6*64);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,86 +0,0 @@
|
|||
#include "dsputil.h"
|
||||
|
||||
#ifndef BIT_DEPTH
|
||||
#define BIT_DEPTH 8
|
||||
#endif
|
||||
|
||||
#ifdef AVCODEC_H264_HIGH_DEPTH_H
|
||||
# undef pixel
|
||||
# undef pixel2
|
||||
# undef pixel4
|
||||
# undef dctcoef
|
||||
# undef INIT_CLIP
|
||||
# undef no_rnd_avg_pixel4
|
||||
# undef rnd_avg_pixel4
|
||||
# undef AV_RN2P
|
||||
# undef AV_RN4P
|
||||
# undef AV_WN2P
|
||||
# undef AV_WN4P
|
||||
# undef AV_WN4PA
|
||||
# undef CLIP
|
||||
# undef FUNC
|
||||
# undef FUNCC
|
||||
# undef av_clip_pixel
|
||||
# undef PIXEL_SPLAT_X4
|
||||
#else
|
||||
# define AVCODEC_H264_HIGH_DEPTH_H
|
||||
# define CLIP_PIXEL(depth)\
|
||||
static inline uint16_t av_clip_pixel_ ## depth (int p)\
|
||||
{\
|
||||
const int pixel_max = (1 << depth)-1;\
|
||||
return (p & ~pixel_max) ? (-p)>>31 & pixel_max : p;\
|
||||
}
|
||||
|
||||
CLIP_PIXEL( 9)
|
||||
CLIP_PIXEL(10)
|
||||
#endif
|
||||
|
||||
#if BIT_DEPTH > 8
|
||||
# define pixel uint16_t
|
||||
# define pixel2 uint32_t
|
||||
# define pixel4 uint64_t
|
||||
# define dctcoef int32_t
|
||||
|
||||
# define INIT_CLIP
|
||||
# define no_rnd_avg_pixel4 no_rnd_avg64
|
||||
# define rnd_avg_pixel4 rnd_avg64
|
||||
# define AV_RN2P AV_RN32
|
||||
# define AV_RN4P AV_RN64
|
||||
# define AV_WN2P AV_WN32
|
||||
# define AV_WN4P AV_WN64
|
||||
# define AV_WN4PA AV_WN64A
|
||||
# define PIXEL_SPLAT_X4(x) ((x)*0x0001000100010001ULL)
|
||||
#else
|
||||
# define pixel uint8_t
|
||||
# define pixel2 uint16_t
|
||||
# define pixel4 uint32_t
|
||||
# define dctcoef int16_t
|
||||
|
||||
# define INIT_CLIP uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
|
||||
# define no_rnd_avg_pixel4 no_rnd_avg32
|
||||
# define rnd_avg_pixel4 rnd_avg32
|
||||
# define AV_RN2P AV_RN16
|
||||
# define AV_RN4P AV_RN32
|
||||
# define AV_WN2P AV_WN16
|
||||
# define AV_WN4P AV_WN32
|
||||
# define AV_WN4PA AV_WN32A
|
||||
# define PIXEL_SPLAT_X4(x) ((x)*0x01010101U)
|
||||
#endif
|
||||
|
||||
#if BIT_DEPTH == 8
|
||||
# define av_clip_pixel(a) av_clip_uint8(a)
|
||||
# define CLIP(a) cm[a]
|
||||
# define FUNC(a) a ## _8
|
||||
# define FUNCC(a) a ## _8_c
|
||||
#elif BIT_DEPTH == 9
|
||||
# define av_clip_pixel(a) av_clip_pixel_9(a)
|
||||
# define CLIP(a) av_clip_pixel_9(a)
|
||||
# define FUNC(a) a ## _9
|
||||
# define FUNCC(a) a ## _9_c
|
||||
#elif BIT_DEPTH == 10
|
||||
# define av_clip_pixel(a) av_clip_pixel_10(a)
|
||||
# define CLIP(a) av_clip_pixel_10(a)
|
||||
# define FUNC(a) a ## _10
|
||||
# define FUNCC(a) a ## _10_c
|
||||
#endif
|
||||
|
||||
|
|
@ -1,288 +0,0 @@
|
|||
/*
|
||||
* H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
|
||||
* Copyright (c) 2003-2011 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
|
||||
* H.264 / AVC / MPEG4 part10 DSP functions.
|
||||
* @author Michael Niedermayer <michaelni@gmx.at>
|
||||
*/
|
||||
|
||||
#include "h264_high_depth.h"
|
||||
|
||||
#define op_scale1(x) block[x] = av_clip_pixel( (block[x]*weight + offset) >> log2_denom )
|
||||
#define op_scale2(x) dst[x] = av_clip_pixel( (src[x]*weights + dst[x]*weightd + offset) >> (log2_denom+1))
|
||||
#define H264_WEIGHT(W,H) \
|
||||
static void FUNCC(weight_h264_pixels ## W ## x ## H)(uint8_t *p_block, int stride, int log2_denom, int weight, int offset){ \
|
||||
int y; \
|
||||
pixel *block = (pixel*)p_block; \
|
||||
stride >>= sizeof(pixel)-1; \
|
||||
offset <<= (log2_denom + (BIT_DEPTH-8)); \
|
||||
if(log2_denom) offset += 1<<(log2_denom-1); \
|
||||
for(y=0; y<H; y++, block += stride){ \
|
||||
op_scale1(0); \
|
||||
op_scale1(1); \
|
||||
if(W==2) continue; \
|
||||
op_scale1(2); \
|
||||
op_scale1(3); \
|
||||
if(W==4) continue; \
|
||||
op_scale1(4); \
|
||||
op_scale1(5); \
|
||||
op_scale1(6); \
|
||||
op_scale1(7); \
|
||||
if(W==8) continue; \
|
||||
op_scale1(8); \
|
||||
op_scale1(9); \
|
||||
op_scale1(10); \
|
||||
op_scale1(11); \
|
||||
op_scale1(12); \
|
||||
op_scale1(13); \
|
||||
op_scale1(14); \
|
||||
op_scale1(15); \
|
||||
} \
|
||||
} \
|
||||
static void FUNCC(biweight_h264_pixels ## W ## x ## H)(uint8_t *p_dst, uint8_t *p_src, int stride, int log2_denom, int weightd, int weights, int offset){ \
|
||||
int y; \
|
||||
pixel *dst = (pixel*)p_dst; \
|
||||
pixel *src = (pixel*)p_src; \
|
||||
stride >>= sizeof(pixel)-1; \
|
||||
offset = ((offset + 1) | 1) << log2_denom; \
|
||||
for(y=0; y<H; y++, dst += stride, src += stride){ \
|
||||
op_scale2(0); \
|
||||
op_scale2(1); \
|
||||
if(W==2) continue; \
|
||||
op_scale2(2); \
|
||||
op_scale2(3); \
|
||||
if(W==4) continue; \
|
||||
op_scale2(4); \
|
||||
op_scale2(5); \
|
||||
op_scale2(6); \
|
||||
op_scale2(7); \
|
||||
if(W==8) continue; \
|
||||
op_scale2(8); \
|
||||
op_scale2(9); \
|
||||
op_scale2(10); \
|
||||
op_scale2(11); \
|
||||
op_scale2(12); \
|
||||
op_scale2(13); \
|
||||
op_scale2(14); \
|
||||
op_scale2(15); \
|
||||
} \
|
||||
}
|
||||
|
||||
H264_WEIGHT(16,16)
|
||||
H264_WEIGHT(16,8)
|
||||
H264_WEIGHT(8,16)
|
||||
H264_WEIGHT(8,8)
|
||||
H264_WEIGHT(8,4)
|
||||
H264_WEIGHT(4,8)
|
||||
H264_WEIGHT(4,4)
|
||||
H264_WEIGHT(4,2)
|
||||
H264_WEIGHT(2,4)
|
||||
H264_WEIGHT(2,2)
|
||||
|
||||
#undef op_scale1
|
||||
#undef op_scale2
|
||||
#undef H264_WEIGHT
|
||||
|
||||
static av_always_inline av_flatten void FUNCC(h264_loop_filter_luma)(uint8_t *p_pix, int xstride, int ystride, int alpha, int beta, int8_t *tc0)
|
||||
{
|
||||
pixel *pix = (pixel*)p_pix;
|
||||
int i, d;
|
||||
xstride >>= sizeof(pixel)-1;
|
||||
ystride >>= sizeof(pixel)-1;
|
||||
for( i = 0; i < 4; i++ ) {
|
||||
if( tc0[i] < 0 ) {
|
||||
pix += 4*ystride;
|
||||
continue;
|
||||
}
|
||||
for( d = 0; d < 4; d++ ) {
|
||||
const int p0 = pix[-1*xstride];
|
||||
const int p1 = pix[-2*xstride];
|
||||
const int p2 = pix[-3*xstride];
|
||||
const int q0 = pix[0];
|
||||
const int q1 = pix[1*xstride];
|
||||
const int q2 = pix[2*xstride];
|
||||
|
||||
if( FFABS( p0 - q0 ) < alpha &&
|
||||
FFABS( p1 - p0 ) < beta &&
|
||||
FFABS( q1 - q0 ) < beta ) {
|
||||
|
||||
int tc = tc0[i];
|
||||
int i_delta;
|
||||
|
||||
if( FFABS( p2 - p0 ) < beta ) {
|
||||
if(tc0[i])
|
||||
pix[-2*xstride] = p1 + av_clip( (( p2 + ( ( p0 + q0 + 1 ) >> 1 ) ) >> 1) - p1, -tc0[i], tc0[i] );
|
||||
tc++;
|
||||
}
|
||||
if( FFABS( q2 - q0 ) < beta ) {
|
||||
if(tc0[i])
|
||||
pix[ xstride] = q1 + av_clip( (( q2 + ( ( p0 + q0 + 1 ) >> 1 ) ) >> 1) - q1, -tc0[i], tc0[i] );
|
||||
tc++;
|
||||
}
|
||||
|
||||
i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
|
||||
pix[-xstride] = av_clip_pixel( p0 + i_delta ); /* p0' */
|
||||
pix[0] = av_clip_pixel( q0 - i_delta ); /* q0' */
|
||||
}
|
||||
pix += ystride;
|
||||
}
|
||||
}
|
||||
}
|
||||
static void FUNCC(h264_v_loop_filter_luma)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
|
||||
{
|
||||
FUNCC(h264_loop_filter_luma)(pix, stride, sizeof(pixel), alpha, beta, tc0);
|
||||
}
|
||||
static void FUNCC(h264_h_loop_filter_luma)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
|
||||
{
|
||||
FUNCC(h264_loop_filter_luma)(pix, sizeof(pixel), stride, alpha, beta, tc0);
|
||||
}
|
||||
|
||||
static av_always_inline av_flatten void FUNCC(h264_loop_filter_luma_intra)(uint8_t *p_pix, int xstride, int ystride, int alpha, int beta)
|
||||
{
|
||||
pixel *pix = (pixel*)p_pix;
|
||||
int d;
|
||||
xstride >>= sizeof(pixel)-1;
|
||||
ystride >>= sizeof(pixel)-1;
|
||||
for( d = 0; d < 16; d++ ) {
|
||||
const int p2 = pix[-3*xstride];
|
||||
const int p1 = pix[-2*xstride];
|
||||
const int p0 = pix[-1*xstride];
|
||||
|
||||
const int q0 = pix[ 0*xstride];
|
||||
const int q1 = pix[ 1*xstride];
|
||||
const int q2 = pix[ 2*xstride];
|
||||
|
||||
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*xstride];
|
||||
/* p0', p1', p2' */
|
||||
pix[-1*xstride] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
|
||||
pix[-2*xstride] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
|
||||
pix[-3*xstride] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
|
||||
} else {
|
||||
/* p0' */
|
||||
pix[-1*xstride] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
|
||||
}
|
||||
if( FFABS( q2 - q0 ) < beta)
|
||||
{
|
||||
const int q3 = pix[3*xstride];
|
||||
/* q0', q1', q2' */
|
||||
pix[0*xstride] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
|
||||
pix[1*xstride] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
|
||||
pix[2*xstride] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
|
||||
} else {
|
||||
/* q0' */
|
||||
pix[0*xstride] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
|
||||
}
|
||||
}else{
|
||||
/* p0', q0' */
|
||||
pix[-1*xstride] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
|
||||
pix[ 0*xstride] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
|
||||
}
|
||||
}
|
||||
pix += ystride;
|
||||
}
|
||||
}
|
||||
static void FUNCC(h264_v_loop_filter_luma_intra)(uint8_t *pix, int stride, int alpha, int beta)
|
||||
{
|
||||
FUNCC(h264_loop_filter_luma_intra)(pix, stride, sizeof(pixel), alpha, beta);
|
||||
}
|
||||
static void FUNCC(h264_h_loop_filter_luma_intra)(uint8_t *pix, int stride, int alpha, int beta)
|
||||
{
|
||||
FUNCC(h264_loop_filter_luma_intra)(pix, sizeof(pixel), stride, alpha, beta);
|
||||
}
|
||||
|
||||
static av_always_inline av_flatten void FUNCC(h264_loop_filter_chroma)(uint8_t *p_pix, int xstride, int ystride, int alpha, int beta, int8_t *tc0)
|
||||
{
|
||||
pixel *pix = (pixel*)p_pix;
|
||||
int i, d;
|
||||
xstride >>= sizeof(pixel)-1;
|
||||
ystride >>= sizeof(pixel)-1;
|
||||
for( i = 0; i < 4; i++ ) {
|
||||
const int tc = tc0[i];
|
||||
if( tc <= 0 ) {
|
||||
pix += 2*ystride;
|
||||
continue;
|
||||
}
|
||||
for( d = 0; d < 2; d++ ) {
|
||||
const int p0 = pix[-1*xstride];
|
||||
const int p1 = pix[-2*xstride];
|
||||
const int q0 = pix[0];
|
||||
const int q1 = pix[1*xstride];
|
||||
|
||||
if( FFABS( p0 - q0 ) < alpha &&
|
||||
FFABS( p1 - p0 ) < beta &&
|
||||
FFABS( q1 - q0 ) < beta ) {
|
||||
|
||||
int delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
|
||||
|
||||
pix[-xstride] = av_clip_pixel( p0 + delta ); /* p0' */
|
||||
pix[0] = av_clip_pixel( q0 - delta ); /* q0' */
|
||||
}
|
||||
pix += ystride;
|
||||
}
|
||||
}
|
||||
}
|
||||
static void FUNCC(h264_v_loop_filter_chroma)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
|
||||
{
|
||||
FUNCC(h264_loop_filter_chroma)(pix, stride, sizeof(pixel), alpha, beta, tc0);
|
||||
}
|
||||
static void FUNCC(h264_h_loop_filter_chroma)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
|
||||
{
|
||||
FUNCC(h264_loop_filter_chroma)(pix, sizeof(pixel), stride, alpha, beta, tc0);
|
||||
}
|
||||
|
||||
static av_always_inline av_flatten void FUNCC(h264_loop_filter_chroma_intra)(uint8_t *p_pix, int xstride, int ystride, int alpha, int beta)
|
||||
{
|
||||
pixel *pix = (pixel*)p_pix;
|
||||
int d;
|
||||
xstride >>= sizeof(pixel)-1;
|
||||
ystride >>= sizeof(pixel)-1;
|
||||
for( d = 0; d < 8; d++ ) {
|
||||
const int p0 = pix[-1*xstride];
|
||||
const int p1 = pix[-2*xstride];
|
||||
const int q0 = pix[0];
|
||||
const int q1 = pix[1*xstride];
|
||||
|
||||
if( FFABS( p0 - q0 ) < alpha &&
|
||||
FFABS( p1 - p0 ) < beta &&
|
||||
FFABS( q1 - q0 ) < beta ) {
|
||||
|
||||
pix[-xstride] = ( 2*p1 + p0 + q1 + 2 ) >> 2; /* p0' */
|
||||
pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2; /* q0' */
|
||||
}
|
||||
pix += ystride;
|
||||
}
|
||||
}
|
||||
static void FUNCC(h264_v_loop_filter_chroma_intra)(uint8_t *pix, int stride, int alpha, int beta)
|
||||
{
|
||||
FUNCC(h264_loop_filter_chroma_intra)(pix, stride, sizeof(pixel), alpha, beta);
|
||||
}
|
||||
static void FUNCC(h264_h_loop_filter_chroma_intra)(uint8_t *pix, int stride, int alpha, int beta)
|
||||
{
|
||||
FUNCC(h264_loop_filter_chroma_intra)(pix, sizeof(pixel), stride, alpha, beta);
|
||||
}
|
||||
|
|
@ -1,21 +1,21 @@
|
|||
/*
|
||||
* H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
|
||||
* Copyright (c) 2003-2010 Michael Niedermayer <michaelni@gmx.at>
|
||||
* Copyright (c) 2003-2011 Michael Niedermayer <michaelni@gmx.at>
|
||||
*
|
||||
* This file is part of Libav.
|
||||
* This file is part of FFmpeg.
|
||||
*
|
||||
* Libav is free software; you can redistribute it and/or
|
||||
* 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.
|
||||
*
|
||||
* Libav is distributed in the hope that it will be useful,
|
||||
* 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 Libav; if not, write to the Free Software
|
||||
* License along with FFmpeg; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
|
|
@ -30,10 +30,10 @@
|
|||
#define op_scale1(x) block[x] = av_clip_pixel( (block[x]*weight + offset) >> log2_denom )
|
||||
#define op_scale2(x) dst[x] = av_clip_pixel( (src[x]*weights + dst[x]*weightd + offset) >> (log2_denom+1))
|
||||
#define H264_WEIGHT(W,H) \
|
||||
static void FUNCC(weight_h264_pixels ## W ## x ## H)(uint8_t *_block, int stride, int log2_denom, int weight, int offset){ \
|
||||
static void FUNCC(weight_h264_pixels ## W ## x ## H)(uint8_t *p_block, int stride, int log2_denom, int weight, int offset){ \
|
||||
int y; \
|
||||
pixel *block = (pixel*)_block; \
|
||||
stride /= sizeof(pixel); \
|
||||
pixel *block = (pixel*)p_block; \
|
||||
stride >>= sizeof(pixel)-1; \
|
||||
offset <<= (log2_denom + (BIT_DEPTH-8)); \
|
||||
if(log2_denom) offset += 1<<(log2_denom-1); \
|
||||
for(y=0; y<H; y++, block += stride){ \
|
||||
|
|
@ -58,11 +58,11 @@ static void FUNCC(weight_h264_pixels ## W ## x ## H)(uint8_t *_block, int stride
|
|||
op_scale1(15); \
|
||||
} \
|
||||
} \
|
||||
static void FUNCC(biweight_h264_pixels ## W ## x ## H)(uint8_t *_dst, uint8_t *_src, int stride, int log2_denom, int weightd, int weights, int offset){ \
|
||||
static void FUNCC(biweight_h264_pixels ## W ## x ## H)(uint8_t *p_dst, uint8_t *p_src, int stride, int log2_denom, int weightd, int weights, int offset){ \
|
||||
int y; \
|
||||
pixel *dst = (pixel*)_dst; \
|
||||
pixel *src = (pixel*)_src; \
|
||||
stride /= sizeof(pixel); \
|
||||
pixel *dst = (pixel*)p_dst; \
|
||||
pixel *src = (pixel*)p_src; \
|
||||
stride >>= sizeof(pixel)-1; \
|
||||
offset = ((offset + 1) | 1) << log2_denom; \
|
||||
for(y=0; y<H; y++, dst += stride, src += stride){ \
|
||||
op_scale2(0); \
|
||||
|
|
@ -102,12 +102,12 @@ H264_WEIGHT(2,2)
|
|||
#undef op_scale2
|
||||
#undef H264_WEIGHT
|
||||
|
||||
static av_always_inline av_flatten void FUNCC(h264_loop_filter_luma)(uint8_t *_pix, int xstride, int ystride, int inner_iters, int alpha, int beta, int8_t *tc0)
|
||||
static av_always_inline av_flatten void FUNCC(h264_loop_filter_luma)(uint8_t *p_pix, int xstride, int ystride, int inner_iters, int alpha, int beta, int8_t *tc0)
|
||||
{
|
||||
pixel *pix = (pixel*)_pix;
|
||||
pixel *pix = (pixel*)p_pix;
|
||||
int i, d;
|
||||
xstride /= sizeof(pixel);
|
||||
ystride /= sizeof(pixel);
|
||||
xstride >>= sizeof(pixel)-1;
|
||||
ystride >>= sizeof(pixel)-1;
|
||||
alpha <<= BIT_DEPTH - 8;
|
||||
beta <<= BIT_DEPTH - 8;
|
||||
for( i = 0; i < 4; i++ ) {
|
||||
|
|
@ -163,12 +163,12 @@ static void FUNCC(h264_h_loop_filter_luma_mbaff)(uint8_t *pix, int stride, int a
|
|||
FUNCC(h264_loop_filter_luma)(pix, sizeof(pixel), stride, 2, alpha, beta, tc0);
|
||||
}
|
||||
|
||||
static av_always_inline av_flatten void FUNCC(h264_loop_filter_luma_intra)(uint8_t *_pix, int xstride, int ystride, int inner_iters, int alpha, int beta)
|
||||
static av_always_inline av_flatten void FUNCC(h264_loop_filter_luma_intra)(uint8_t *p_pix, int xstride, int ystride, int inner_iters, int alpha, int beta)
|
||||
{
|
||||
pixel *pix = (pixel*)_pix;
|
||||
pixel *pix = (pixel*)p_pix;
|
||||
int d;
|
||||
xstride /= sizeof(pixel);
|
||||
ystride /= sizeof(pixel);
|
||||
xstride >>= sizeof(pixel)-1;
|
||||
ystride >>= sizeof(pixel)-1;
|
||||
alpha <<= BIT_DEPTH - 8;
|
||||
beta <<= BIT_DEPTH - 8;
|
||||
for( d = 0; d < 4 * inner_iters; d++ ) {
|
||||
|
|
@ -229,14 +229,14 @@ static void FUNCC(h264_h_loop_filter_luma_mbaff_intra)(uint8_t *pix, int stride,
|
|||
FUNCC(h264_loop_filter_luma_intra)(pix, sizeof(pixel), stride, 2, alpha, beta);
|
||||
}
|
||||
|
||||
static av_always_inline av_flatten void FUNCC(h264_loop_filter_chroma)(uint8_t *_pix, int xstride, int ystride, int inner_iters, int alpha, int beta, int8_t *tc0)
|
||||
static av_always_inline av_flatten void FUNCC(h264_loop_filter_chroma)(uint8_t *p_pix, int xstride, int ystride, int inner_iters, int alpha, int beta, int8_t *tc0)
|
||||
{
|
||||
pixel *pix = (pixel*)_pix;
|
||||
pixel *pix = (pixel*)p_pix;
|
||||
int i, d;
|
||||
xstride /= sizeof(pixel);
|
||||
ystride /= sizeof(pixel);
|
||||
alpha <<= BIT_DEPTH - 8;
|
||||
beta <<= BIT_DEPTH - 8;
|
||||
xstride >>= sizeof(pixel)-1;
|
||||
ystride >>= sizeof(pixel)-1;
|
||||
for( i = 0; i < 4; i++ ) {
|
||||
const int tc = ((tc0[i] - 1) << (BIT_DEPTH - 8)) + 1;
|
||||
if( tc <= 0 ) {
|
||||
|
|
@ -275,12 +275,12 @@ static void FUNCC(h264_h_loop_filter_chroma_mbaff)(uint8_t *pix, int stride, int
|
|||
FUNCC(h264_loop_filter_chroma)(pix, sizeof(pixel), stride, 1, alpha, beta, tc0);
|
||||
}
|
||||
|
||||
static av_always_inline av_flatten void FUNCC(h264_loop_filter_chroma_intra)(uint8_t *_pix, int xstride, int ystride, int inner_iters, int alpha, int beta)
|
||||
static av_always_inline av_flatten void FUNCC(h264_loop_filter_chroma_intra)(uint8_t *p_pix, int xstride, int ystride, int inner_iters, int alpha, int beta)
|
||||
{
|
||||
pixel *pix = (pixel*)_pix;
|
||||
pixel *pix = (pixel*)p_pix;
|
||||
int d;
|
||||
xstride /= sizeof(pixel);
|
||||
ystride /= sizeof(pixel);
|
||||
xstride >>= sizeof(pixel)-1;
|
||||
ystride >>= sizeof(pixel)-1;
|
||||
alpha <<= BIT_DEPTH - 8;
|
||||
beta <<= BIT_DEPTH - 8;
|
||||
for( d = 0; d < 4 * inner_iters; d++ ) {
|
||||
|
|
|
|||
|
|
@ -1,291 +0,0 @@
|
|||
/*
|
||||
* H.264 IDCT
|
||||
* Copyright (c) 2004-2011 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
|
||||
* H.264 IDCT.
|
||||
* @author Michael Niedermayer <michaelni@gmx.at>
|
||||
*/
|
||||
|
||||
#include "h264_high_depth.h"
|
||||
|
||||
#ifndef AVCODEC_H264IDCT_INTERNAL_H
|
||||
#define AVCODEC_H264IDCT_INTERNAL_H
|
||||
//FIXME this table is a duplicate from h264data.h, and will be removed once the tables from, h264 have been split
|
||||
static const uint8_t scan8[16 + 2*4]={
|
||||
4+1*8, 5+1*8, 4+2*8, 5+2*8,
|
||||
6+1*8, 7+1*8, 6+2*8, 7+2*8,
|
||||
4+3*8, 5+3*8, 4+4*8, 5+4*8,
|
||||
6+3*8, 7+3*8, 6+4*8, 7+4*8,
|
||||
1+1*8, 2+1*8,
|
||||
1+2*8, 2+2*8,
|
||||
1+4*8, 2+4*8,
|
||||
1+5*8, 2+5*8,
|
||||
};
|
||||
#endif
|
||||
|
||||
static av_always_inline void FUNCC(idct_internal)(uint8_t *p_dst, DCTELEM *p_block, int stride, int block_stride, int shift, int add){
|
||||
int i;
|
||||
INIT_CLIP
|
||||
pixel *dst = (pixel*)p_dst;
|
||||
dctcoef *block = (dctcoef*)p_block;
|
||||
stride >>= sizeof(pixel)-1;
|
||||
|
||||
block[0] += 1<<(shift-1);
|
||||
|
||||
for(i=0; i<4; i++){
|
||||
const int z0= block[i + block_stride*0] + block[i + block_stride*2];
|
||||
const int z1= block[i + block_stride*0] - block[i + block_stride*2];
|
||||
const int z2= (block[i + block_stride*1]>>1) - block[i + block_stride*3];
|
||||
const int z3= block[i + block_stride*1] + (block[i + block_stride*3]>>1);
|
||||
|
||||
block[i + block_stride*0]= z0 + z3;
|
||||
block[i + block_stride*1]= z1 + z2;
|
||||
block[i + block_stride*2]= z1 - z2;
|
||||
block[i + block_stride*3]= z0 - z3;
|
||||
}
|
||||
|
||||
for(i=0; i<4; i++){
|
||||
const int z0= block[0 + block_stride*i] + block[2 + block_stride*i];
|
||||
const int z1= block[0 + block_stride*i] - block[2 + block_stride*i];
|
||||
const int z2= (block[1 + block_stride*i]>>1) - block[3 + block_stride*i];
|
||||
const int z3= block[1 + block_stride*i] + (block[3 + block_stride*i]>>1);
|
||||
|
||||
dst[i + 0*stride]= CLIP(add*dst[i + 0*stride] + ((z0 + z3) >> shift));
|
||||
dst[i + 1*stride]= CLIP(add*dst[i + 1*stride] + ((z1 + z2) >> shift));
|
||||
dst[i + 2*stride]= CLIP(add*dst[i + 2*stride] + ((z1 - z2) >> shift));
|
||||
dst[i + 3*stride]= CLIP(add*dst[i + 3*stride] + ((z0 - z3) >> shift));
|
||||
}
|
||||
}
|
||||
|
||||
void FUNCC(ff_h264_idct_add)(uint8_t *dst, DCTELEM *block, int stride){
|
||||
FUNCC(idct_internal)(dst, block, stride, 4, 6, 1);
|
||||
}
|
||||
|
||||
void FUNCC(ff_h264_lowres_idct_add)(uint8_t *dst, int stride, DCTELEM *block){
|
||||
FUNCC(idct_internal)(dst, block, stride, 8, 3, 1);
|
||||
}
|
||||
|
||||
void FUNCC(ff_h264_lowres_idct_put)(uint8_t *dst, int stride, DCTELEM *block){
|
||||
FUNCC(idct_internal)(dst, block, stride, 8, 3, 0);
|
||||
}
|
||||
|
||||
void FUNCC(ff_h264_idct8_add)(uint8_t *p_dst, DCTELEM *p_block, int stride){
|
||||
int i;
|
||||
INIT_CLIP
|
||||
pixel *dst = (pixel*)p_dst;
|
||||
dctcoef *block = (dctcoef*)p_block;
|
||||
stride >>= sizeof(pixel)-1;
|
||||
|
||||
block[0] += 32;
|
||||
|
||||
for( i = 0; i < 8; i++ )
|
||||
{
|
||||
const int a0 = block[i+0*8] + block[i+4*8];
|
||||
const int a2 = block[i+0*8] - block[i+4*8];
|
||||
const int a4 = (block[i+2*8]>>1) - block[i+6*8];
|
||||
const int a6 = (block[i+6*8]>>1) + block[i+2*8];
|
||||
|
||||
const int b0 = a0 + a6;
|
||||
const int b2 = a2 + a4;
|
||||
const int b4 = a2 - a4;
|
||||
const int b6 = a0 - a6;
|
||||
|
||||
const int a1 = -block[i+3*8] + block[i+5*8] - block[i+7*8] - (block[i+7*8]>>1);
|
||||
const int a3 = block[i+1*8] + block[i+7*8] - block[i+3*8] - (block[i+3*8]>>1);
|
||||
const int a5 = -block[i+1*8] + block[i+7*8] + block[i+5*8] + (block[i+5*8]>>1);
|
||||
const int a7 = block[i+3*8] + block[i+5*8] + block[i+1*8] + (block[i+1*8]>>1);
|
||||
|
||||
const int b1 = (a7>>2) + a1;
|
||||
const int b3 = a3 + (a5>>2);
|
||||
const int b5 = (a3>>2) - a5;
|
||||
const int b7 = a7 - (a1>>2);
|
||||
|
||||
block[i+0*8] = b0 + b7;
|
||||
block[i+7*8] = b0 - b7;
|
||||
block[i+1*8] = b2 + b5;
|
||||
block[i+6*8] = b2 - b5;
|
||||
block[i+2*8] = b4 + b3;
|
||||
block[i+5*8] = b4 - b3;
|
||||
block[i+3*8] = b6 + b1;
|
||||
block[i+4*8] = b6 - b1;
|
||||
}
|
||||
for( i = 0; i < 8; i++ )
|
||||
{
|
||||
const int a0 = block[0+i*8] + block[4+i*8];
|
||||
const int a2 = block[0+i*8] - block[4+i*8];
|
||||
const int a4 = (block[2+i*8]>>1) - block[6+i*8];
|
||||
const int a6 = (block[6+i*8]>>1) + block[2+i*8];
|
||||
|
||||
const int b0 = a0 + a6;
|
||||
const int b2 = a2 + a4;
|
||||
const int b4 = a2 - a4;
|
||||
const int b6 = a0 - a6;
|
||||
|
||||
const int a1 = -block[3+i*8] + block[5+i*8] - block[7+i*8] - (block[7+i*8]>>1);
|
||||
const int a3 = block[1+i*8] + block[7+i*8] - block[3+i*8] - (block[3+i*8]>>1);
|
||||
const int a5 = -block[1+i*8] + block[7+i*8] + block[5+i*8] + (block[5+i*8]>>1);
|
||||
const int a7 = block[3+i*8] + block[5+i*8] + block[1+i*8] + (block[1+i*8]>>1);
|
||||
|
||||
const int b1 = (a7>>2) + a1;
|
||||
const int b3 = a3 + (a5>>2);
|
||||
const int b5 = (a3>>2) - a5;
|
||||
const int b7 = a7 - (a1>>2);
|
||||
|
||||
dst[i + 0*stride] = CLIP( dst[i + 0*stride] + ((b0 + b7) >> 6) );
|
||||
dst[i + 1*stride] = CLIP( dst[i + 1*stride] + ((b2 + b5) >> 6) );
|
||||
dst[i + 2*stride] = CLIP( dst[i + 2*stride] + ((b4 + b3) >> 6) );
|
||||
dst[i + 3*stride] = CLIP( dst[i + 3*stride] + ((b6 + b1) >> 6) );
|
||||
dst[i + 4*stride] = CLIP( dst[i + 4*stride] + ((b6 - b1) >> 6) );
|
||||
dst[i + 5*stride] = CLIP( dst[i + 5*stride] + ((b4 - b3) >> 6) );
|
||||
dst[i + 6*stride] = CLIP( dst[i + 6*stride] + ((b2 - b5) >> 6) );
|
||||
dst[i + 7*stride] = CLIP( dst[i + 7*stride] + ((b0 - b7) >> 6) );
|
||||
}
|
||||
}
|
||||
|
||||
// assumes all AC coefs are 0
|
||||
void FUNCC(ff_h264_idct_dc_add)(uint8_t *p_dst, DCTELEM *block, int stride){
|
||||
int i, j;
|
||||
int dc = (((dctcoef*)block)[0] + 32) >> 6;
|
||||
INIT_CLIP
|
||||
pixel *dst = (pixel*)p_dst;
|
||||
stride >>= sizeof(pixel)-1;
|
||||
for( j = 0; j < 4; j++ )
|
||||
{
|
||||
for( i = 0; i < 4; i++ )
|
||||
dst[i] = CLIP( dst[i] + dc );
|
||||
dst += stride;
|
||||
}
|
||||
}
|
||||
|
||||
void FUNCC(ff_h264_idct8_dc_add)(uint8_t *p_dst, DCTELEM *block, int stride){
|
||||
int i, j;
|
||||
int dc = (((dctcoef*)block)[0] + 32) >> 6;
|
||||
INIT_CLIP
|
||||
pixel *dst = (pixel*)p_dst;
|
||||
stride >>= sizeof(pixel)-1;
|
||||
for( j = 0; j < 8; j++ )
|
||||
{
|
||||
for( i = 0; i < 8; i++ )
|
||||
dst[i] = CLIP( dst[i] + dc );
|
||||
dst += stride;
|
||||
}
|
||||
}
|
||||
|
||||
void FUNCC(ff_h264_idct_add16)(uint8_t *dst, const int *block_offset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]){
|
||||
int i;
|
||||
for(i=0; i<16; i++){
|
||||
int nnz = nnzc[ scan8[i] ];
|
||||
if(nnz){
|
||||
if(nnz==1 && ((dctcoef*)block)[i*16]) FUNCC(ff_h264_idct_dc_add)(dst + block_offset[i], block + i*16*sizeof(pixel), stride);
|
||||
else FUNCC(idct_internal )(dst + block_offset[i], block + i*16*sizeof(pixel), stride, 4, 6, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void FUNCC(ff_h264_idct_add16intra)(uint8_t *dst, const int *block_offset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]){
|
||||
int i;
|
||||
for(i=0; i<16; i++){
|
||||
if(nnzc[ scan8[i] ]) FUNCC(idct_internal )(dst + block_offset[i], block + i*16*sizeof(pixel), stride, 4, 6, 1);
|
||||
else if(((dctcoef*)block)[i*16]) FUNCC(ff_h264_idct_dc_add)(dst + block_offset[i], block + i*16*sizeof(pixel), stride);
|
||||
}
|
||||
}
|
||||
|
||||
void FUNCC(ff_h264_idct8_add4)(uint8_t *dst, const int *block_offset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]){
|
||||
int i;
|
||||
for(i=0; i<16; i+=4){
|
||||
int nnz = nnzc[ scan8[i] ];
|
||||
if(nnz){
|
||||
if(nnz==1 && ((dctcoef*)block)[i*16]) FUNCC(ff_h264_idct8_dc_add)(dst + block_offset[i], block + i*16*sizeof(pixel), stride);
|
||||
else FUNCC(ff_h264_idct8_add )(dst + block_offset[i], block + i*16*sizeof(pixel), stride);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void FUNCC(ff_h264_idct_add8)(uint8_t **dest, const int *block_offset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]){
|
||||
int i;
|
||||
for(i=16; i<16+8; i++){
|
||||
if(nnzc[ scan8[i] ])
|
||||
FUNCC(ff_h264_idct_add )(dest[(i&4)>>2] + block_offset[i], block + i*16*sizeof(pixel), stride);
|
||||
else if(((dctcoef*)block)[i*16])
|
||||
FUNCC(ff_h264_idct_dc_add)(dest[(i&4)>>2] + block_offset[i], block + i*16*sizeof(pixel), stride);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* IDCT transforms the 16 dc values and dequantizes them.
|
||||
* @param qp quantization parameter
|
||||
*/
|
||||
void FUNCC(ff_h264_luma_dc_dequant_idct)(DCTELEM *p_output, DCTELEM *p_input, int qmul){
|
||||
#define stride 16
|
||||
int i;
|
||||
int temp[16];
|
||||
static const uint8_t x_offset[4]={0, 2*stride, 8*stride, 10*stride};
|
||||
dctcoef *input = (dctcoef*)p_input;
|
||||
dctcoef *output = (dctcoef*)p_output;
|
||||
|
||||
for(i=0; i<4; i++){
|
||||
const int z0= input[4*i+0] + input[4*i+1];
|
||||
const int z1= input[4*i+0] - input[4*i+1];
|
||||
const int z2= input[4*i+2] - input[4*i+3];
|
||||
const int z3= input[4*i+2] + input[4*i+3];
|
||||
|
||||
temp[4*i+0]= z0+z3;
|
||||
temp[4*i+1]= z0-z3;
|
||||
temp[4*i+2]= z1-z2;
|
||||
temp[4*i+3]= z1+z2;
|
||||
}
|
||||
|
||||
for(i=0; i<4; i++){
|
||||
const int offset= x_offset[i];
|
||||
const int z0= temp[4*0+i] + temp[4*2+i];
|
||||
const int z1= temp[4*0+i] - temp[4*2+i];
|
||||
const int z2= temp[4*1+i] - temp[4*3+i];
|
||||
const int z3= temp[4*1+i] + temp[4*3+i];
|
||||
|
||||
output[stride* 0+offset]= ((((z0 + z3)*qmul + 128 ) >> 8));
|
||||
output[stride* 1+offset]= ((((z1 + z2)*qmul + 128 ) >> 8));
|
||||
output[stride* 4+offset]= ((((z1 - z2)*qmul + 128 ) >> 8));
|
||||
output[stride* 5+offset]= ((((z0 - z3)*qmul + 128 ) >> 8));
|
||||
}
|
||||
#undef stride
|
||||
}
|
||||
|
||||
void FUNCC(ff_h264_chroma_dc_dequant_idct)(DCTELEM *p_block, int qmul){
|
||||
const int stride= 16*2;
|
||||
const int xStride= 16;
|
||||
int a,b,c,d,e;
|
||||
dctcoef *block = (dctcoef*)p_block;
|
||||
|
||||
a= block[stride*0 + xStride*0];
|
||||
b= block[stride*0 + xStride*1];
|
||||
c= block[stride*1 + xStride*0];
|
||||
d= block[stride*1 + xStride*1];
|
||||
|
||||
e= a-b;
|
||||
a= a+b;
|
||||
b= c-d;
|
||||
c= c+d;
|
||||
|
||||
block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7;
|
||||
block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7;
|
||||
block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7;
|
||||
block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7;
|
||||
}
|
||||
|
|
@ -2,20 +2,20 @@
|
|||
* H.264 IDCT
|
||||
* Copyright (c) 2004-2011 Michael Niedermayer <michaelni@gmx.at>
|
||||
*
|
||||
* This file is part of Libav.
|
||||
* This file is part of FFmpeg.
|
||||
*
|
||||
* Libav is free software; you can redistribute it and/or
|
||||
* 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.
|
||||
*
|
||||
* Libav is distributed in the hope that it will be useful,
|
||||
* 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 Libav; if not, write to the Free Software
|
||||
* License along with FFmpeg; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
|
|
@ -25,7 +25,7 @@
|
|||
* @author Michael Niedermayer <michaelni@gmx.at>
|
||||
*/
|
||||
|
||||
#include "high_bit_depth.h"
|
||||
#include "h264_high_depth.h"
|
||||
|
||||
#ifndef AVCODEC_H264IDCT_INTERNAL_H
|
||||
#define AVCODEC_H264IDCT_INTERNAL_H
|
||||
|
|
@ -42,12 +42,12 @@ static const uint8_t scan8[16 + 2*4]={
|
|||
};
|
||||
#endif
|
||||
|
||||
static av_always_inline void FUNCC(idct_internal)(uint8_t *_dst, DCTELEM *_block, int stride, int block_stride, int shift, int add){
|
||||
static av_always_inline void FUNCC(idct_internal)(uint8_t *p_dst, DCTELEM *p_block, int stride, int block_stride, int shift, int add){
|
||||
int i;
|
||||
INIT_CLIP
|
||||
pixel *dst = (pixel*)_dst;
|
||||
dctcoef *block = (dctcoef*)_block;
|
||||
stride /= sizeof(pixel);
|
||||
pixel *dst = (pixel*)p_dst;
|
||||
dctcoef *block = (dctcoef*)p_block;
|
||||
stride >>= sizeof(pixel)-1;
|
||||
|
||||
block[0] += 1<<(shift-1);
|
||||
|
||||
|
|
@ -88,12 +88,12 @@ void FUNCC(ff_h264_lowres_idct_put)(uint8_t *dst, int stride, DCTELEM *block){
|
|||
FUNCC(idct_internal)(dst, block, stride, 8, 3, 0);
|
||||
}
|
||||
|
||||
void FUNCC(ff_h264_idct8_add)(uint8_t *_dst, DCTELEM *_block, int stride){
|
||||
void FUNCC(ff_h264_idct8_add)(uint8_t *p_dst, DCTELEM *p_block, int stride){
|
||||
int i;
|
||||
INIT_CLIP
|
||||
pixel *dst = (pixel*)_dst;
|
||||
dctcoef *block = (dctcoef*)_block;
|
||||
stride /= sizeof(pixel);
|
||||
pixel *dst = (pixel*)p_dst;
|
||||
dctcoef *block = (dctcoef*)p_block;
|
||||
stride >>= sizeof(pixel)-1;
|
||||
|
||||
block[0] += 32;
|
||||
|
||||
|
|
@ -162,12 +162,12 @@ void FUNCC(ff_h264_idct8_add)(uint8_t *_dst, DCTELEM *_block, int stride){
|
|||
}
|
||||
|
||||
// assumes all AC coefs are 0
|
||||
void FUNCC(ff_h264_idct_dc_add)(uint8_t *_dst, DCTELEM *block, int stride){
|
||||
void FUNCC(ff_h264_idct_dc_add)(uint8_t *p_dst, DCTELEM *block, int stride){
|
||||
int i, j;
|
||||
int dc = (((dctcoef*)block)[0] + 32) >> 6;
|
||||
INIT_CLIP
|
||||
pixel *dst = (pixel*)_dst;
|
||||
stride /= sizeof(pixel);
|
||||
pixel *dst = (pixel*)p_dst;
|
||||
stride >>= sizeof(pixel)-1;
|
||||
for( j = 0; j < 4; j++ )
|
||||
{
|
||||
for( i = 0; i < 4; i++ )
|
||||
|
|
@ -176,12 +176,12 @@ void FUNCC(ff_h264_idct_dc_add)(uint8_t *_dst, DCTELEM *block, int stride){
|
|||
}
|
||||
}
|
||||
|
||||
void FUNCC(ff_h264_idct8_dc_add)(uint8_t *_dst, DCTELEM *block, int stride){
|
||||
void FUNCC(ff_h264_idct8_dc_add)(uint8_t *p_dst, DCTELEM *block, int stride){
|
||||
int i, j;
|
||||
int dc = (((dctcoef*)block)[0] + 32) >> 6;
|
||||
INIT_CLIP
|
||||
pixel *dst = (pixel*)_dst;
|
||||
stride /= sizeof(pixel);
|
||||
pixel *dst = (pixel*)p_dst;
|
||||
stride >>= sizeof(pixel)-1;
|
||||
for( j = 0; j < 8; j++ )
|
||||
{
|
||||
for( i = 0; i < 8; i++ )
|
||||
|
|
@ -233,13 +233,13 @@ void FUNCC(ff_h264_idct_add8)(uint8_t **dest, const int *block_offset, DCTELEM *
|
|||
* IDCT transforms the 16 dc values and dequantizes them.
|
||||
* @param qp quantization parameter
|
||||
*/
|
||||
void FUNCC(ff_h264_luma_dc_dequant_idct)(DCTELEM *_output, DCTELEM *_input, int qmul){
|
||||
void FUNCC(ff_h264_luma_dc_dequant_idct)(DCTELEM *p_output, DCTELEM *p_input, int qmul){
|
||||
#define stride 16
|
||||
int i;
|
||||
int temp[16];
|
||||
static const uint8_t x_offset[4]={0, 2*stride, 8*stride, 10*stride};
|
||||
dctcoef *input = (dctcoef*)_input;
|
||||
dctcoef *output = (dctcoef*)_output;
|
||||
dctcoef *input = (dctcoef*)p_input;
|
||||
dctcoef *output = (dctcoef*)p_output;
|
||||
|
||||
for(i=0; i<4; i++){
|
||||
const int z0= input[4*i+0] + input[4*i+1];
|
||||
|
|
@ -268,11 +268,11 @@ void FUNCC(ff_h264_luma_dc_dequant_idct)(DCTELEM *_output, DCTELEM *_input, int
|
|||
#undef stride
|
||||
}
|
||||
|
||||
void FUNCC(ff_h264_chroma_dc_dequant_idct)(DCTELEM *_block, int qmul){
|
||||
void FUNCC(ff_h264_chroma_dc_dequant_idct)(DCTELEM *p_block, int qmul){
|
||||
const int stride= 16*2;
|
||||
const int xStride= 16;
|
||||
int a,b,c,d,e;
|
||||
dctcoef *block = (dctcoef*)_block;
|
||||
dctcoef *block = (dctcoef*)p_block;
|
||||
|
||||
a= block[stride*0 + xStride*0];
|
||||
b= block[stride*0 + xStride*1];
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -2,20 +2,20 @@
|
|||
* H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
|
||||
* Copyright (c) 2003-2011 Michael Niedermayer <michaelni@gmx.at>
|
||||
*
|
||||
* This file is part of Libav.
|
||||
* This file is part of FFmpeg.
|
||||
*
|
||||
* Libav is free software; you can redistribute it and/or
|
||||
* 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.
|
||||
*
|
||||
* Libav is distributed in the hope that it will be useful,
|
||||
* 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 Libav; if not, write to the Free Software
|
||||
* License along with FFmpeg; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
|
|
@ -30,7 +30,7 @@
|
|||
|
||||
static void FUNCC(pred4x4_vertical)(uint8_t *_src, const uint8_t *topright, int _stride){
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
const pixel4 a= AV_RN4PA(src-stride);
|
||||
|
||||
AV_WN4PA(src+0*stride, a);
|
||||
|
|
@ -41,7 +41,7 @@ static void FUNCC(pred4x4_vertical)(uint8_t *_src, const uint8_t *topright, int
|
|||
|
||||
static void FUNCC(pred4x4_horizontal)(uint8_t *_src, const uint8_t *topright, int _stride){
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
AV_WN4PA(src+0*stride, PIXEL_SPLAT_X4(src[-1+0*stride]));
|
||||
AV_WN4PA(src+1*stride, PIXEL_SPLAT_X4(src[-1+1*stride]));
|
||||
AV_WN4PA(src+2*stride, PIXEL_SPLAT_X4(src[-1+2*stride]));
|
||||
|
|
@ -50,7 +50,7 @@ static void FUNCC(pred4x4_horizontal)(uint8_t *_src, const uint8_t *topright, in
|
|||
|
||||
static void FUNCC(pred4x4_dc)(uint8_t *_src, const uint8_t *topright, int _stride){
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride]
|
||||
+ src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3;
|
||||
const pixel4 a = PIXEL_SPLAT_X4(dc);
|
||||
|
|
@ -63,7 +63,7 @@ static void FUNCC(pred4x4_dc)(uint8_t *_src, const uint8_t *topright, int _strid
|
|||
|
||||
static void FUNCC(pred4x4_left_dc)(uint8_t *_src, const uint8_t *topright, int _stride){
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
const int dc= ( src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2;
|
||||
const pixel4 a = PIXEL_SPLAT_X4(dc);
|
||||
|
||||
|
|
@ -75,7 +75,7 @@ static void FUNCC(pred4x4_left_dc)(uint8_t *_src, const uint8_t *topright, int _
|
|||
|
||||
static void FUNCC(pred4x4_top_dc)(uint8_t *_src, const uint8_t *topright, int _stride){
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
const int dc= ( src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2;
|
||||
const pixel4 a = PIXEL_SPLAT_X4(dc);
|
||||
|
||||
|
|
@ -87,7 +87,7 @@ static void FUNCC(pred4x4_top_dc)(uint8_t *_src, const uint8_t *topright, int _s
|
|||
|
||||
static void FUNCC(pred4x4_128_dc)(uint8_t *_src, const uint8_t *topright, int _stride){
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
const pixel4 a = PIXEL_SPLAT_X4(1<<(BIT_DEPTH-1));
|
||||
|
||||
AV_WN4PA(src+0*stride, a);
|
||||
|
|
@ -98,7 +98,7 @@ static void FUNCC(pred4x4_128_dc)(uint8_t *_src, const uint8_t *topright, int _s
|
|||
|
||||
static void FUNCC(pred4x4_127_dc)(uint8_t *_src, const uint8_t *topright, int _stride){
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
const pixel4 a = PIXEL_SPLAT_X4((1<<(BIT_DEPTH-1))-1);
|
||||
|
||||
AV_WN4PA(src+0*stride, a);
|
||||
|
|
@ -109,7 +109,7 @@ static void FUNCC(pred4x4_127_dc)(uint8_t *_src, const uint8_t *topright, int _s
|
|||
|
||||
static void FUNCC(pred4x4_129_dc)(uint8_t *_src, const uint8_t *topright, int _stride){
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
const pixel4 a = PIXEL_SPLAT_X4((1<<(BIT_DEPTH-1))+1);
|
||||
|
||||
AV_WN4PA(src+0*stride, a);
|
||||
|
|
@ -145,7 +145,7 @@ static void FUNCC(pred4x4_129_dc)(uint8_t *_src, const uint8_t *topright, int _s
|
|||
|
||||
static void FUNCC(pred4x4_down_right)(uint8_t *_src, const uint8_t *topright, int _stride){
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
const int lt= src[-1-1*stride];
|
||||
LOAD_TOP_EDGE
|
||||
LOAD_LEFT_EDGE
|
||||
|
|
@ -171,7 +171,7 @@ static void FUNCC(pred4x4_down_right)(uint8_t *_src, const uint8_t *topright, in
|
|||
static void FUNCC(pred4x4_down_left)(uint8_t *_src, const uint8_t *_topright, int _stride){
|
||||
pixel *src = (pixel*)_src;
|
||||
const pixel *topright = (const pixel*)_topright;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
LOAD_TOP_EDGE
|
||||
LOAD_TOP_RIGHT_EDGE
|
||||
// LOAD_LEFT_EDGE
|
||||
|
|
@ -196,7 +196,7 @@ static void FUNCC(pred4x4_down_left)(uint8_t *_src, const uint8_t *_topright, in
|
|||
|
||||
static void FUNCC(pred4x4_vertical_right)(uint8_t *_src, const uint8_t *topright, int _stride){
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
const int lt= src[-1-1*stride];
|
||||
LOAD_TOP_EDGE
|
||||
LOAD_LEFT_EDGE
|
||||
|
|
@ -222,7 +222,7 @@ static void FUNCC(pred4x4_vertical_right)(uint8_t *_src, const uint8_t *topright
|
|||
static void FUNCC(pred4x4_vertical_left)(uint8_t *_src, const uint8_t *_topright, int _stride){
|
||||
pixel *src = (pixel*)_src;
|
||||
const pixel *topright = (const pixel*)_topright;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
LOAD_TOP_EDGE
|
||||
LOAD_TOP_RIGHT_EDGE
|
||||
|
||||
|
|
@ -246,7 +246,7 @@ static void FUNCC(pred4x4_vertical_left)(uint8_t *_src, const uint8_t *_topright
|
|||
|
||||
static void FUNCC(pred4x4_horizontal_up)(uint8_t *_src, const uint8_t *topright, int _stride){
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
LOAD_LEFT_EDGE
|
||||
|
||||
src[0+0*stride]=(l0 + l1 + 1)>>1;
|
||||
|
|
@ -269,7 +269,7 @@ static void FUNCC(pred4x4_horizontal_up)(uint8_t *_src, const uint8_t *topright,
|
|||
|
||||
static void FUNCC(pred4x4_horizontal_down)(uint8_t *_src, const uint8_t *topright, int _stride){
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
const int lt= src[-1-1*stride];
|
||||
LOAD_TOP_EDGE
|
||||
LOAD_LEFT_EDGE
|
||||
|
|
@ -295,7 +295,7 @@ static void FUNCC(pred4x4_horizontal_down)(uint8_t *_src, const uint8_t *toprigh
|
|||
static void FUNCC(pred16x16_vertical)(uint8_t *_src, int _stride){
|
||||
int i;
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
const pixel4 a = AV_RN4PA(((pixel4*)(src-stride))+0);
|
||||
const pixel4 b = AV_RN4PA(((pixel4*)(src-stride))+1);
|
||||
const pixel4 c = AV_RN4PA(((pixel4*)(src-stride))+2);
|
||||
|
|
@ -312,7 +312,7 @@ static void FUNCC(pred16x16_vertical)(uint8_t *_src, int _stride){
|
|||
static void FUNCC(pred16x16_horizontal)(uint8_t *_src, int stride){
|
||||
int i;
|
||||
pixel *src = (pixel*)_src;
|
||||
stride /= sizeof(pixel);
|
||||
stride >>= sizeof(pixel)-1;
|
||||
|
||||
for(i=0; i<16; i++){
|
||||
const pixel4 a = PIXEL_SPLAT_X4(src[-1+i*stride]);
|
||||
|
|
@ -337,7 +337,7 @@ static void FUNCC(pred16x16_dc)(uint8_t *_src, int stride){
|
|||
int i, dc=0;
|
||||
pixel *src = (pixel*)_src;
|
||||
pixel4 dcsplat;
|
||||
stride /= sizeof(pixel);
|
||||
stride >>= sizeof(pixel)-1;
|
||||
|
||||
for(i=0;i<16; i++){
|
||||
dc+= src[-1+i*stride];
|
||||
|
|
@ -355,7 +355,7 @@ static void FUNCC(pred16x16_left_dc)(uint8_t *_src, int stride){
|
|||
int i, dc=0;
|
||||
pixel *src = (pixel*)_src;
|
||||
pixel4 dcsplat;
|
||||
stride /= sizeof(pixel);
|
||||
stride >>= sizeof(pixel)-1;
|
||||
|
||||
for(i=0;i<16; i++){
|
||||
dc+= src[-1+i*stride];
|
||||
|
|
@ -369,7 +369,7 @@ static void FUNCC(pred16x16_top_dc)(uint8_t *_src, int stride){
|
|||
int i, dc=0;
|
||||
pixel *src = (pixel*)_src;
|
||||
pixel4 dcsplat;
|
||||
stride /= sizeof(pixel);
|
||||
stride >>= sizeof(pixel)-1;
|
||||
|
||||
for(i=0;i<16; i++){
|
||||
dc+= src[i-stride];
|
||||
|
|
@ -383,7 +383,7 @@ static void FUNCC(pred16x16_top_dc)(uint8_t *_src, int stride){
|
|||
static void FUNCC(pred16x16_##n##_dc)(uint8_t *_src, int stride){\
|
||||
int i;\
|
||||
pixel *src = (pixel*)_src;\
|
||||
stride /= sizeof(pixel);\
|
||||
stride >>= sizeof(pixel)-1;\
|
||||
PREDICT_16x16_DC(PIXEL_SPLAT_X4(v));\
|
||||
}
|
||||
|
||||
|
|
@ -391,12 +391,12 @@ PRED16x16_X(127, (1<<(BIT_DEPTH-1))-1);
|
|||
PRED16x16_X(128, (1<<(BIT_DEPTH-1))+0);
|
||||
PRED16x16_X(129, (1<<(BIT_DEPTH-1))+1);
|
||||
|
||||
static inline void FUNCC(pred16x16_plane_compat)(uint8_t *_src, int _stride, const int svq3, const int rv40){
|
||||
static inline void FUNCC(pred16x16_plane_compat)(uint8_t *p_src, int p_stride, const int svq3, const int rv40){
|
||||
int i, j, k;
|
||||
int a;
|
||||
INIT_CLIP
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
pixel *src = (pixel*)p_src;
|
||||
int stride = p_stride>>(sizeof(pixel)-1);
|
||||
const pixel * const src0 = src +7-stride;
|
||||
const pixel * src1 = src +8*stride-1;
|
||||
const pixel * src2 = src1-2*stride; // == src+6*stride-1;
|
||||
|
|
@ -443,7 +443,7 @@ static void FUNCC(pred16x16_plane)(uint8_t *src, int stride){
|
|||
static void FUNCC(pred8x8_vertical)(uint8_t *_src, int _stride){
|
||||
int i;
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
const pixel4 a= AV_RN4PA(((pixel4*)(src-stride))+0);
|
||||
const pixel4 b= AV_RN4PA(((pixel4*)(src-stride))+1);
|
||||
|
||||
|
|
@ -456,7 +456,7 @@ static void FUNCC(pred8x8_vertical)(uint8_t *_src, int _stride){
|
|||
static void FUNCC(pred8x8_horizontal)(uint8_t *_src, int stride){
|
||||
int i;
|
||||
pixel *src = (pixel*)_src;
|
||||
stride /= sizeof(pixel);
|
||||
stride >>= sizeof(pixel)-1;
|
||||
|
||||
for(i=0; i<8; i++){
|
||||
const pixel4 a = PIXEL_SPLAT_X4(src[-1+i*stride]);
|
||||
|
|
@ -470,7 +470,7 @@ static void FUNCC(pred8x8_##n##_dc)(uint8_t *_src, int stride){\
|
|||
int i;\
|
||||
const pixel4 a = PIXEL_SPLAT_X4(v);\
|
||||
pixel *src = (pixel*)_src;\
|
||||
stride /= sizeof(pixel);\
|
||||
stride >>= sizeof(pixel)-1;\
|
||||
for(i=0; i<8; i++){\
|
||||
AV_WN4PA(((pixel4*)(src+i*stride))+0, a);\
|
||||
AV_WN4PA(((pixel4*)(src+i*stride))+1, a);\
|
||||
|
|
@ -486,7 +486,7 @@ static void FUNCC(pred8x8_left_dc)(uint8_t *_src, int stride){
|
|||
int dc0, dc2;
|
||||
pixel4 dc0splat, dc2splat;
|
||||
pixel *src = (pixel*)_src;
|
||||
stride /= sizeof(pixel);
|
||||
stride >>= sizeof(pixel)-1;
|
||||
|
||||
dc0=dc2=0;
|
||||
for(i=0;i<4; i++){
|
||||
|
|
@ -511,7 +511,7 @@ static void FUNCC(pred8x8_top_dc)(uint8_t *_src, int stride){
|
|||
int dc0, dc1;
|
||||
pixel4 dc0splat, dc1splat;
|
||||
pixel *src = (pixel*)_src;
|
||||
stride /= sizeof(pixel);
|
||||
stride >>= sizeof(pixel)-1;
|
||||
|
||||
dc0=dc1=0;
|
||||
for(i=0;i<4; i++){
|
||||
|
|
@ -536,7 +536,7 @@ static void FUNCC(pred8x8_dc)(uint8_t *_src, int stride){
|
|||
int dc0, dc1, dc2;
|
||||
pixel4 dc0splat, dc1splat, dc2splat, dc3splat;
|
||||
pixel *src = (pixel*)_src;
|
||||
stride /= sizeof(pixel);
|
||||
stride >>= sizeof(pixel)-1;
|
||||
|
||||
dc0=dc1=dc2=0;
|
||||
for(i=0;i<4; i++){
|
||||
|
|
@ -587,7 +587,7 @@ static void FUNCC(pred8x8_plane)(uint8_t *_src, int _stride){
|
|||
int a;
|
||||
INIT_CLIP
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
const pixel * const src0 = src +3-stride;
|
||||
const pixel * src1 = src +4*stride-1;
|
||||
const pixel * src2 = src1-2*stride; // == src+2*stride-1;
|
||||
|
|
@ -658,32 +658,32 @@ static void FUNCC(pred8x8_plane)(uint8_t *_src, int _stride){
|
|||
static void FUNCC(pred8x8l_128_dc)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
|
||||
{
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
|
||||
PREDICT_8x8_DC(PIXEL_SPLAT_X4(1<<(BIT_DEPTH-1)));
|
||||
}
|
||||
static void FUNCC(pred8x8l_left_dc)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
|
||||
{
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
|
||||
PREDICT_8x8_LOAD_LEFT;
|
||||
const pixel4 dc = PIXEL_SPLAT_X4((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3);
|
||||
PREDICT_8x8_DC(dc);
|
||||
}
|
||||
static void FUNCC(pred8x8l_top_dc)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
|
||||
static void FUNCC(pred8x8l_top_dc)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
|
||||
{
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
pixel *src = (pixel*)p_src;
|
||||
int stride = p_stride>>(sizeof(pixel)-1);
|
||||
|
||||
PREDICT_8x8_LOAD_TOP;
|
||||
const pixel4 dc = PIXEL_SPLAT_X4((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3);
|
||||
PREDICT_8x8_DC(dc);
|
||||
}
|
||||
static void FUNCC(pred8x8l_dc)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
|
||||
static void FUNCC(pred8x8l_dc)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
|
||||
{
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
pixel *src = (pixel*)p_src;
|
||||
int stride = p_stride>>(sizeof(pixel)-1);
|
||||
|
||||
PREDICT_8x8_LOAD_LEFT;
|
||||
PREDICT_8x8_LOAD_TOP;
|
||||
|
|
@ -691,10 +691,10 @@ static void FUNCC(pred8x8l_dc)(uint8_t *_src, int has_topleft, int has_topright,
|
|||
+t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4);
|
||||
PREDICT_8x8_DC(dc);
|
||||
}
|
||||
static void FUNCC(pred8x8l_horizontal)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
|
||||
static void FUNCC(pred8x8l_horizontal)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
|
||||
{
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
pixel *src = (pixel*)p_src;
|
||||
int stride = p_stride>>(sizeof(pixel)-1);
|
||||
|
||||
PREDICT_8x8_LOAD_LEFT;
|
||||
#define ROW(y) ((pixel4*)(src+y*stride))[0] =\
|
||||
|
|
@ -706,7 +706,7 @@ static void FUNCC(pred8x8l_vertical)(uint8_t *_src, int has_topleft, int has_top
|
|||
{
|
||||
int y;
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
int stride = _stride>>(sizeof(pixel)-1);
|
||||
pixel4 a, b;
|
||||
|
||||
PREDICT_8x8_LOAD_TOP;
|
||||
|
|
@ -725,10 +725,10 @@ static void FUNCC(pred8x8l_vertical)(uint8_t *_src, int has_topleft, int has_top
|
|||
AV_WN4PA(((pixel4*)(src+y*stride))+1, b);
|
||||
}
|
||||
}
|
||||
static void FUNCC(pred8x8l_down_left)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
|
||||
static void FUNCC(pred8x8l_down_left)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
|
||||
{
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
pixel *src = (pixel*)p_src;
|
||||
int stride = p_stride>>(sizeof(pixel)-1);
|
||||
PREDICT_8x8_LOAD_TOP;
|
||||
PREDICT_8x8_LOAD_TOPRIGHT;
|
||||
SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2;
|
||||
|
|
@ -747,10 +747,10 @@ static void FUNCC(pred8x8l_down_left)(uint8_t *_src, int has_topleft, int has_to
|
|||
SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2;
|
||||
SRC(7,7)= (t14 + 3*t15 + 2) >> 2;
|
||||
}
|
||||
static void FUNCC(pred8x8l_down_right)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
|
||||
static void FUNCC(pred8x8l_down_right)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
|
||||
{
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
pixel *src = (pixel*)p_src;
|
||||
int stride = p_stride>>(sizeof(pixel)-1);
|
||||
PREDICT_8x8_LOAD_TOP;
|
||||
PREDICT_8x8_LOAD_LEFT;
|
||||
PREDICT_8x8_LOAD_TOPLEFT;
|
||||
|
|
@ -770,10 +770,10 @@ static void FUNCC(pred8x8l_down_right)(uint8_t *_src, int has_topleft, int has_t
|
|||
SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2;
|
||||
SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2;
|
||||
}
|
||||
static void FUNCC(pred8x8l_vertical_right)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
|
||||
static void FUNCC(pred8x8l_vertical_right)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
|
||||
{
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
pixel *src = (pixel*)p_src;
|
||||
int stride = p_stride>>(sizeof(pixel)-1);
|
||||
PREDICT_8x8_LOAD_TOP;
|
||||
PREDICT_8x8_LOAD_LEFT;
|
||||
PREDICT_8x8_LOAD_TOPLEFT;
|
||||
|
|
@ -800,10 +800,10 @@ static void FUNCC(pred8x8l_vertical_right)(uint8_t *_src, int has_topleft, int h
|
|||
SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2;
|
||||
SRC(7,0)= (t6 + t7 + 1) >> 1;
|
||||
}
|
||||
static void FUNCC(pred8x8l_horizontal_down)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
|
||||
static void FUNCC(pred8x8l_horizontal_down)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
|
||||
{
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
pixel *src = (pixel*)p_src;
|
||||
int stride = p_stride>>(sizeof(pixel)-1);
|
||||
PREDICT_8x8_LOAD_TOP;
|
||||
PREDICT_8x8_LOAD_LEFT;
|
||||
PREDICT_8x8_LOAD_TOPLEFT;
|
||||
|
|
@ -830,10 +830,10 @@ static void FUNCC(pred8x8l_horizontal_down)(uint8_t *_src, int has_topleft, int
|
|||
SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2;
|
||||
SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2;
|
||||
}
|
||||
static void FUNCC(pred8x8l_vertical_left)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
|
||||
static void FUNCC(pred8x8l_vertical_left)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
|
||||
{
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
pixel *src = (pixel*)p_src;
|
||||
int stride = p_stride>>(sizeof(pixel)-1);
|
||||
PREDICT_8x8_LOAD_TOP;
|
||||
PREDICT_8x8_LOAD_TOPRIGHT;
|
||||
SRC(0,0)= (t0 + t1 + 1) >> 1;
|
||||
|
|
@ -859,10 +859,10 @@ static void FUNCC(pred8x8l_vertical_left)(uint8_t *_src, int has_topleft, int ha
|
|||
SRC(7,6)= (t10 + t11 + 1) >> 1;
|
||||
SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2;
|
||||
}
|
||||
static void FUNCC(pred8x8l_horizontal_up)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
|
||||
static void FUNCC(pred8x8l_horizontal_up)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
|
||||
{
|
||||
pixel *src = (pixel*)_src;
|
||||
int stride = _stride/sizeof(pixel);
|
||||
pixel *src = (pixel*)p_src;
|
||||
int stride = p_stride>>(sizeof(pixel)-1);
|
||||
PREDICT_8x8_LOAD_LEFT;
|
||||
SRC(0,0)= (l0 + l1 + 1) >> 1;
|
||||
SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2;
|
||||
|
|
@ -893,11 +893,11 @@ static void FUNCC(pred8x8l_horizontal_up)(uint8_t *_src, int has_topleft, int ha
|
|||
#undef PL
|
||||
#undef SRC
|
||||
|
||||
static void FUNCC(pred4x4_vertical_add)(uint8_t *_pix, const DCTELEM *_block, int stride){
|
||||
static void FUNCC(pred4x4_vertical_add)(uint8_t *p_pix, const DCTELEM *p_block, int stride){
|
||||
int i;
|
||||
pixel *pix = (pixel*)_pix;
|
||||
const dctcoef *block = (const dctcoef*)_block;
|
||||
stride /= sizeof(pixel);
|
||||
pixel *pix = (pixel*)p_pix;
|
||||
const dctcoef *block = (const dctcoef*)p_block;
|
||||
stride >>= sizeof(pixel)-1;
|
||||
pix -= stride;
|
||||
for(i=0; i<4; i++){
|
||||
pixel v = pix[0];
|
||||
|
|
@ -910,11 +910,11 @@ static void FUNCC(pred4x4_vertical_add)(uint8_t *_pix, const DCTELEM *_block, in
|
|||
}
|
||||
}
|
||||
|
||||
static void FUNCC(pred4x4_horizontal_add)(uint8_t *_pix, const DCTELEM *_block, int stride){
|
||||
static void FUNCC(pred4x4_horizontal_add)(uint8_t *p_pix, const DCTELEM *p_block, int stride){
|
||||
int i;
|
||||
pixel *pix = (pixel*)_pix;
|
||||
const dctcoef *block = (const dctcoef*)_block;
|
||||
stride /= sizeof(pixel);
|
||||
pixel *pix = (pixel*)p_pix;
|
||||
const dctcoef *block = (const dctcoef*)p_block;
|
||||
stride >>= sizeof(pixel)-1;
|
||||
for(i=0; i<4; i++){
|
||||
pixel v = pix[-1];
|
||||
pix[0]= v += block[0];
|
||||
|
|
@ -926,11 +926,11 @@ static void FUNCC(pred4x4_horizontal_add)(uint8_t *_pix, const DCTELEM *_block,
|
|||
}
|
||||
}
|
||||
|
||||
static void FUNCC(pred8x8l_vertical_add)(uint8_t *_pix, const DCTELEM *_block, int stride){
|
||||
static void FUNCC(pred8x8l_vertical_add)(uint8_t *p_pix, const DCTELEM *p_block, int stride){
|
||||
int i;
|
||||
pixel *pix = (pixel*)_pix;
|
||||
const dctcoef *block = (const dctcoef*)_block;
|
||||
stride /= sizeof(pixel);
|
||||
pixel *pix = (pixel*)p_pix;
|
||||
const dctcoef *block = (const dctcoef*)p_block;
|
||||
stride >>= sizeof(pixel)-1;
|
||||
pix -= stride;
|
||||
for(i=0; i<8; i++){
|
||||
pixel v = pix[0];
|
||||
|
|
@ -947,11 +947,11 @@ static void FUNCC(pred8x8l_vertical_add)(uint8_t *_pix, const DCTELEM *_block, i
|
|||
}
|
||||
}
|
||||
|
||||
static void FUNCC(pred8x8l_horizontal_add)(uint8_t *_pix, const DCTELEM *_block, int stride){
|
||||
static void FUNCC(pred8x8l_horizontal_add)(uint8_t *p_pix, const DCTELEM *p_block, int stride){
|
||||
int i;
|
||||
pixel *pix = (pixel*)_pix;
|
||||
const dctcoef *block = (const dctcoef*)_block;
|
||||
stride /= sizeof(pixel);
|
||||
pixel *pix = (pixel*)p_pix;
|
||||
const dctcoef *block = (const dctcoef*)p_block;
|
||||
stride >>= sizeof(pixel)-1;
|
||||
for(i=0; i<8; i++){
|
||||
pixel v = pix[-1];
|
||||
pix[0]= v += block[0];
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user