schroframe

schroframe —

Synopsis




            SchroFrame;
            SchroFrameData;
void        (*SchroFrameFreeFunc)           (SchroFrame *frame,
                                             void *priv);
enum        SchroFrameFormat;
            SchroUpsampledFrame;
#define     SCHRO_FRAME_FORMAT_DEPTH        (format)
#define     SCHRO_FRAME_FORMAT_DEPTH_S16
#define     SCHRO_FRAME_FORMAT_DEPTH_S32
#define     SCHRO_FRAME_FORMAT_DEPTH_U8
#define     SCHRO_FRAME_FORMAT_H_SHIFT      (format)
#define     SCHRO_FRAME_FORMAT_V_SHIFT      (format)
#define     SCHRO_FRAME_IS_PACKED           (format)
#define     SCHRO_FRAME_DATA_GET_LINE       (fd,i)
#define     SCHRO_FRAME_DATA_GET_PIXEL_S16  (fd,i,j)
#define     SCHRO_FRAME_DATA_GET_PIXEL_U8   (fd,i,j)
SchroFrame* schro_frame_new                 (void);
SchroFrame* schro_frame_new_and_alloc       (SchroMemoryDomain *domain,
                                             SchroFrameFormat format,
                                             int width,
                                             int height);
SchroFrame* schro_frame_new_from_data_AYUV  (void *data,
                                             int width,
                                             int height);
SchroFrame* schro_frame_new_from_data_I420  (void *data,
                                             int width,
                                             int height);
SchroFrame* schro_frame_new_from_data_YUY2  (void *data,
                                             int width,
                                             int height);
SchroFrame* schro_frame_dup                 (SchroFrame *frame);
SchroFrame* schro_frame_ref                 (SchroFrame *frame);
void        schro_frame_unref               (SchroFrame *frame);
void        schro_frame_set_free_callback   (SchroFrame *frame,
                                             SchroFrameFreeFunc free_func,
                                             void *priv);
SchroFrame* schro_frame_clone               (SchroMemoryDomain *domain,
                                             SchroFrame *frame);
void        schro_frame_data_get_codeblock  (SchroFrameData *dest,
                                             SchroFrameData *src,
                                             int x,
                                             int y,
                                             int horiz_codeblocks,
                                             int vert_codeblocks);
int         schro_frame_get_metric          (SchroFrame *frame1,
                                             int x1,
                                             int y1,
                                             SchroFrame *frame2,
                                             int x2,
                                             int y2);
void        schro_frame_get_subdata         (SchroFrame *frame,
                                             SchroFrameData *fd,
                                             int comp,
                                             int x,
                                             int y);
void        schro_frame_inverse_iwt_transform_cuda
                                            (SchroFrame *frame,
                                             SchroFrame *transform_frame,
                                             SchroParams *params);
SchroFrame* schro_frame_new_from_data_UYVY  (void *data,
                                             int width,
                                             int height);
SchroFrame* schro_frame_new_from_data_YV12  (void *data,
                                             int width,
                                             int height);

void        schro_frame_convert             (SchroFrame *dest,
                                             SchroFrame *src);
SchroFrame* schro_frame_convert_to_444      (SchroFrame *frame);
void        schro_frame_add                 (SchroFrame *dest,
                                             SchroFrame *src);
void        schro_frame_subtract            (SchroFrame *dest,
                                             SchroFrame *src);
void        schro_frame_shift_left          (SchroFrame *frame,
                                             int shift);
void        schro_frame_shift_right         (SchroFrame *frame,
                                             int shift);
void        schro_frame_edge_extend         (SchroFrame *frame,
                                             int width,
                                             int height);
void        schro_frame_zero_extend         (SchroFrame *frame,
                                             int width,
                                             int height);
void        schro_frame_iwt_transform       (SchroFrame *frame,
                                             SchroParams *params);
void        schro_frame_inverse_iwt_transform
                                            (SchroFrame *frame,
                                             SchroParams *params);
void        schro_frame_downsample          (SchroFrame *dest,
                                             SchroFrame *src);
void        schro_frame_mark                (SchroFrame *frame,
                                             int value);
void        schro_frame_upsample_horiz      (SchroFrame *dest,
                                             SchroFrame *src);
void        schro_frame_upsample_vert       (SchroFrame *dest,
                                             SchroFrame *src);

