mc.h

/*****************************************************************************
 * mc.h: motion compensation
 *****************************************************************************/
 
#ifndef X264_MC_H
#define X264_MC_H
 
struct x264_weight_t;
typedef void (*weight_fn_t)(pixel *, intptr_t, pixel *, intptr_t, const struct x264_weight_t *, int);
typedef struct x264_weight_t {
    /* aligning the first member is a gcc hack to force the struct to be
     * 16 byte aligned, as well as force sizeof(struct) to be a multiple of 16 */
    ALIGNED_16(int16_t cachea[8]);
    int16_t cacheb[8];
    int32_t i_denom; /* exp2 as denominator */
    int32_t i_scale; /* scale as numerator */
    int32_t i_offset;
    weight_fn_t *weightfn;
} ALIGNED_16(x264_weight_t);
 
extern const x264_weight_t x264_weight_none[3];
 
/* Do the MC
 * XXX: Only width = 4, 8 or 16 are valid
 * width == 4 -> height == 4 or 8
 * width == 8 -> height == 4 or 8 or 16
 * width == 16-> height == 8 or 16
 * */
 
typedef struct
{
    void (*mc_luma)(pixel *dst, intptr_t i_dst, pixel **src, intptr_t i_src,
            int mvx, int mvy, int i_width, int i_height, const x264_weight_t *weight);
 
    /* may round up the dimensions if they're not a power of 2 */
    pixel *(*get_ref)(pixel *dst, intptr_t *i_dst, pixel **src, intptr_t i_src,
              int mvx, int mvy, int i_width, int i_height, const x264_weight_t *weight);
 
    /* mc_chroma may write up to 2 bytes of garbage to the right of dst,
     * so it must be run from left to right. */
    void (*mc_chroma)(pixel *dstu, pixel *dstv, intptr_t i_dst, pixel *src, intptr_t i_src,
              int mvx, int mvy, int i_width, int i_height);
 
    /* only 16x16, 8x8, and 4x4 defined */
    void (*copy[7])(pixel *dst, intptr_t dst_stride, pixel *src, intptr_t src_stride, int i_height);
 
    void (*store_interleave_chroma)(pixel *dst, intptr_t i_dst, pixel *srcu, pixel *srcv, int height);
    void (*load_deinterleave_chroma_fenc)(pixel *dst, pixel *src, intptr_t i_src, int height);
    void (*load_deinterleave_chroma_fdec)(pixel *dst, pixel *src, intptr_t i_src, int height);
 
    void (*plane_copy)(pixel *dst, intptr_t i_dst, pixel *src, intptr_t i_src, int w, int h);
    void (*plane_copy_interleave)(pixel *dst, intptr_t i_dst, pixel *srcu, intptr_t i_srcu,
                      pixel *srcv, intptr_t i_srcv, int w, int h);
    /* may write up to 15 pixels off the end of each plane */
    void (*plane_copy_deinterleave)(pixel *dstu, intptr_t i_dstu, pixel *dstv, intptr_t i_dstv,
                    pixel *src, intptr_t i_src, int w, int h);
    void (*plane_copy_deinterlace)(
        pixel *srcy, intptr_t i_srcy, pixel *dsty, intptr_t i_dsty,
        pixel *srcc, intptr_t i_srcc, pixel *dstc, intptr_t i_dstc,
        int i_width, int i_height);
    void (*plane_deinterlace)(pixel *pixy, intptr_t i_pixy, pixel *pixc, intptr_t i_pixc, int i_width, int i_height);
 
    void (*hpel_filter)(pixel *dsth, pixel *dstv, pixel *dstc, pixel *src,
                intptr_t i_stride, int i_width, int i_height, int16_t *buf);
 
    /* prefetch the next few macroblocks of fenc or fdec */
    void (*prefetch_fenc)(pixel *pix_y, intptr_t stride_y, pixel *pix_uv, intptr_t stride_uv, int mb_x);
    void (*prefetch_fenc_420)(pixel *pix_y, intptr_t stride_y, pixel *pix_uv, intptr_t stride_uv, int mb_x);
    /* prefetch the next few macroblocks of a hpel reference frame */
    void (*prefetch_ref)(pixel *pix, intptr_t stride, int parity);
 
    void *(*memcpy_aligned)(void *dst, const void *src, size_t n);
    void (*memzero_aligned)(void *dst, size_t n);
 
    void (*frame_init_lowres_core)(pixel *src0, pixel *dst0, pixel *dsth, pixel *dstv, pixel *dstc,
                       intptr_t src_stride, intptr_t dst_stride, int width, int height);
 
} x264_mc_functions_t;
 
void x264_mc_init(int cpu, x264_mc_functions_t *pf);
 
#endif