struct SchroFrame

struct SchroFrame {
  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];
  int is_upsampled;
};

struct SchroFrameData

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

SchroFrameFreeFunc ()

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

enum SchroFrameFormat

typedef enum {
  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,
  SCHRO_FRAME_FORMAT_AY64 = 0x107
} SchroFrameFormat;

struct SchroUpsampledFrame

struct SchroUpsampledFrame {
  SchroFrame *frames[4];
};

SCHRO_FRAME_FORMAT_DEPTH()

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

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)

SCHRO_FRAME_FORMAT_V_SHIFT()

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

SCHRO_FRAME_IS_PACKED()

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

SCHRO_FRAME_DATA_GET_LINE()

#define SCHRO_FRAME_DATA_GET_LINE(fd,i) (SCHRO_OFFSET((fd)->data,(fd)->stride*(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)))

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)))

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.

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.

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.

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.

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.

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.

schro_frame_ref ()

SchroFrame *        schro_frame_ref                     (SchroFrame *frame);

Increases the reference count 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.

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.

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.

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);

schro_frame_get_metric ()

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

schro_frame_get_subdata ()

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

schro_frame_inverse_iwt_transform_cuda ()

void                schro_frame_inverse_iwt_transform_cuda
                                                        (SchroFrame *frame,
                                                         SchroFrame *transform_frame,
                                                         SchroParams *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.

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.

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.

schro_frame_convert_to_444 ()

SchroFrame *        schro_frame_convert_to_444          (SchroFrame *frame);

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.

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.

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.

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.

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.

schro_frame_zero_extend ()

void                schro_frame_zero_extend             (SchroFrame *frame,
                                                         int width,
                                                         int 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.

schro_frame_downsample ()

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

schro_frame_mark ()

void                schro_frame_mark                    (SchroFrame *frame,
                                                         int value);

schro_frame_upsample_horiz ()

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

schro_frame_upsample_vert ()

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

schro_frame_ssim ()

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

schro_frame_mean_squared_error ()

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

schro_frame_md5 ()

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

schro_frame_calculate_average_luma ()

double              schro_frame_calculate_average_luma  (SchroFrame *frame);

schro_upsampled_frame_free ()

void                schro_upsampled_frame_free          (SchroUpsampledFrame *df);

schro_upsampled_frame_new ()

SchroUpsampledFrame * schro_upsampled_frame_new         (SchroFrame *frame);

schro_upsampled_frame_upsample ()

void                schro_upsampled_frame_upsample      (SchroUpsampledFrame *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);

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);

schro_upsampled_frame_get_pixel_prec0 ()

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

schro_upsampled_frame_get_pixel_prec1 ()

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

schro_upsampled_frame_get_pixel_prec3 ()

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

schro_upsampled_frame_get_pixel_precN ()

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