double      schro_frame_ssim                (SchroFrame *a,
                                             SchroFrame *b);
void        schro_frame_mean_squared_error  (SchroFrame *a,
                                             SchroFrame *b,
                                             double *mse);
void        schro_frame_md5                 (SchroFrame *frame,
                                             uint32_t *state);
double      schro_frame_calculate_average_luma
                                            (SchroFrame *frame);


void        schro_upsampled_frame_free      (SchroUpsampledFrame *df);
SchroUpsampledFrame* schro_upsampled_frame_new
                                            (SchroFrame *frame);
void        schro_upsampled_frame_upsample  (SchroUpsampledFrame *df);
void        schro_upsampled_frame_get_block_fast_precN
                                            (SchroUpsampledFrame *upframe,
                                             int k,
                                             int x,
                                             int y,
                                             int prec,
                                             SchroFrameData *dest,
                                             SchroFrameData *fd);
void        schro_upsampled_frame_get_block_precN
                                            (SchroUpsampledFrame *upframe,
                                             int k,
                                             int x,
                                             int y,
                                             int prec,
                                             SchroFrameData *dest);
int         schro_upsampled_frame_get_pixel_prec0
                                            (SchroUpsampledFrame *upframe,
                                             int k,
                                             int x,
                                             int y);
int         schro_upsampled_frame_get_pixel_prec1
                                            (SchroUpsampledFrame *upframe,
                                             int k,
                                             int x,
                                             int y);
int         schro_upsampled_frame_get_pixel_prec3
                                            (SchroUpsampledFrame *upframe,
                                             int k,
                                             int x,
                                             int y);
int         schro_upsampled_frame_get_pixel_precN
                                            (SchroUpsampledFrame *upframe,
                                             int k,
                                             int x,
                                             int y,
                                             int mv_precision);

Description

Details

SchroFrame

typedef struct {
  int refcount;
  SchroFrameFreeFunc free;
  SchroMemoryDomain *domain;
  void *regions[3];
  void *priv;

  SchroFrameFormat format;
  int width;
  int height;

  SchroFrameData components[3];

  int is_virtual;
  int cached_lines[3][SCHRO_FRAME_CACHE_SIZE];
  SchroFrame *virt_frame1;
  SchroFrame *virt_frame2;
  void (*render_line) (SchroFrame *frame, void *dest, int component, int i);
  void *virt_priv;
  void *virt_priv2;

  int extension;
  int cache_offset[3];
} SchroFrame;


SchroFrameData

typedef struct {
  SchroFrameFormat format;
  void *data;
  int stride;
  int width;
  int height;
  int length;
  int h_shift;
  int v_shift;
} SchroFrameData;


SchroFrameFreeFunc ()

void        (*SchroFrameFreeFunc)           (SchroFrame *frame,
                                             void *priv);

frame :
priv :

enum SchroFrameFormat

typedef enum _SchroFrameFormat {
  SCHRO_FRAME_FORMAT_U8_444 = 0x00,
  SCHRO_FRAME_FORMAT_U8_422 = 0x01,
  SCHRO_FRAME_FORMAT_U8_420 = 0x03,

  SCHRO_FRAME_FORMAT_S16_444 = 0x04,
  SCHRO_FRAME_FORMAT_S16_422 = 0x05,
  SCHRO_FRAME_FORMAT_S16_420 = 0x07,

  SCHRO_FRAME_FORMAT_S32_444 = 0x08,
  SCHRO_FRAME_FORMAT_S32_422 = 0x09,
  SCHRO_FRAME_FORMAT_S32_420 = 0x0b,

  /* indirectly supported */
  SCHRO_FRAME_FORMAT_YUYV = 0x100, /* YUYV order */
  SCHRO_FRAME_FORMAT_UYVY = 0x101, /* UYVY order */
  SCHRO_FRAME_FORMAT_AYUV = 0x102,
  SCHRO_FRAME_FORMAT_ARGB = 0x103,
  SCHRO_FRAME_FORMAT_RGB = 0x104,
  SCHRO_FRAME_FORMAT_v216 = 0x105,
  SCHRO_FRAME_FORMAT_v210 = 0x106
} SchroFrameFormat;


SchroUpsampledFrame

typedef struct {
  SchroFrame *frames[4];
  void *components[3];
} SchroUpsampledFrame;


SCHRO_FRAME_FORMAT_DEPTH()

