Pixel Operations

## Pixel Operations Pixel Operations — Operations on pixels |

## Synopsis

    void                oil_argb_paint_u8                   (uint8_t *i_4xn,
                                                             const uint8_t *s1_4,
                                                             const uint8_t *s2_n,
                                                             int n);
    void                oil_ayuv2argb_u8                    (uint8_t *d_4xn,
                                                             const uint8_t *s_4xn,
                                                             int n);
    void                oil_ayuv2uyvy                       (uint32_t *d_n,
                                                             const uint32_t *s_n,
                                                             int n);
    void                oil_ayuv2yuyv                       (uint32_t *d_n,
                                                             const uint32_t *s_n,
                                                             int n);
    void                oil_ayuv2yvyu                       (uint32_t *d_n,
                                                             const uint32_t *s_n,
                                                             int n);
    void                oil_composite_add_argb              (uint32_t *i_n,
                                                             const uint32_t *s1_n,
                                                             int n);
    void                oil_composite_add_argb_const_src    (uint32_t *i_n,
                                                             const uint32_t *s1_1,
                                                             int n);
    void                oil_composite_in_argb               (uint32_t *d_n,
                                                             const uint32_t *s1_n,
                                                             const uint8_t *s2_n,
                                                             int n);
    void                oil_composite_in_argb_const_mask    (uint32_t *d_n,
                                                             const uint32_t *s1_n,
                                                             const uint8_t *s2_1,
                                                             int n);
    void                oil_composite_in_argb_const_src     (uint32_t *d_n,
                                                             const uint32_t *s1_1,
                                                             const uint8_t *s2_n,
                                                             int n);
    void                oil_composite_in_over_argb          (uint32_t *i_n,
                                                             const uint32_t *s1_n,
                                                             const uint8_t *s2_n,
                                                             int n);
    void                oil_composite_in_over_argb_const_mask
                                                            (uint32_t *i_n,
                                                             const uint32_t *s1_n,
                                                             const uint8_t *s2_1,
                                                             int n);
    void                oil_composite_in_over_argb_const_src
                                                            (uint32_t *i_n,
                                                             const uint32_t *s1_1,
                                                             const uint8_t *s2_n,
                                                             int n);
    void                oil_composite_over_argb             (uint32_t *i_n,
                                                             const uint32_t *s1_n,
                                                             int n);
    void                oil_composite_over_argb_const_src   (uint32_t *i_n,
                                                             const uint32_t *s1_1,
                                                             int n);
    void                oil_merge_linear_argb               (uint32_t *d_n,
                                                             const uint32_t *s_n,
                                                             const uint32_t *s2_n,
                                                             const uint32_t *s3_1,
                                                             int n);
    void                oil_resample_linear_argb            (uint32_t *d_n,
                                                             const uint32_t *s_2xn,
                                                             int n,
                                                             uint32_t *i_2);
    void                oil_resample_linear_u8              (uint8_t *d_n,
                                                             const uint8_t *s_2xn,
                                                             int n,
                                                             uint32_t *i_2);
    void                oil_rgb2bgr                         (uint8_t *d_3xn,
                                                             const uint8_t *s_3xn,
                                                             int n);
    void                oil_rgb2rgba                        (uint8_t *d_4xn,
                                                             const uint8_t *s_3xn,
                                                             int n);
    void                oil_yuv2rgbx_sub2_u8                (uint8_t *d_4xn,
                                                             const uint8_t *src1,
                                                             const uint8_t *src2,
                                                             const uint8_t *src3,
                                                             int n);
    void                oil_yuv2rgbx_sub4_u8                (uint8_t *d_4xn,
                                                             const uint8_t *src1,
                                                             const uint8_t *src2,
                                                             const uint8_t *src3,
                                                             int n);
    void                oil_yuv2rgbx_u8                     (uint8_t *d_4xn,
                                                             const uint8_t *src1,
                                                             const uint8_t *src2,
                                                             const uint8_t *src3,
                                                             int n);
    void                oil_uyvy2ayuv                       (uint32_t *d_n,
                                                             const uint32_t *s_n,
                                                             int n);
    void                oil_yuyv2ayuv                       (uint32_t *d_n,
                                                             const uint32_t *s_n,
                                                             int n);
    void                oil_yvyu2ayuv                       (uint32_t *d_n,
                                                             const uint32_t *s_n,
                                                             int n);

## Description

Pixels are 4-element arrays of type uint8_t. The elements, in memory order, represent the alpha, red, green, and blue components respectively. The color components are premultiplied with the alpha component. Liboil functions represent pixels as the type uint32_t.

The compositing operators IN, OVER, and ADD are defined the same as cairo.

## Details

### oil_argb_paint_u8 ()

    void                oil_argb_paint_u8                   (uint8_t *i_4xn,
                                                             const uint8_t *s1_4,
                                                             const uint8_t *s2_n,
                                                             int n);

Composites source color onto in-place array according to the alpha array.

Deprecated.

`i_4xn` : | array
`s1_4` : | source color
`s2_n` : | source alpha array
`n` : | number of elements

