schromotion

schromotion

Synopsis

struct              SchroMotion;
#define             SCHRO_MOTION_GET_BLOCK              (motion,
                                                         x,
                                                         y)
void                schro_motion_dc_prediction          (SchroMotion *motion,
                                                         int x,
                                                         int y,
                                                         int *pred);
void                schro_motion_vector_prediction      (SchroMotion *motion,
                                                         int x,
                                                         int y,
                                                         int *pred_x,
                                                         int *pred_y,
                                                         int mode);
int                 schro_motion_split_prediction       (SchroMotion *motion,
                                                         int x,
                                                         int y);
int                 schro_motion_get_mode_prediction    (SchroMotion *motion,
                                                         int x,
                                                         int y);
int                 schro_motion_block_estimate_entropy (SchroMotion *motion,
                                                         int i,
                                                         int j);
void                schro_motion_copy_from              (SchroMotion *motion,
                                                         int i,
                                                         int j,
                                                         SchroBlock *block);
void                schro_motion_copy_to                (SchroMotion *motion,
                                                         int i,
                                                         int j,
                                                         SchroBlock *block);
int                 schro_motion_estimate_entropy       (SchroMotion *motion);
void                schro_motion_field_lshift           (SchroMotionField *mf,
                                                         int n);
void                schro_motion_free                   (SchroMotion *motion);
int                 schro_motion_get_global_prediction  (SchroMotion *motion,
                                                         int x,
                                                         int y);
SchroMotion *       schro_motion_new                    (SchroParams *params,
                                                         SchroUpsampledFrame *ref1,
                                                         SchroUpsampledFrame *ref2);
void                schro_motion_render                 (SchroMotion *motion,
                                                         SchroFrame *dest,
                                                         SchroFrame *addframe,
                                                         int add,
                                                         SchroFrame *output_frame);
void                schro_motion_render_cuda            (SchroMotion *motion,
                                                         SchroFrame *dest);
void                schro_motion_render_ref             (SchroMotion *motion,
                                                         SchroFrame *dest,
                                                         SchroFrame *addframe,
                                                         int add,
                                                         SchroFrame *output_frame);
int                 schro_motion_superblock_estimate_entropy
                                                        (SchroMotion *motion,
                                                         int i,
                                                         int j);
int                 schro_motion_superblock_try_estimate_entropy
                                                        (SchroMotion *motion,
                                                         int i,
                                                         int j,
                                                         SchroBlock *block);
int                 schro_motion_vector_is_equal        (SchroMotionVector *mv1,
                                                         SchroMotionVector *mv2);
SchroMotionField *  schro_motion_field_new              (int x_num_blocks,
                                                         int y_num_blocks);
void                schro_motion_field_free             (SchroMotionField *field);
void                schro_motion_field_scan             (SchroMotionField *field,
                                                         SchroParams *params,
                                                         SchroFrame *frame,
                                                         SchroFrame *ref,
                                                         int dist);
void                schro_motion_field_inherit          (SchroMotionField *field,
                                                         SchroMotionField *parent);
void                schro_motion_field_copy             (SchroMotionField *field,
                                                         SchroMotionField *parent);
int                 schro_motion_verify                 (SchroMotion *mf);

Description

Details

struct SchroMotion

struct SchroMotion {
  SchroUpsampledFrame *src1;
  SchroUpsampledFrame *src2;
  SchroMotionVector *motion_vectors;
  SchroParams *params;

  uint8_t *tmpdata;

  int ref_weight_precision;
  int ref1_weight;
  int ref2_weight;
  int mv_precision;
  int xoffset;
  int yoffset;
  int xbsep;
  int ybsep;
  int xblen;
  int yblen;

  SchroFrameData block;
  SchroFrameData alloc_block;
  SchroFrameData obmc_weight;

  SchroFrameData alloc_block_ref[2];
  SchroFrameData block_ref[2];

  int weight_x[SCHRO_LIMIT_BLOCK_SIZE];
  int weight_y[SCHRO_LIMIT_BLOCK_SIZE];
  int width;
  int height;
  int max_fast_x;
  int max_fast_y;