#define SCHRO_FRAME_FORMAT_DEPTH(format) ((format) & 0xc)

format :

SCHRO_FRAME_FORMAT_DEPTH_S16

#define SCHRO_FRAME_FORMAT_DEPTH_S16 0x04


SCHRO_FRAME_FORMAT_DEPTH_S32

#define SCHRO_FRAME_FORMAT_DEPTH_S32 0x08


SCHRO_FRAME_FORMAT_DEPTH_U8

#define SCHRO_FRAME_FORMAT_DEPTH_U8 0x00


SCHRO_FRAME_FORMAT_H_SHIFT()

#define SCHRO_FRAME_FORMAT_H_SHIFT(format) ((format) & 0x1)

format :

SCHRO_FRAME_FORMAT_V_SHIFT()

#define SCHRO_FRAME_FORMAT_V_SHIFT(format) (((format)>>1) & 0x1)

format :

SCHRO_FRAME_IS_PACKED()

#define SCHRO_FRAME_IS_PACKED(format) (((format)>>8) & 0x1)

format :

SCHRO_FRAME_DATA_GET_LINE()

#define SCHRO_FRAME_DATA_GET_LINE(fd,i) (SCHRO_OFFSET((fd)->data,(fd)->stride*(i)))

fd :
i :

SCHRO_FRAME_DATA_GET_PIXEL_S16()

#define SCHRO_FRAME_DATA_GET_PIXEL_S16(fd,i,j) ((int16_t *)SCHRO_OFFSET((fd)->data,(fd)->stride*(j)+(i)*sizeof(int16_t)))

fd :
i :
j :

SCHRO_FRAME_DATA_GET_PIXEL_U8()

#define SCHRO_FRAME_DATA_GET_PIXEL_U8(fd,i,j) ((uint8_t *)SCHRO_OFFSET((fd)->data,(fd)->stride*(j)+(i)))

fd :
i :
j :

schro_frame_new ()

SchroFrame* schro_frame_new                 (void);

Creates a new SchroFrame object. The created frame is uninitialized and has no data storage associated with it. The caller must fill in the required information.

Returns : a new SchroFrame object

schro_frame_new_and_alloc ()

SchroFrame* schro_frame_new_and_alloc       (SchroMemoryDomain *domain,
                                             SchroFrameFormat format,
                                             int width,
                                             int height);

Creates a new SchroFrame object with the requested size and format.

domain :
format :
width :
height :
Returns : a new SchroFrame object

schro_frame_new_from_data_AYUV ()

SchroFrame* schro_frame_new_from_data_AYUV  (void *data,
                                             int width,
                                             int height);

Creates a new SchroFrame object with the requested size using the data pointed to by data. The data must be in AYUV format. The data must remain for the lifetime of the SchroFrame object. It is recommended to use schro_frame_set_free_callback() for notification when the data is no longer needed.

data :
width :
height :
Returns : a new SchroFrame object

schro_frame_new_from_data_I420 ()

SchroFrame* schro_frame_new_from_data_I420  (void *data,
                                             int width,
                                             int height);

Creates a new SchroFrame object with the requested size using the data pointed to by data. The data must be in I420 format. The data must remain for the lifetime of the SchroFrame object. It is recommended to use schro_frame_set_free_callback() for notification when the data is no longer needed.

data :
width :
height :
Returns : a new SchroFrame object

schro_frame_new_from_data_YUY2 ()

SchroFrame* schro_frame_new_from_data_YUY2  (void *data,
                                             int width,
                                             int height);

Creates a new SchroFrame object with the requested size using the data pointed to by data. The data must be in YUY2 format. The data must remain for the lifetime of the SchroFrame object. It is recommended to use schro_frame_set_free_callback() for notification when the data is no longer needed.

data :
width :
height :
Returns : a new SchroFrame object

schro_frame_dup ()

SchroFrame* schro_frame_dup                 (SchroFrame *frame);

Creates a new SchroFrame object with the same dimensions and format as frame, and copies the data from the frame to the new object.

frame :
Returns : a new SchroFrame object

schro_frame_ref ()

SchroFrame* schro_frame_ref                 (SchroFrame *frame);

Increases the reference count of frame.

frame : a frame object
Returns : the value of frame

schro_frame_unref ()

void        schro_frame_unref               (SchroFrame *frame);