### oil_ayuv2argb_u8 ()

    void                oil_ayuv2argb_u8                    (uint8_t *d_4xn,
                                                             const uint8_t *s_4xn,
                                                             int n);

Converts AYUV pixels to ARGB pixels. AYUV pixels are in the JPEG colorspace. Note that this function doesn't follow normal liboil pixel conventions.

(This function should be replaced by one that handles other conversion factors.)

`d_4xn` : |
`s_4xn` : |
`n` : |

### oil_ayuv2uyvy ()

    void                oil_ayuv2uyvy                       (uint32_t *d_n,
                                                             const uint32_t *s_n,
                                                             int n);

Converts pixels in AYUV format to UYVY. Note that only approximately half of the destination array is written. Alpha values are ignored.

`d_n` : |
`s_n` : | n:
`n` : |

### oil_ayuv2yuyv ()

    void                oil_ayuv2yuyv                       (uint32_t *d_n,
                                                             const uint32_t *s_n,
                                                             int n);

Converts pixels in AYUV format to YUYV. Note that only approximately half of the destination array is written. Alpha values are ignored.

`d_n` : |
`s_n` : | n:
`n` : |

### oil_ayuv2yvyu ()

    void                oil_ayuv2yvyu                       (uint32_t *d_n,
                                                             const uint32_t *s_n,
                                                             int n);

Converts pixels in AYUV format to YVYU. Note that only approximately half of the destination array is written. Alpha values are ignored.

`d_n` : |
`s_n` : | n:
`n` : |

### oil_composite_add_argb ()

    void                oil_composite_add_argb              (uint32_t *i_n,
                                                             const uint32_t *s1_n,
                                                             int n);

Performs the compositing operation DEST = SRC ADD DEST.

`i_n` : | DEST
`s1_n` : | SRC
`n` : | number of elements

### oil_composite_add_argb_const_src ()

    void                oil_composite_add_argb_const_src    (uint32_t *i_n,
                                                             const uint32_t *s1_1,
                                                             int n);

Performs the compositing operation DEST = SRC ADD DEST, for a constant SRC.

`i_n` : | DEST
`s1_1` : | SRC
`n` : | number of elements

### oil_composite_in_argb ()

    void                oil_composite_in_argb               (uint32_t *d_n,
                                                             const uint32_t *s1_n,
                                                             const uint8_t *s2_n,
                                                             int n);

Performs the compositing operation DEST = SRC IN MASK.

`d_n` : | DEST
`s1_n` : | SRC
`s2_n` : | MASK
`n` : | number of elements

### oil_composite_in_argb_const_mask ()

    void                oil_composite_in_argb_const_mask    (uint32_t *d_n,
                                                             const uint32_t *s1_n,
                                                             const uint8_t *s2_1,
                                                             int n);

Performs the compositing operation DEST = SRC IN MASK, for a constant MASK.

`d_n` : | DEST
`s1_n` : | SRC
`s2_1` : | MASK
`n` : | number of elements

### oil_composite_in_argb_const_src ()

    void                oil_composite_in_argb_const_src     (uint32_t *d_n,
                                                             const uint32_t *s1_1,
                                                             const uint8_t *s2_n,
                                                             int n);

Performs the compositing operation DEST = SRC IN MASK, for a constant SRC.

`d_n` : | DEST
`s1_1` : | SRC
`s2_n` : | MASK
`n` : | number of elements

### oil_composite_in_over_argb ()

    void                oil_composite_in_over_argb          (uint32_t *i_n,
                                                             const uint32_t *s1_n,
                                                             const uint8_t *s2_n,
                                                             int n);

Performs the compositing operation DEST = (SRC IN MASK) OVER DEST.

`i_n` : | DEST
`s1_n` : | SRC
`s2_n` : | MASK
`n` : | number of elements

### oil_composite_in_over_argb_const_mask ()

    void                oil_composite_in_over_argb_const_mask
                                                            (uint32_t *i_n,
                                                             const uint32_t *s1_n,
                                                             const uint8_t *s2_1,
                                                             int n);

Performs the compositing operation DEST = (SRC IN MASK) OVER DEST, for a constant MASK.

`i_n` : | DEST
`s1_n` : | SRC
`s2_1` : | MASK
`n` : | number of elements

### oil_composite_in_over_argb_const_src ()

    void                oil_composite_in_over_argb_const_src
                                                            (uint32_t *i_n,
                                                             const uint32_t *s1_1,
                                                             const uint8_t *s2_n,
                                                             int n);

Performs the compositing operation DEST = (SRC IN MASK) OVER DEST, for a constant SRC.

`i_n` : | DEST
`s1_1` : | SRC
`s2_n` : | MASK
`n` : | number of elements

### oil_composite_over_argb ()

    void                oil_composite_over_argb             (uint32_t *i_n,
                                                             const uint32_t *s1_n,
                                                             int n);

Performs the compositing operation DEST = SRC OVER DEST.

`i_n` : | DEST
`s1_n` : | SRC
`n` : | number of elements

### oil_composite_over_argb_const_src ()

    void                oil_composite_over_argb_const_src   (uint32_t *i_n,
                                                             const uint32_t *s1_1,
                                                             int n);