  schro_bool simple_weight;
  schro_bool oneref_noscale;
};

SCHRO_MOTION_GET_BLOCK()

#define             SCHRO_MOTION_GET_BLOCK(motion,x,y)

schro_motion_dc_prediction ()

void                schro_motion_dc_prediction          (SchroMotion *motion,
                                                         int x,
                                                         int y,
                                                         int *pred);

schro_motion_vector_prediction ()

void                schro_motion_vector_prediction      (SchroMotion *motion,
                                                         int x,
                                                         int y,
                                                         int *pred_x,
                                                         int *pred_y,
                                                         int mode);

schro_motion_split_prediction ()

int                 schro_motion_split_prediction       (SchroMotion *motion,
                                                         int x,
                                                         int y);

schro_motion_get_mode_prediction ()

int                 schro_motion_get_mode_prediction    (SchroMotion *motion,
                                                         int x,
                                                         int y);

schro_motion_block_estimate_entropy ()

int                 schro_motion_block_estimate_entropy (SchroMotion *motion,
                                                         int i,
                                                         int j);

schro_motion_copy_from ()

void                schro_motion_copy_from              (SchroMotion *motion,
                                                         int i,
                                                         int j,
                                                         SchroBlock *block);

schro_motion_copy_to ()

void                schro_motion_copy_to                (SchroMotion *motion,
                                                         int i,
                                                         int j,
                                                         SchroBlock *block);

schro_motion_estimate_entropy ()

int                 schro_motion_estimate_entropy       (SchroMotion *motion);

schro_motion_field_lshift ()

void                schro_motion_field_lshift           (SchroMotionField *mf,
                                                         int n);

schro_motion_free ()

void                schro_motion_free                   (SchroMotion *motion);

schro_motion_get_global_prediction ()

int                 schro_motion_get_global_prediction  (SchroMotion *motion,
                                                         int x,
                                                         int y);

schro_motion_new ()

SchroMotion *       schro_motion_new                    (SchroParams *params,
                                                         SchroUpsampledFrame *ref1,
                                                         SchroUpsampledFrame *ref2);

schro_motion_render ()

void                schro_motion_render                 (SchroMotion *motion,
                                                         SchroFrame *dest,
                                                         SchroFrame *addframe,
                                                         int add,
                                                         SchroFrame *output_frame);

schro_motion_render_cuda ()

void                schro_motion_render_cuda            (SchroMotion *motion,
                                                         SchroFrame *dest);

schro_motion_render_ref ()

void                schro_motion_render_ref             (SchroMotion *motion,
                                                         SchroFrame *dest,
                                                         SchroFrame *addframe,
                                                         int add,
                                                         SchroFrame *output_frame);

schro_motion_superblock_estimate_entropy ()

int                 schro_motion_superblock_estimate_entropy
                                                        (SchroMotion *motion,
                                                         int i,
                                                         int j);

schro_motion_superblock_try_estimate_entropy ()

int                 schro_motion_superblock_try_estimate_entropy
                                                        (SchroMotion *motion,
                                                         int i,
                                                         int j,
                                                         SchroBlock *block);

schro_motion_vector_is_equal ()

int                 schro_motion_vector_is_equal        (SchroMotionVector *mv1,
                                                         SchroMotionVector *mv2);

schro_motion_field_new ()

SchroMotionField *  schro_motion_field_new              (int x_num_blocks,
                                                         int y_num_blocks);

schro_motion_field_free ()

void                schro_motion_field_free             (SchroMotionField *field);

schro_motion_field_scan ()

void                schro_motion_field_scan             (SchroMotionField *field,
                                                         SchroParams *params,
                                                         SchroFrame *frame,
                                                         SchroFrame *ref,
                                                         int dist);

schro_motion_field_inherit ()

void                schro_motion_field_inherit          (SchroMotionField *field,
                                                         SchroMotionField *parent);

schro_motion_field_copy ()

void                schro_motion_field_copy             (SchroMotionField *field,
                                                         SchroMotionField *parent);

schro_motion_verify ()

int                 schro_motion_verify                 (SchroMotion *mf);

Generated by GTK-Doc V1.18