Decreases the reference count of frame. If the new reference count is 0, the frame is freed. If a frame free callback was set, this function is called.

frame : a frame object

schro_frame_set_free_callback ()

void        schro_frame_set_free_callback   (SchroFrame *frame,
                                             SchroFrameFreeFunc free_func,
                                             void *priv);

Sets a function that will be called when the object reference count drops to zero and the object is freed.

frame : a frame object
free_func : the function to call when the frame is freed
priv : callback key

schro_frame_clone ()

SchroFrame* schro_frame_clone               (SchroMemoryDomain *domain,
                                             SchroFrame *frame);

Creates a new SchroFrame object with the same dimensions and format as frame. This function leaves the data in the new object uninitialized.

domain :
frame :
Returns : a new SchroFrame object

schro_frame_data_get_codeblock ()

void        schro_frame_data_get_codeblock  (SchroFrameData *dest,
                                             SchroFrameData *src,
                                             int x,
                                             int y,
                                             int horiz_codeblocks,
                                             int vert_codeblocks);

dest :
src :
x :
y :
horiz_codeblocks :
vert_codeblocks :

schro_frame_get_metric ()

int         schro_frame_get_metric          (SchroFrame *frame1,
                                             int x1,
                                             int y1,
                                             SchroFrame *frame2,
                                             int x2,
                                             int y2);

frame1 :
x1 :
y1 :
frame2 :
x2 :
y2 :
Returns :

schro_frame_get_subdata ()

void        schro_frame_get_subdata         (SchroFrame *frame,
                                             SchroFrameData *fd,
                                             int comp,
                                             int x,
                                             int y);

frame :
fd :
comp :
x :
y :

schro_frame_inverse_iwt_transform_cuda ()

void        schro_frame_inverse_iwt_transform_cuda
                                            (SchroFrame *frame,
                                             SchroFrame *transform_frame,
                                             SchroParams *params);

frame :
transform_frame :
params :

schro_frame_new_from_data_UYVY ()

SchroFrame* schro_frame_new_from_data_UYVY  (void *data,
                                             int width,
                                             int height);

Creates a new SchroFrame object with the requested size using the data pointed to by data. The data must be in UYVY format. The data must remain for the lifetime of the SchroFrame object. It is recommended to use schro_frame_set_free_callback() for notification when the data is no longer needed.

data :
width :
height :
Returns : a new SchroFrame object

schro_frame_new_from_data_YV12 ()

SchroFrame* schro_frame_new_from_data_YV12  (void *data,
                                             int width,
                                             int height);

Creates a new SchroFrame object with the requested size using the data pointed to by data. The data must be in YV12 format. The data must remain for the lifetime of the SchroFrame object. It is recommended to use schro_frame_set_free_callback() for notification when the data is no longer needed.

data :
width :
height :
Returns : a new SchroFrame object

schro_frame_convert ()

void        schro_frame_convert             (SchroFrame *dest,
                                             SchroFrame *src);

Copies data from the source frame to the destination frame, converting formats if necessary. Only a few conversions are supported.

dest : destination frame
src : source frame

schro_frame_convert_to_444 ()

SchroFrame* schro_frame_convert_to_444      (SchroFrame *frame);

frame :
Returns :

schro_frame_add ()

void        schro_frame_add                 (SchroFrame *dest,
                                             SchroFrame *src);

Adds data from the source frame to the destination frame. The frames must have the same chroma subsampling, and only a few combinations of bit depths are supported.

dest : destination frame
src : source frame

schro_frame_subtract ()

void        schro_frame_subtract            (SchroFrame *dest,
                                             SchroFrame *src);

Subtracts data from the source frame to the destination frame. The frames must have the same chroma subsampling, and only a few combinations of bit depths are supported.

dest : destination frame
src : source frame

schro_frame_shift_left ()

void        schro_frame_shift_left          (SchroFrame *frame,
                                             int shift);

Shifts each value in frame to the left by shift bits. This operation happens in-place.

frame : frame
shift : number of bits to shift

schro_frame_shift_right ()

void        schro_frame_shift_right         (SchroFrame *frame,
                                             int shift);

Shifts each value in frame to the right by shift bits. This operation happens in-place.

frame : frame
shift : number of bits to shift

schro_frame_edge_extend ()

void        schro_frame_edge_extend         (SchroFrame *frame,
                                             int width,
                                             int height);