Performs the compositing operation DEST = SRC OVER DEST, for a constant SRC.

`i_n` : | DEST
`s1_1` : | SRC
`n` : | number of elements

### oil_merge_linear_argb ()

    void                oil_merge_linear_argb               (uint32_t *d_n,
                                                             const uint32_t *s_n,
                                                             const uint32_t *s2_n,
                                                             const uint32_t *s3_1,
                                                             int n);

Linearly interpolate the `s_n` and `s2_n` arrays using the scale factor in `s3_1`. The value `s3_1` must be in the range [0, 256] A value of 0 indicates weights of 1.0 and 0.0 for the s_n and s2_n arrays respectively. A value of 256 indicates weights of 0.0 and 1.0 respectively.

This function is not intended for alpha blending; use one of the compositing functions instead.

`d_n` : |
`s_n` : |
`s2_n` : |
`s3_1` : |
`n` : |

### oil_resample_linear_argb ()

    void                oil_resample_linear_argb            (uint32_t *d_n,
                                                             const uint32_t *s_2xn,
                                                             int n,
                                                             uint32_t *i_2);

Linearly resamples a row of pixels. FIXME.

`d_n` : |
`s_2xn` : |
`n` : |
`i_2` : |

### oil_resample_linear_u8 ()

    void                oil_resample_linear_u8              (uint8_t *d_n,
                                                             const uint8_t *s_2xn,
                                                             int n,
                                                             uint32_t *i_2);

Linearly resamples a row of pixels. FIXME.

`d_n` : |
`s_2xn` : |
`n` : |
`i_2` : |

### oil_rgb2bgr ()

    void                oil_rgb2bgr                         (uint8_t *d_3xn,
                                                             const uint8_t *s_3xn,
                                                             int n);

Converts arrays of 24-bit RGB pixels from RGBRGBRGB ordering to BGRBGRBGR ordering (and vice-versa).

`d_3xn` : |
`s_3xn` : |
`n` : |

### oil_rgb2rgba ()

    void                oil_rgb2rgba                        (uint8_t *d_4xn,
                                                             const uint8_t *s_3xn,
                                                             int n);

Converts arrays of 24-bit RGB pixels in RGBRGBRGB memory order to 32-bit RGBA pixels in RGBARGBA order.

`d_4xn` : |
`s_3xn` : |
`n` : |

### oil_yuv2rgbx_sub2_u8 ()

    void                oil_yuv2rgbx_sub2_u8                (uint8_t *d_4xn,
                                                             const uint8_t *src1,
                                                             const uint8_t *src2,
                                                             const uint8_t *src3,
                                                             int n);

Converts YUV pixels to RGB pixels. Each YUV component is in a separate source array, and are combined and converted to RGB. The U and V arrays are subsampled by a factor of 2, so only half of each array is used.

This function should be replaced by one that makes sense.

`d_4xn` : |
`src1` : | Y component
`src2` : | U component
`src3` : | V component
`n` : |

### oil_yuv2rgbx_sub4_u8 ()

    void                oil_yuv2rgbx_sub4_u8                (uint8_t *d_4xn,
                                                             const uint8_t *src1,
                                                             const uint8_t *src2,
                                                             const uint8_t *src3,
                                                             int n);

Converts YUV pixels to RGB pixels. Each YUV component is in a separate source array, and are combined and converted to RGB. The U and V arrays are subsampled by a factor of 4, so only a quarter of each array is used.

This function should be replaced by one that makes sense.

`d_4xn` : |
`src1` : | Y component
`src2` : | U component
`src3` : | V component
`n` : |

### oil_yuv2rgbx_u8 ()

    void                oil_yuv2rgbx_u8                     (uint8_t *d_4xn,
                                                             const uint8_t *src1,
                                                             const uint8_t *src2,
                                                             const uint8_t *src3,
                                                             int n);

Converts YUV pixels to RGB pixels. Each YUV component is in a separate source array, and are combined and converted to RGB.

This function should be replaced by one that makes sense.

`d_4xn` : |
`src1` : | Y component
`src2` : | U component
`src3` : | V component
`n` : |

### oil_uyvy2ayuv ()

    void                oil_uyvy2ayuv                       (uint32_t *d_n,
                                                             const uint32_t *s_n,
                                                             int n);

Converts pixels in UYVY format to AYUV. Note that only approximately half of the source array is used. Alpha values are set to 255.

`d_n` : |
`s_n` : | n:
`n` : |

### oil_yuyv2ayuv ()

    void                oil_yuyv2ayuv                       (uint32_t *d_n,
                                                             const uint32_t *s_n,
                                                             int n);

Converts pixels in YUYV format to AYUV. Note that only approximately half of the source array is used. Alpha values are set to 255.

`d_n` : |
`s_n` : | n:
`n` : |

### oil_yvyu2ayuv ()

    void                oil_yvyu2ayuv                       (uint32_t *d_n,
                                                             const uint32_t *s_n,
                                                             int n);

Converts pixels in YVYU format to AYUV. Note that only approximately half of the source array is used. Alpha values are set to 255.

`d_n` : |
`s_n` : | n:
`n` : |