Extends the edges of the subpicture defined from 0,0 to width,height to the size of frame.

frame : frame
width : width of subpicture
height : height of subpicture

schro_frame_zero_extend ()

void        schro_frame_zero_extend         (SchroFrame *frame,
                                             int width,
                                             int height);

frame :
width :
height :

schro_frame_iwt_transform ()

void        schro_frame_iwt_transform       (SchroFrame *frame,
                                             SchroParams *params);

Performs an in-place integer wavelet transform on frame. The frame must have a bit depth of 16.

frame : frame
params : transform parameters

schro_frame_inverse_iwt_transform ()

void        schro_frame_inverse_iwt_transform
                                            (SchroFrame *frame,
                                             SchroParams *params);

Performs an in-place inverse integer wavelet transform on frame. The frame must have a bit depth of 16.

frame : frame
params : transform parameters

schro_frame_downsample ()

void        schro_frame_downsample          (SchroFrame *dest,
                                             SchroFrame *src);

dest :
src :

schro_frame_mark ()

void        schro_frame_mark                (SchroFrame *frame,
                                             int value);

frame :
value :

schro_frame_upsample_horiz ()

void        schro_frame_upsample_horiz      (SchroFrame *dest,
                                             SchroFrame *src);

dest :
src :

schro_frame_upsample_vert ()

void        schro_frame_upsample_vert       (SchroFrame *dest,
                                             SchroFrame *src);

dest :
src :

schro_frame_ssim ()

double      schro_frame_ssim                (SchroFrame *a,
                                             SchroFrame *b);

a :
b :
Returns :

schro_frame_mean_squared_error ()

void        schro_frame_mean_squared_error  (SchroFrame *a,
                                             SchroFrame *b,
                                             double *mse);

a :
b :
mse :

schro_frame_md5 ()

void        schro_frame_md5                 (SchroFrame *frame,
                                             uint32_t *state);

frame :
state :

schro_frame_calculate_average_luma ()

double      schro_frame_calculate_average_luma
                                            (SchroFrame *frame);

frame :
Returns :

schro_upsampled_frame_free ()

void        schro_upsampled_frame_free      (SchroUpsampledFrame *df);

df :

schro_upsampled_frame_new ()

SchroUpsampledFrame* schro_upsampled_frame_new
                                            (SchroFrame *frame);

frame :
Returns :

schro_upsampled_frame_upsample ()

void        schro_upsampled_frame_upsample  (SchroUpsampledFrame *df);

df :

schro_upsampled_frame_get_block_fast_precN ()

void        schro_upsampled_frame_get_block_fast_precN
                                            (SchroUpsampledFrame *upframe,
                                             int k,
                                             int x,
                                             int y,
                                             int prec,
                                             SchroFrameData *dest,
                                             SchroFrameData *fd);

upframe :
k :
x :
y :
prec :
dest :
fd :

schro_upsampled_frame_get_block_precN ()

void        schro_upsampled_frame_get_block_precN
                                            (SchroUpsampledFrame *upframe,
                                             int k,
                                             int x,
                                             int y,
                                             int prec,
                                             SchroFrameData *dest);

upframe :
k :
x :
y :
prec :
dest :

schro_upsampled_frame_get_pixel_prec0 ()

int         schro_upsampled_frame_get_pixel_prec0
                                            (SchroUpsampledFrame *upframe,
                                             int k,
                                             int x,
                                             int y);

upframe :
k :
x :
y :
Returns :

schro_upsampled_frame_get_pixel_prec1 ()

int         schro_upsampled_frame_get_pixel_prec1
                                            (SchroUpsampledFrame *upframe,
                                             int k,
                                             int x,
                                             int y);

upframe :
k :
x :
y :
Returns :

schro_upsampled_frame_get_pixel_prec3 ()

int         schro_upsampled_frame_get_pixel_prec3
                                            (SchroUpsampledFrame *upframe,
                                             int k,
                                             int x,
                                             int y);

upframe :
k :
x :
y :
Returns :

schro_upsampled_frame_get_pixel_precN ()

int         schro_upsampled_frame_get_pixel_precN
                                            (SchroUpsampledFrame *upframe,
                                             int k,
                                             int x,
                                             int y,
                                             int mv_precision);

upframe :
k :
x :
y :
mv_precision :
Returns :