switch_core_video.h File Reference

video includes header More...

#include <switch.h>

Include dependency graph for switch_core_video.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	switch_yuv_color_s
struct	switch_rgb_color_s
struct	switch_hsl_color_s
struct	switch_lab_color_t
struct	switch_xyz_color_t
struct	switch_image_rect
	Representation of a rectangle on a surface. More...
struct	switch_png_s

Macros
#define	CHROMAKEY_MAX_MASK   25

Typedefs
typedef struct switch_yuv_color_s	switch_yuv_color_t
typedef struct switch_rgb_color_s	switch_rgb_color_t
typedef struct switch_hsl_color_s	switch_hsl_color_t
typedef struct switch_image_rect	switch_image_rect_t
	Representation of a rectangle on a surface. More...
typedef struct switch_png_opaque_s	switch_png_opaque_t
typedef struct switch_png_s	switch_png_t

Enumerations
enum	switch_core_video_filter_t {   SCV_FILTER_GRAY_FG = (1 << 0), SCV_FILTER_GRAY_BG = (1 << 1), SCV_FILTER_SEPIA_FG = (1 << 2), SCV_FILTER_SEPIA_BG = (1 << 3),   SCV_FILTER_8BIT_FG = (1 << 4) }
enum	switch_shade_t {   SWITCH_SHADE_NONE = 0, SWITCH_SHADE_RED, SWITCH_SHADE_GREEN, SWITCH_SHADE_BLUE,   SWITCH_SHADE_AUTO }
enum	switch_img_position_t {   POS_LEFT_TOP = 0, POS_LEFT_MID, POS_LEFT_BOT, POS_CENTER_TOP,   POS_CENTER_MID, POS_CENTER_BOT, POS_RIGHT_TOP, POS_RIGHT_MID,   POS_RIGHT_BOT, POS_NONE }
enum	switch_img_fit_t {   SWITCH_FIT_SIZE, SWITCH_FIT_SCALE, SWITCH_FIT_SIZE_AND_SCALE, SWITCH_FIT_NECESSARY,   SWITCH_FIT_NONE }
enum	switch_convert_fmt_t { SWITCH_CONVERT_FMT_YUYV = 0 }
enum	switch_image_rotation_mode_t { SRM_NONE = 0, SRM_90 = 90, SRM_180 = 180, SRM_270 = 270 }

Functions
switch_image_t *	switch_img_alloc (switch_image_t *img, switch_img_fmt_t fmt, unsigned int d_w, unsigned int d_h, unsigned int align)
	Open a descriptor, allocating storage for the underlying image. More...
switch_image_t *	switch_img_wrap (switch_image_t *img, switch_img_fmt_t fmt, unsigned int d_w, unsigned int d_h, unsigned int align, unsigned char *img_data)
	Open a descriptor, using existing storage for the underlying image. More...
int	switch_img_set_rect (switch_image_t *img, unsigned int x, unsigned int y, unsigned int w, unsigned int h)
	Set the rectangle identifying the displayed portion of the image. More...
void	switch_img_patch (switch_image_t *IMG, switch_image_t *img, int x, int y)
	patch a small img to a big IMG at position x,y More...
void	switch_img_attenuate (switch_image_t *img)
void	switch_img_patch_rgb (switch_image_t *IMG, switch_image_t *img, int x, int y, switch_bool_t noalpha)
	patch a small img to a big IMG at position x,y More...
void	switch_img_patch_rect (switch_image_t *IMG, int X, int Y, switch_image_t *img, uint32_t x, uint32_t y, uint32_t w, uint32_t h)
	patch part of a small img (x,y,w,h) to a big IMG at position X,Y More...
void	switch_img_copy (switch_image_t *img, switch_image_t **new_img)
	Copy image to a new image. More...
void	switch_img_rotate_copy (switch_image_t *img, switch_image_t **new_img, switch_image_rotation_mode_t mode)
void	switch_img_rotate (switch_image_t **img, switch_image_rotation_mode_t mode)
	Flip the image vertically (top for bottom) More...
void	switch_img_free (switch_image_t **img)
	Close an image descriptor. More...
void	switch_img_draw_text (switch_image_t *IMG, int x, int y, switch_rgb_color_t color, uint16_t font_size, char *text)
void	switch_img_add_text (void *buffer, int w, int x, int y, char *s)
switch_image_t *	switch_img_copy_rect (switch_image_t *img, uint32_t x, uint32_t y, uint32_t w, uint32_t h)
	Copy part of an image to a new image. More...
void	switch_img_fill (switch_image_t *img, int x, int y, int w, int h, switch_rgb_color_t *color)
	Fill image with color. More...
void	switch_img_8bit (switch_image_t *img)
void	switch_img_gray (switch_image_t *img, int x, int y, int w, int h)
void	switch_img_sepia (switch_image_t *img, int x, int y, int w, int h)
void	switch_img_fill_noalpha (switch_image_t *img, int x, int y, int w, int h, switch_rgb_color_t *color)
void	switch_color_set_rgb (switch_rgb_color_t *color, const char *color_str)
	Set RGB color with a string. More...
void	switch_color_set_yuv (switch_yuv_color_t *color, const char *color_str)
	Set YUV color with a string. More...
switch_status_t	switch_img_txt_handle_create (switch_img_txt_handle_t **handleP, const char *font_family, const char *font_color, const char *bgcolor, uint16_t font_size, double angle, switch_memory_pool_t *pool)
	Created a text handle. More...
void	switch_img_txt_handle_destroy (switch_img_txt_handle_t **handleP)
	Free a text handle. More...
uint32_t	switch_img_txt_handle_render (switch_img_txt_handle_t *handle, switch_image_t *img, int x, int y, const char *text, const char *font_family, const char *font_color, const char *bgcolor, uint16_t font_size, double angle)
	Render text to an img. More...
void	switch_img_patch_hole (switch_image_t *IMG, switch_image_t *img, int x, int y, switch_image_rect_t *rect)
switch_status_t	switch_png_patch_img (switch_png_t *use_png, switch_image_t *img, int x, int y)
switch_image_t *	switch_img_read_png (const char *file_name, switch_img_fmt_t img_fmt)
switch_image_t *	switch_img_read_png_from_memory (void *mem, size_t size, switch_img_fmt_t img_fmt)
switch_status_t	switch_img_write_png (switch_image_t *img, char *file_name)
switch_status_t	switch_png_open (switch_png_t **pngP, const char *file_name)
void	switch_png_free (switch_png_t **pngP)
switch_status_t	switch_img_data_url_png (switch_image_t *img, char **urlP)
switch_status_t	switch_img_data_url (switch_image_t *img, char **urlP, const char *type, int quality)
switch_image_t *	switch_img_read_from_file (const char *file_name, switch_img_fmt_t img_fmt)
	Read an image file to switch_image_t. More...
switch_status_t	switch_img_write_to_file (switch_image_t *img, const char *file_name, int quality)
	Write an image file, supported formats png,jpg,bmp,tga,hdr. More...
void	switch_img_overlay (switch_image_t *IMG, switch_image_t *img, int x, int y, uint8_t percent)
	put a small img over a big IMG at position x,y, with alpha transparency More...
switch_status_t	switch_img_mirror (switch_image_t *src, switch_image_t **destP)
switch_status_t	switch_img_scale (switch_image_t *src, switch_image_t **destP, int width, int height)
switch_status_t	switch_img_fit (switch_image_t **srcP, int width, int height, switch_img_fit_t fit)
void	switch_img_calc_fit (switch_image_t *src, int width, int height, int *new_wP, int *new_hP)
switch_img_position_t	parse_img_position (const char *name)
switch_img_fit_t	parse_img_fit (const char *name)
void	switch_img_find_position (switch_img_position_t pos, int sw, int sh, int iw, int ih, int *xP, int *yP)
switch_status_t	switch_img_to_raw (switch_image_t *src, void *dest, int stride, switch_img_fmt_t fmt)
	convert img to raw format More...
switch_status_t	switch_img_from_raw (switch_image_t **destP, void *src, switch_img_fmt_t fmt, int width, int height)
	convert raw memory to switch_img_t More...
switch_image_t *	switch_img_write_text_img (int w, int h, switch_bool_t full, const char *text)
switch_image_t *	switch_img_read_file (const char *file_name)
switch_status_t	switch_img_letterbox (switch_image_t *img, switch_image_t **imgP, int width, int height, const char *color)
switch_bool_t	switch_core_has_video (void)
switch_status_t	switch_I420_copy (const uint8_t *src_y, int src_stride_y, const uint8_t *src_u, int src_stride_u, const uint8_t *src_v, int src_stride_v, uint8_t *dst_y, int dst_stride_y, uint8_t *dst_u, int dst_stride_u, uint8_t *dst_v, int dst_stride_v, int width, int height)
	I420 to I420 Copy. More...
switch_status_t	switch_I420_copy2 (uint8_t *src_planes[], int src_stride[], uint8_t *dst_planes[], int dst_stride[], int width, int height)
switch_status_t	switch_I420ToARGB (const uint8_t *src_y, int src_stride_y, const uint8_t *src_u, int src_stride_u, const uint8_t *src_v, int src_stride_v, uint8_t *dst_argb, int dst_stride_argb, int width, int height)
	I420 to ARGB Convertion. More...
switch_status_t	switch_RGBAToARGB (const uint8_t *src_frame, int src_stride_frame, uint8_t *dst_argb, int dst_stride_argb, int width, int height)
switch_status_t	switch_ABGRToARGB (const uint8_t *src_frame, int src_stride_frame, uint8_t *dst_argb, int dst_stride_argb, int width, int height)
switch_status_t	switch_ARGBToARGB (const uint8_t *src_frame, int src_stride_frame, uint8_t *dst_argb, int dst_stride_argb, int width, int height)
void	switch_img_chromakey (switch_image_t *img, switch_rgb_color_t *mask, int threshold)
	chromakey an img, img must be RGBA and return modified img More...
switch_status_t	switch_chromakey_clear_colors (switch_chromakey_t *ck)
switch_status_t	switch_chromakey_autocolor (switch_chromakey_t *ck, switch_shade_t autocolor, uint32_t threshold)
switch_status_t	switch_chromakey_add_color (switch_chromakey_t *ck, switch_rgb_color_t *color, uint32_t threshold)
switch_status_t	switch_chromakey_destroy (switch_chromakey_t **ckP)
switch_status_t	switch_chromakey_create (switch_chromakey_t **ckP)
void	switch_chromakey_set_default_threshold (switch_chromakey_t *ck, uint32_t threshold)
void	switch_chromakey_process (switch_chromakey_t *ck, switch_image_t *img)
switch_image_t *	switch_chromakey_cache_image (switch_chromakey_t *ck)
switch_shade_t	switch_chromakey_str2shade (switch_chromakey_t *ck, const char *shade_name)
void	switch_core_video_parse_filter_string (switch_core_video_filter_t *filters, const char *filter_str)

Detailed Description

video includes header

The things powered by libvpx are renamed into the switch_ namespace to provide a cleaner look to things and helps me to document what parts of video I am using I'd like to take this opportunity to thank libvpx for all the awesome stuff it does and for making my life much easier.

Definition in file switch_core_video.h.

Macro Definition Documentation

CHROMAKEY_MAX_MASK

#define CHROMAKEY_MAX_MASK   25

Definition at line 47 of file switch_core_video.h.

Referenced by switch_chromakey_add_color(), and switch_chromakey_clear_colors().

Typedef Documentation

switch_hsl_color_t

typedef struct switch_hsl_color_s switch_hsl_color_t

switch_image_rect_t

typedef struct switch_image_rect switch_image_rect_t

Representation of a rectangle on a surface.

switch_png_opaque_t

typedef struct switch_png_opaque_s switch_png_opaque_t

Definition at line 140 of file switch_core_video.h.

switch_png_t

typedef struct switch_png_s switch_png_t

switch_rgb_color_t

typedef struct switch_rgb_color_s switch_rgb_color_t

switch_yuv_color_t

typedef struct switch_yuv_color_s switch_yuv_color_t

Enumeration Type Documentation

switch_convert_fmt_t

enum switch_convert_fmt_t

Enumerator
SWITCH_CONVERT_FMT_YUYV

Definition at line 135 of file switch_core_video.h.

             {
        SWITCH_CONVERT_FMT_YUYV = 0
} switch_convert_fmt_t;

switch_core_video_filter_t

enum switch_core_video_filter_t

Enumerator
SCV_FILTER_GRAY_FG
SCV_FILTER_GRAY_BG
SCV_FILTER_SEPIA_FG
SCV_FILTER_SEPIA_BG
SCV_FILTER_8BIT_FG

Definition at line 49 of file switch_core_video.h.

             {
        SCV_FILTER_GRAY_FG = (1 << 0),
        SCV_FILTER_GRAY_BG = (1 << 1),
        SCV_FILTER_SEPIA_FG = (1 << 2),
        SCV_FILTER_SEPIA_BG = (1 << 3),
        SCV_FILTER_8BIT_FG = (1 << 4)
} switch_core_video_filter_t;

switch_image_rotation_mode_t

enum switch_image_rotation_mode_t

Enumerator
SRM_NONE
SRM_90
SRM_180
SRM_270

Definition at line 147 of file switch_core_video.h.

             {
        SRM_NONE = 0,  // No rotation.
        SRM_90 = 90,  // Rotate 90 degrees clockwise.
        SRM_180 = 180,  // Rotate 180 degrees.
        SRM_270 = 270,  // Rotate 270 degrees clockwise.
} switch_image_rotation_mode_t;

switch_img_fit_t

enum switch_img_fit_t

Enumerator
SWITCH_FIT_SIZE
SWITCH_FIT_SCALE
SWITCH_FIT_SIZE_AND_SCALE
SWITCH_FIT_NECESSARY
SWITCH_FIT_NONE

Definition at line 79 of file switch_core_video.h.

             {
        SWITCH_FIT_SIZE,
        SWITCH_FIT_SCALE,
        SWITCH_FIT_SIZE_AND_SCALE,
        SWITCH_FIT_NECESSARY,
        SWITCH_FIT_NONE
} switch_img_fit_t;

switch_img_position_t

enum switch_img_position_t

Enumerator
POS_LEFT_TOP
POS_LEFT_MID
POS_LEFT_BOT
POS_CENTER_TOP
POS_CENTER_MID
POS_CENTER_BOT
POS_RIGHT_TOP
POS_RIGHT_MID
POS_RIGHT_BOT
POS_NONE

Definition at line 66 of file switch_core_video.h.

             {
        POS_LEFT_TOP = 0,
        POS_LEFT_MID,
        POS_LEFT_BOT,
        POS_CENTER_TOP,
        POS_CENTER_MID,
        POS_CENTER_BOT,
        POS_RIGHT_TOP,
        POS_RIGHT_MID,
        POS_RIGHT_BOT,
        POS_NONE
} switch_img_position_t;

switch_shade_t

enum switch_shade_t

Enumerator
SWITCH_SHADE_NONE
SWITCH_SHADE_RED
SWITCH_SHADE_GREEN
SWITCH_SHADE_BLUE
SWITCH_SHADE_AUTO

Definition at line 58 of file switch_core_video.h.

             {
        SWITCH_SHADE_NONE = 0,
        SWITCH_SHADE_RED,
        SWITCH_SHADE_GREEN,
        SWITCH_SHADE_BLUE,
        SWITCH_SHADE_AUTO
} switch_shade_t;

Function Documentation

parse_img_fit()

switch_img_fit_t parse_img_fit

(

const char *

name

)

Definition at line 162 of file switch_core_video.c.

References fit_el::fit, fit_el::name, switch_assert, and SWITCH_FIT_SIZE.

{
        switch_img_fit_t r = SWITCH_FIT_SIZE;
        int i;

        switch_assert(name);

        for(i = 0; IMG_FIT_TABLE[i].name; i++) {
                if (!strcasecmp(IMG_FIT_TABLE[i].name, name)) {
                        r = IMG_FIT_TABLE[i].fit;
                        break;
                }
        }

        return r;
}

parse_img_position()

switch_img_position_t parse_img_position

(

const char *

name

)

Definition at line 129 of file switch_core_video.c.

References pos_el::name, pos_el::pos, POS_NONE, and switch_assert.

{
        switch_img_position_t r = POS_NONE;
        int i;

        switch_assert(name);

        for(i = 0; POS_TABLE[i].name; i++) {
                if (!strcasecmp(POS_TABLE[i].name, name)) {
                        r = POS_TABLE[i].pos;
                        break;
                }
        }

        return r;
}

switch_ABGRToARGB()

switch_status_t switch_ABGRToARGB	(	const uint8_t *	src_frame,
		int	src_stride_frame,
		uint8_t *	dst_argb,
		int	dst_stride_argb,
		int	width,
		int	height
	)

Definition at line 3847 of file switch_core_video.c.

References SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
#ifdef SWITCH_HAVE_YUV
        int ret = ABGRToARGB(src_frame, src_stride_frame, dst_argb, dst_stride_argb, width, height);

        return ret == 0 ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
#else
        return SWITCH_STATUS_FALSE;
#endif
}

switch_ARGBToARGB()

switch_status_t switch_ARGBToARGB	(	const uint8_t *	src_frame,
		int	src_stride_frame,
		uint8_t *	dst_argb,
		int	dst_stride_argb,
		int	width,
		int	height
	)

Definition at line 3860 of file switch_core_video.c.

References SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
#ifdef SWITCH_HAVE_YUV
        int ret = ARGBToARGB(src_frame, src_stride_frame, dst_argb, dst_stride_argb, width, height);

        return ret == 0 ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
#else
        return SWITCH_STATUS_FALSE;
#endif
}

switch_chromakey_add_color()

switch_status_t switch_chromakey_add_color	(	switch_chromakey_t *	ck,
		switch_rgb_color_t *	color,
		uint32_t	threshold
	)

Definition at line 1054 of file switch_core_video.c.

References switch_chromakey_s::auto_color, switch_rgb_color_s::b, CHROMAKEY_MAX_MASK, switch_rgb_color_s::g, switch_chromakey_s::mask, switch_chromakey_s::mask_len, switch_rgb_color_s::r, switch_assert, SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_chromakey_s::thresholds.

Referenced by switch_chromakey_process().

{
        switch_assert(ck);

        if (ck->mask_len == CHROMAKEY_MAX_MASK) {
                return SWITCH_STATUS_FALSE;
        }

        ck->mask[ck->mask_len] = *color;
        ck->thresholds[ck->mask_len] = threshold * threshold;
        ck->mask_len++;

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Adding color %d:%d:%d #%.2x%.2x%.2x\n",
                                          ck->auto_color.r, ck->auto_color.g, ck->auto_color.b, ck->auto_color.r, ck->auto_color.g, ck->auto_color.b);

        return SWITCH_STATUS_SUCCESS;
}

switch_chromakey_autocolor()

switch_status_t switch_chromakey_autocolor	(	switch_chromakey_t *	ck,
		switch_shade_t	autocolor,
		uint32_t	threshold
	)

Definition at line 1039 of file switch_core_video.c.

References switch_chromakey_s::auto_color, switch_chromakey_s::autocolor, switch_chromakey_s::cache_img, switch_chromakey_s::dft_thresh, switch_chromakey_s::dft_thresh_squared, memset(), switch_chromakey_s::no_cache, switch_assert, switch_chromakey_clear_colors(), switch_img_free(), and SWITCH_STATUS_SUCCESS.

{
        switch_assert(ck);

        switch_chromakey_clear_colors(ck);
        ck->autocolor = autocolor;
        ck->dft_thresh = threshold;
        ck->dft_thresh_squared = threshold * threshold;
        switch_img_free(&ck->cache_img);
        ck->no_cache = 90;
        memset(&ck->auto_color, 0, sizeof(ck->auto_color));

        return SWITCH_STATUS_SUCCESS;
}

switch_chromakey_cache_image()

switch_image_t* switch_chromakey_cache_image

(

switch_chromakey_t *

ck

)

Definition at line 1103 of file switch_core_video.c.

References switch_chromakey_s::cache_img, and switch_assert.

{
        switch_assert(ck);

        return ck->cache_img;
}

switch_chromakey_clear_colors()

switch_status_t switch_chromakey_clear_colors

(

switch_chromakey_t *

ck

)

Definition at line 1026 of file switch_core_video.c.

References switch_chromakey_s::autocolor, CHROMAKEY_MAX_MASK, switch_chromakey_s::mask, switch_chromakey_s::mask_len, memset(), switch_chromakey_s::no_cache, switch_assert, SWITCH_SHADE_NONE, SWITCH_STATUS_SUCCESS, and switch_chromakey_s::thresholds.

Referenced by switch_chromakey_autocolor().

{
        switch_assert(ck);

        ck->autocolor = SWITCH_SHADE_NONE;
        ck->mask_len = 0;
        memset(ck->mask, 0, sizeof(ck->mask[0]) * CHROMAKEY_MAX_MASK);
        memset(ck->thresholds, 0, sizeof(ck->thresholds[0]) * CHROMAKEY_MAX_MASK);
        ck->no_cache = 1;

        return SWITCH_STATUS_SUCCESS;
}

switch_chromakey_create()

switch_status_t switch_chromakey_create

(

switch_chromakey_t **

ckP

)

Definition at line 1089 of file switch_core_video.c.

References switch_assert, SWITCH_STATUS_SUCCESS, and switch_zmalloc.

{
        switch_chromakey_t *ck;

        switch_assert(ckP);

        switch_zmalloc(ck, sizeof(*ck));

        *ckP = ck;

        return SWITCH_STATUS_SUCCESS;

}

switch_chromakey_destroy()

switch_status_t switch_chromakey_destroy

(

switch_chromakey_t **

ckP

)

Definition at line 1072 of file switch_core_video.c.

References switch_chromakey_s::cache_img, switch_assert, switch_img_free(), and SWITCH_STATUS_SUCCESS.

{
        switch_chromakey_t *ck;

        switch_assert(ckP);

        ck = *ckP;
        *ckP = NULL;

        if (ck) {
                switch_img_free(&ck->cache_img);
                free(ck);
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_chromakey_process()

void switch_chromakey_process	(	switch_chromakey_t *	ck,
		switch_image_t *	img
	)

Definition at line 1194 of file switch_core_video.c.

References switch_rgb_color_s::a, switch_chromakey_s::auto_color, switch_chromakey_s::autocolor, switch_rgb_color_s::b, b, switch_chromakey_s::bb, switch_chromakey_s::cache_img, switch_chromakey_s::color_count, vpx_image::d_h, vpx_image::d_w, switch_chromakey_s::dft_thresh, vpx_image::fmt, switch_chromakey_s::frames_read, switch_rgb_color_s::g, get_dom(), switch_chromakey_s::gg, switch_chromakey_s::mask, switch_chromakey_s::mask_len, switch_chromakey_s::no_cache, vpx_image::planes, switch_rgb_color_s::r, switch_chromakey_s::rr, switch_assert, switch_chromakey_add_color(), switch_color_distance_cheap(), switch_color_distance_literal(), switch_color_distance_multi(), switch_color_dom_cmp(), switch_img_copy(), SWITCH_IMG_FMT_ARGB, switch_img_free(), SWITCH_PLANE_PACKED, SWITCH_SHADE_AUTO, and switch_chromakey_s::thresholds.

{
        uint8_t *pixel, *last_pixel = NULL, *cache_pixel = NULL, *end_pixel = NULL;
        int last_hits = 0;
        switch_image_t *cache_img;
        int same = 0;
        int same_same = 0;

#ifdef DEBUG_CHROMA
        int other_img_cached = 0, color_cached = 0, checked = 0, hit_total = 0, total_pixel = 0, delta_hits = 0;
#endif

        switch_assert(ck);
        switch_assert(img);

        if (img->fmt != SWITCH_IMG_FMT_ARGB) return;

        pixel = img->planes[SWITCH_PLANE_PACKED];

        cache_img = ck->cache_img;
        ck->cache_img = NULL;

        ck->frames_read++;

        if ((ck->frames_read % 300) == 0) {
                ck->no_cache = 2;
        }

        if (cache_img && (cache_img->d_w != img->d_w || cache_img->d_h != img->d_h)) {
                switch_img_free(&cache_img);
        }

        if (cache_img) {
                cache_pixel = cache_img->planes[SWITCH_PLANE_PACKED];
        }

        end_pixel = (img->planes[SWITCH_PLANE_PACKED] + img->d_w * img->d_h * 4);

        if (ck->autocolor) {
                ck->color_count = 0;
                ck->rr = ck->gg = ck->bb = 0;
        }

        for (; pixel < end_pixel; pixel += 4) {
                switch_rgb_color_t *color = (switch_rgb_color_t *)pixel;
                switch_rgb_color_t *last_color = (switch_rgb_color_t *)last_pixel;
                int hits = 0;



#ifdef DEBUG_CHROMA
                total_pixel++;
#endif

                if (!ck->no_cache && cache_img && cache_pixel) {
                        switch_rgb_color_t *cache_color = (switch_rgb_color_t *)cache_pixel;
                                
                        if (switch_color_distance_cheap(color, cache_color) < 5) {
#ifdef DEBUG_CHROMA
                                other_img_cached++;
#endif
                                color->a = cache_color->a;
                                goto end;
                        }
                }


                if (last_color) {
                        if (switch_color_distance_cheap(color, last_color) < 5) {

                                hits = last_hits;
#ifdef DEBUG_CHROMA
                                color_cached++;
#endif

                                same++;
                        } else {
                                same = 0;
                        }
                } 

                if (!hits) {

                        if (ck->autocolor) {
                                int dom, a, b;

                                get_dom(ck->autocolor, color, &dom, &a, &b);

                                if (ck->autocolor != SWITCH_SHADE_AUTO) {
                                        //printf("WTF %d\n", ck->dft_thresh);

                                        int tol = ck->dft_thresh;
                                        int a_tol = tol/6;
                                        int b_tol = tol/6;

                                        if (dom > a && dom > b && dom > tol) {
                                                if (dom - a > a_tol && dom - b > b_tol) {
                                                        hits = 1;
                                                }
                                        }
                                }
                        }

                        if (!hits && ck->mask_len) {
                                hits = switch_color_distance_multi(color, ck->mask, ck->mask_len, ck->thresholds);
                        }


#ifdef DEBUG_CHROMA
                        checked++;
#endif
                }

        end:

                if (same > 100 && last_color && switch_color_dom_cmp(color, last_color)) {
                        same_same++;
                } else {
                        same_same = 0;
                }

                if (!hits && ck->autocolor == SWITCH_SHADE_AUTO && (same > 300 || same_same > 50) && ck->no_cache) {
                        ck->color_count++;
                        ck->rr += color->r;
                        ck->gg += color->g;
                        ck->bb += color->b;
                }

                if (cache_pixel) {
                        cache_pixel += 4;
                }

                if (hits) {
#ifdef DEBUG_CHROMA
                        hit_total++;
#endif
                        color->a = 0;
                }
        
                last_pixel = pixel;
                last_hits = hits;
        }

        if (ck->color_count > 1000) {
                switch_rgb_color_t *last_color = NULL;
                int skip = 0;
                int dom, a, b;

                ck->auto_color.r = ck->rr / ck->color_count;
                ck->auto_color.g = ck->gg / ck->color_count;
                ck->auto_color.b = ck->bb / ck->color_count;

                if (ck->mask_len) {
                        int i = 0;

                        for (i = 0; i < ck->mask_len; i++) {
                                last_color = &ck->mask[i];

                                get_dom(ck->autocolor, &ck->auto_color, &dom, &a, &b);

                                if (switch_color_distance_literal(&ck->auto_color, last_color, 10) || !switch_color_dom_cmp(&ck->auto_color, last_color) || (dom - a < 50 || dom - b < 50)) {
                                        skip = 1;
                                        break;
                                }
                        }
                }

                if (!ck->mask_len || !skip) {
                        switch_chromakey_add_color(ck, &ck->auto_color, ck->dft_thresh);
                }

        }

        if (ck->no_cache > 0 && ck->mask_len) {
                ck->no_cache--;
        }


#ifdef DEBUG_CHROMA
        printf("total %d: other img cache %d color cache %d Checked %d Hit Total %d Delta hits: %d\n", total_pixel, other_img_cached, color_cached, checked, hit_total, delta_hits);
#endif

        if (!ck->no_cache) {
                switch_img_copy(img, &ck->cache_img);
        }

        switch_img_free(&cache_img);

        return;
}

switch_chromakey_set_default_threshold()

void switch_chromakey_set_default_threshold	(	switch_chromakey_t *	ck,
		uint32_t	threshold
	)

Definition at line 1014 of file switch_core_video.c.

References switch_chromakey_s::dft_thresh, switch_chromakey_s::dft_thresh_squared, switch_chromakey_s::mask_len, and switch_chromakey_s::thresholds.

{
        int i;

        ck->dft_thresh = threshold;
        ck->dft_thresh_squared = threshold * threshold;

        for (i = 0; i < ck->mask_len; i++) {
                if (!ck->thresholds[i]) ck->thresholds[i] = ck->dft_thresh_squared;
        }
}

switch_chromakey_str2shade()

switch_shade_t switch_chromakey_str2shade	(	switch_chromakey_t *	ck,
		const char *	shade_name
	)

Definition at line 997 of file switch_core_video.c.

References SWITCH_SHADE_AUTO, SWITCH_SHADE_BLUE, SWITCH_SHADE_GREEN, SWITCH_SHADE_NONE, and SWITCH_SHADE_RED.

{
        switch_shade_t shade = SWITCH_SHADE_NONE;

        if (!strcasecmp(shade_name, "red")) {
                shade = SWITCH_SHADE_RED;
        } else if (!strcasecmp(shade_name, "green")) {
                shade = SWITCH_SHADE_GREEN;
        } else if (!strcasecmp(shade_name, "blue")) {
                shade = SWITCH_SHADE_BLUE;
        } else if (!strcasecmp(shade_name, "auto")) {
                shade = SWITCH_SHADE_AUTO;
        }

        return shade;
}

switch_color_set_rgb()

void switch_color_set_rgb	(	switch_rgb_color_t *	color,
		const char *	color_str
	)

Set RGB color with a string.

Color string should be in #RRGGBB format

Parameters

[out]	color	RGB color pointer
[in]	color_str	Color string in #RRGGBB format

Definition at line 1747 of file switch_core_video.c.

References switch_rgb_color_s::a, switch_rgb_color_s::b, b, switch_rgb_color_s::g, switch_rgb_color_s::r, switch_yuv_color_s::u, switch_yuv_color_s::v, switch_yuv_color_s::y, and zstr.

Referenced by switch_color_set_yuv(), switch_core_media_bug_patch_spy_frame(), switch_core_session_write_blank_video(), switch_img_letterbox(), switch_img_txt_handle_create(), switch_img_txt_handle_render(), switch_img_write_text_img(), video_bug_thread(), video_helper_thread(), and video_write_thread().

{
        if (zstr(str)) return;

        if ((*str) == '#' && strlen(str) == 7) {
                unsigned int r, g, b;
                sscanf(str, "#%02x%02x%02x", &r, &g, &b);
                color->r = r;
                color->g = g;
                color->b = b;
        } else {
                if (!strcmp(str, "red")) {
                        color->r = 255;
                        color->g = 0;
                        color->b = 0;
                } else if (!strcmp(str, "green")) {
                        color->r = 0;
                        color->g = 255;
                        color->b = 0;
                } else if (!strcmp(str, "blue")) {
                        color->r = 0;
                        color->g = 0;
                        color->b = 255;
                }
        }

        color->a = 255;
}

switch_color_set_yuv()

void switch_color_set_yuv	(	switch_yuv_color_t *	color,
		const char *	color_str
	)

Set YUV color with a string.

Color string should be in #RRGGBB format

Parameters

[out]	color	YUV color pointer
[in]	color_str	Color string in #RRGGBB format

Definition at line 1812 of file switch_core_video.c.

References switch_color_set_rgb().

{
#ifdef SWITCH_HAVE_YUV
        switch_rgb_color_t rgb = { 0 };

        switch_color_set_rgb(&rgb, str);
        switch_color_rgb2yuv(&rgb, color);
#endif
}

switch_core_has_video()

switch_bool_t switch_core_has_video

(

void

)

Definition at line 179 of file switch_core_video.c.

References SWITCH_FALSE, and SWITCH_TRUE.

{
#ifdef SWITCH_HAVE_VPX
#ifdef SWITCH_HAVE_YUV
        return SWITCH_TRUE;
#else
        return SWITCH_FALSE;
#endif
#else
        return SWITCH_FALSE;
#endif
}

switch_core_video_parse_filter_string()

void switch_core_video_parse_filter_string	(	switch_core_video_filter_t *	filters,
		const char *	filter_str
	)

Definition at line 3874 of file switch_core_video.c.

References SCV_FILTER_8BIT_FG, SCV_FILTER_GRAY_BG, SCV_FILTER_GRAY_FG, SCV_FILTER_SEPIA_BG, SCV_FILTER_SEPIA_FG, and switch_stristr().

{
        *filters = 0;

        if (!filter_str) return;

        if (switch_stristr("fg-gray", filter_str)) {
                *filters |= SCV_FILTER_GRAY_FG;
        }

        if (switch_stristr("bg-gray", filter_str)) {
                *filters |= SCV_FILTER_GRAY_BG;
        }

        if (switch_stristr("fg-sepia", filter_str)) {
                *filters |= SCV_FILTER_SEPIA_FG;
        }

        if (switch_stristr("bg-sepia", filter_str)) {
                *filters |= SCV_FILTER_SEPIA_BG;
        }

        if (switch_stristr("fg-8bit", filter_str)) {
                *filters |= SCV_FILTER_8BIT_FG;
        }
} 

switch_I420_copy()

switch_status_t switch_I420_copy	(	const uint8_t *	src_y,
		int	src_stride_y,
		const uint8_t *	src_u,
		int	src_stride_u,
		const uint8_t *	src_v,
		int	src_stride_v,
		uint8_t *	dst_y,
		int	dst_stride_y,
		uint8_t *	dst_u,
		int	dst_stride_u,
		uint8_t *	dst_v,
		int	dst_stride_v,
		int	width,
		int	height
	)

I420 to I420 Copy.

Definition at line 3779 of file switch_core_video.c.

References SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
#ifdef SWITCH_HAVE_YUV
        int ret = I420Copy(src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v,
                                           dst_y, dst_stride_y, dst_u, dst_stride_u, dst_v, dst_stride_v,
                                           width, height);
        return ret == 0 ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
#else
        return SWITCH_STATUS_FALSE;
#endif
}

switch_I420_copy2()

switch_status_t switch_I420_copy2	(	uint8_t *	src_planes[],
		int	src_stride[],
		uint8_t *	dst_planes[],
		int	dst_stride[],
		int	width,
		int	height
	)

Definition at line 3797 of file switch_core_video.c.

References SWITCH_PLANE_U, SWITCH_PLANE_V, SWITCH_PLANE_Y, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
#ifdef SWITCH_HAVE_YUV
        int ret = I420Copy(src_planes[SWITCH_PLANE_Y], src_stride[SWITCH_PLANE_Y],
                                           src_planes[SWITCH_PLANE_U], src_stride[SWITCH_PLANE_U],
                                           src_planes[SWITCH_PLANE_V], src_stride[SWITCH_PLANE_V],
                                           dst_planes[SWITCH_PLANE_Y], dst_stride[SWITCH_PLANE_Y],
                                           dst_planes[SWITCH_PLANE_U], dst_stride[SWITCH_PLANE_U],
                                           dst_planes[SWITCH_PLANE_V], dst_stride[SWITCH_PLANE_V],
                                           width, height);
        return ret == 0 ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
#else
        return SWITCH_STATUS_FALSE;
#endif
}

switch_I420ToARGB()

switch_status_t switch_I420ToARGB	(	const uint8_t *	src_y,
		int	src_stride_y,
		const uint8_t *	src_u,
		int	src_stride_u,
		const uint8_t *	src_v,
		int	src_stride_v,
		uint8_t *	dst_argb,
		int	dst_stride_argb,
		int	width,
		int	height
	)

I420 to ARGB Convertion.

Definition at line 3815 of file switch_core_video.c.

References SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{

#ifdef SWITCH_HAVE_YUV
        int ret = I420ToARGB(src_y, src_stride_y, src_u, src_stride_u, src_v, src_stride_v,
                                                 dst_argb, dst_stride_argb, width, height);

        return ret == 0 ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
#else
        return SWITCH_STATUS_FALSE;
#endif
}

switch_img_8bit()

void switch_img_8bit

(

switch_image_t *

img

)

Definition at line 1464 of file switch_core_video.c.

References switch_rgb_color_s::a, vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, vpx_image::planes, vpx_image::stride, switch_img_alloc(), SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_I420, switch_img_free(), SWITCH_PLANE_PACKED, SWITCH_PLANE_U, SWITCH_PLANE_V, and SWITCH_PLANE_Y.

{
#ifdef SWITCH_HAVE_YUV
        int i;

        if (img->fmt == SWITCH_IMG_FMT_ARGB) {
                int max_w = img->d_w;
                int max_h = img->d_h;
                int j;
                switch_rgb_color_t *rgb; 
                uint32_t *bytes;

                for (i = 0; i < max_h; i++) {           
                        for (j = 0; j < max_w; j++) {
                                rgb = (switch_rgb_color_t *)(img->planes[SWITCH_PLANE_PACKED] + i * img->stride[SWITCH_PLANE_PACKED] + j * 4);
                                //if (rgb);

                                
                                if (!rgb->a) continue;;

                                //rgb->r = rgb->r & 0xE0, rgb->g = rgb->g & 0xE0, rgb->b = rgb->b & 0xC0;
                                bytes = (uint32_t *) rgb;

#if SWITCH_BYTE_ORDER == __BIG_ENDIAN
                                *bytes = *bytes & 0xE0E0C0FF;
#else
                                *bytes = *bytes & 0xFFC0E0E0;
#endif

                        }
                }
        } else if (img->fmt == SWITCH_IMG_FMT_I420) {
                switch_image_t *tmp_img = switch_img_alloc(NULL, SWITCH_IMG_FMT_ARGB, img->d_w, img->d_h, 1);

                I420ToARGB(img->planes[SWITCH_PLANE_Y], img->stride[SWITCH_PLANE_Y],
                                   img->planes[SWITCH_PLANE_U], img->stride[SWITCH_PLANE_U],
                                   img->planes[SWITCH_PLANE_V], img->stride[SWITCH_PLANE_V],
                                   tmp_img->planes[SWITCH_PLANE_PACKED], tmp_img->stride[SWITCH_PLANE_PACKED],
                                   img->d_w, img->d_h);
                
                switch_img_8bit(tmp_img);

                ARGBToI420(tmp_img->planes[SWITCH_PLANE_PACKED], tmp_img->stride[SWITCH_PLANE_PACKED],
                                   img->planes[SWITCH_PLANE_Y], img->stride[SWITCH_PLANE_Y],
                                   img->planes[SWITCH_PLANE_U], img->stride[SWITCH_PLANE_U],
                                   img->planes[SWITCH_PLANE_V], img->stride[SWITCH_PLANE_V],
                                   tmp_img->d_w, tmp_img->d_h);
                
                switch_img_free(&tmp_img);
        }
#endif  
}

switch_img_add_text()

void switch_img_add_text	(	void *	buffer,
		int	w,
		int	x,
		int	y,
		char *	s
	)

Definition at line 1725 of file switch_core_video.c.

References index, and scv_tag().

{
        while (*s) {
                int index;

                if (x > w - 8) break;

                switch (*s) {
                        case '.': index = 10; break;
                        case ':': index = 11; break;
                        case '-': index = 12; break;
                        case ' ': index = 13; break;
                        default:
                                index = *s - 0x30;
                }

                scv_tag(buffer, w, x, y, index);
                x += 8;
                s++;
        }
}

switch_img_alloc()

switch_image_t* switch_img_alloc	(	switch_image_t *	img,
		switch_img_fmt_t	fmt,
		unsigned int	d_w,
		unsigned int	d_h,
		unsigned int	align
	)

Open a descriptor, allocating storage for the underlying image.

Returns a descriptor for storing an image of the given format. The storage for the descriptor is allocated on the heap.

Parameters

[in]	img	Pointer to storage for descriptor. If this parameter is NULL, the storage for the descriptor will be allocated on the heap.
[in]	fmt	Format for the image
[in]	d_w	Width of the image
[in]	d_h	Height of the image
[in]	align	Alignment, in bytes, of the image buffer and each row in the image(stride).

Returns

Returns a pointer to the initialized image descriptor. If the img parameter is non-null, the value of the img parameter will be returned.

Definition at line 192 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, switch_assert, SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_GD, switch_img_free(), vpx_image::user_priv, and vpx_img_alloc().

Referenced by switch_core_session_write_blank_video(), switch_img_8bit(), switch_img_copy(), switch_img_find_position(), switch_img_from_raw(), switch_img_letterbox(), switch_img_mirror(), switch_img_read_from_file(), switch_img_rotate(), switch_img_rotate_copy(), switch_img_scale(), switch_img_write_text_img(), video_bug_thread(), and video_helper_thread().

{
#ifdef SWITCH_HAVE_VPX
        switch_image_t *r = NULL;
#ifdef HAVE_LIBGD
        if (fmt == SWITCH_IMG_FMT_GD) {
                gdImagePtr gd = gdImageCreateTrueColor(d_w, d_h);

                if (!gd) return NULL;

                switch_img_free(&img);
                img = (switch_image_t *)vpx_img_alloc(NULL, SWITCH_IMG_FMT_ARGB, 1, 1, 1);

                if (!img) {
                        gdImageDestroy(gd);
                        return NULL;
                }

                img->user_priv = gd;
                img->d_w = d_w;
                img->d_h = d_h;
                img->fmt = SWITCH_IMG_FMT_GD;
                return img;
        }
#endif

        switch_assert(d_w > 0);
        switch_assert(d_h > 0);
        r = (switch_image_t *)vpx_img_alloc((vpx_image_t *)img, (vpx_img_fmt_t)fmt, d_w, d_h, align);
        switch_assert(r);
        switch_assert(r->d_w == d_w);
        switch_assert(r->d_h == d_h);

        return r;
#else
        return NULL;
#endif
}

switch_img_attenuate()

void switch_img_attenuate

(

switch_image_t *

img

)

Definition at line 371 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, vpx_image::planes, vpx_image::stride, SWITCH_IMG_FMT_ARGB, SWITCH_PLANE_PACKED, and vpx_image::user_priv.

{
#ifdef SWITCH_HAVE_YUV
        if (img->fmt != SWITCH_IMG_FMT_ARGB) {
                return;
        }

        if (img->user_priv) return;

        img->user_priv = (void *)(intptr_t)1;

        ARGBAttenuate(img->planes[SWITCH_PLANE_PACKED], img->stride[SWITCH_PLANE_PACKED],
                                  img->planes[SWITCH_PLANE_PACKED], img->stride[SWITCH_PLANE_PACKED], img->d_w, img->d_h);
#else
        return;
#endif

}

switch_img_calc_fit()

void switch_img_calc_fit	(	switch_image_t *	src,
		int	width,
		int	height,
		int *	new_wP,
		int *	new_hP
	)

Definition at line 3363 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, and switch_assert.

Referenced by switch_img_fit().

{
        int new_w, new_h;

        switch_assert(src);
        
        new_w = src->d_w;
        new_h = src->d_h;

        if (src->d_w < width && src->d_h < height) {
                float rw = (float)new_w / width;
                float rh = (float)new_h / height;

                if (rw > rh) {
                        new_h = (int)((float)new_h / rw);
                        new_w = width;
                } else {
                        new_w = (int)((float)new_w / rh);
                        new_h = height;
                }
        } else {
                while(new_w > width || new_h > height) {
                        if (new_w > width) {
                                double m = (double) width / new_w;
                                new_w = width;
                                new_h = (int) (new_h * m);
                        } else {
                                double m = (double) height / new_h;
                                new_h = height;
                                new_w = (int) (new_w * m);
                        }
                }
        }

        *new_wP = new_w;
        *new_hP = new_h;
}

switch_img_chromakey()

void switch_img_chromakey	(	switch_image_t *	img,
		switch_rgb_color_t *	mask,
		int	threshold
	)

chromakey an img, img must be RGBA and return modified img

Definition at line 1385 of file switch_core_video.c.

References switch_rgb_color_s::a, vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, vpx_image::planes, switch_assert, switch_color_distance(), SWITCH_IMG_FMT_ARGB, and SWITCH_PLANE_PACKED.

{
        switch_rgb_color_t *pixel, *last_pixel = NULL;
        int last_threshold = 0;
        switch_assert(img);

        if (img->fmt != SWITCH_IMG_FMT_ARGB) return;

        pixel = (switch_rgb_color_t *)img->planes[SWITCH_PLANE_PACKED];

        for (; pixel < ((switch_rgb_color_t *)img->planes[SWITCH_PLANE_PACKED] + img->d_w * img->d_h); pixel++) {
                int threshold = 0;

                if (last_pixel && (*(uint32_t *)pixel & 0xFFFFFF) == (*(uint32_t *)last_pixel & 0xFFFFFF)) {
                        threshold = last_threshold;
                } else {
                        threshold = switch_color_distance(pixel, mask);
                }

                last_threshold = threshold;
                last_pixel = pixel;

                if (threshold) {
                        pixel->a = 0;
                }
        }

        return;
}

switch_img_copy()

void switch_img_copy	(	switch_image_t *	img,
		switch_image_t **	new_img
	)

Copy image to a new image.

if new_img is NULL, a new image is allocated if new_img is not NULL but not the same size as img, new_img is destroyed and a new new_img is allocated else, copy the img data to the new_img

Parameters

[in]	img	Image descriptor
[out]	new_img	New Image descriptor, NULL if out of memory

Definition at line 584 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, vpx_image::planes, vpx_image::stride, switch_assert, switch_img_alloc(), SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_ARGB_LE, SWITCH_IMG_FMT_I420, switch_img_free(), SWITCH_PLANE_PACKED, SWITCH_PLANE_U, SWITCH_PLANE_V, and SWITCH_PLANE_Y.

Referenced by find_free_frame(), switch_chromakey_process(), switch_core_media_bug_patch_spy_frame(), switch_core_media_bug_push_spy_frame(), switch_core_session_read_video_frame(), switch_core_session_write_video_frame(), switch_frame_dup(), switch_img_copy_rect(), switch_img_letterbox(), switch_img_patch_rect(), and video_write_overlay_callback().

{
#ifdef SWITCH_HAVE_YUV
        switch_img_fmt_t new_fmt = img->fmt;

        switch_assert(img);
        switch_assert(new_img);

        if (img->fmt != SWITCH_IMG_FMT_I420 && img->fmt != SWITCH_IMG_FMT_ARGB) return;

        if (*new_img) {
                new_fmt = (*new_img)->fmt;
                if ((*new_img)->fmt != SWITCH_IMG_FMT_I420 && (*new_img)->fmt != SWITCH_IMG_FMT_ARGB && (*new_img)->fmt != SWITCH_IMG_FMT_ARGB_LE) return;
                if (img->d_w != (*new_img)->d_w || img->d_h != (*new_img)->d_h ) {
                        new_fmt = (*new_img)->fmt;
                        switch_img_free(new_img);
                }
        }

        if (*new_img == NULL) {
                *new_img = switch_img_alloc(NULL, new_fmt, img->d_w, img->d_h, 1);
        }

        switch_assert(*new_img);

        if (img->fmt == SWITCH_IMG_FMT_I420) {
                if (new_fmt == SWITCH_IMG_FMT_I420) {
                        I420Copy(img->planes[SWITCH_PLANE_Y], img->stride[SWITCH_PLANE_Y],
                                         img->planes[SWITCH_PLANE_U], img->stride[SWITCH_PLANE_U],
                                         img->planes[SWITCH_PLANE_V], img->stride[SWITCH_PLANE_V],
                                         (*new_img)->planes[SWITCH_PLANE_Y], (*new_img)->stride[SWITCH_PLANE_Y],
                                         (*new_img)->planes[SWITCH_PLANE_U], (*new_img)->stride[SWITCH_PLANE_U],
                                         (*new_img)->planes[SWITCH_PLANE_V], (*new_img)->stride[SWITCH_PLANE_V],
                                         img->d_w, img->d_h);
                } else if (new_fmt == SWITCH_IMG_FMT_ARGB) {
                        I420ToARGB(img->planes[SWITCH_PLANE_Y], img->stride[SWITCH_PLANE_Y],
                                img->planes[SWITCH_PLANE_U], img->stride[SWITCH_PLANE_U],
                                img->planes[SWITCH_PLANE_V], img->stride[SWITCH_PLANE_V],
                                (*new_img)->planes[SWITCH_PLANE_PACKED], (*new_img)->stride[SWITCH_PLANE_PACKED],
                                img->d_w, img->d_h);
                } else if (new_fmt == SWITCH_IMG_FMT_ARGB_LE) {
                                I420ToABGR(img->planes[SWITCH_PLANE_Y], img->stride[SWITCH_PLANE_Y],
                                img->planes[SWITCH_PLANE_U], img->stride[SWITCH_PLANE_U],
                                img->planes[SWITCH_PLANE_V], img->stride[SWITCH_PLANE_V],
                                (*new_img)->planes[SWITCH_PLANE_PACKED], (*new_img)->stride[SWITCH_PLANE_PACKED],
                                img->d_w, img->d_h);
                }
        } else if (img->fmt == SWITCH_IMG_FMT_ARGB) {
                if (new_fmt == SWITCH_IMG_FMT_ARGB) {
                        ARGBCopy(img->planes[SWITCH_PLANE_PACKED], img->stride[SWITCH_PLANE_PACKED],
                                 (*new_img)->planes[SWITCH_PLANE_PACKED], (*new_img)->stride[SWITCH_PLANE_PACKED],
                                 img->d_w, img->d_h);
                } else if (new_fmt == SWITCH_IMG_FMT_I420) {
                        ARGBToI420(img->planes[SWITCH_PLANE_PACKED], img->stride[SWITCH_PLANE_PACKED],
                                          (*new_img)->planes[SWITCH_PLANE_Y], (*new_img)->stride[SWITCH_PLANE_Y],
                                          (*new_img)->planes[SWITCH_PLANE_U], (*new_img)->stride[SWITCH_PLANE_U],
                                          (*new_img)->planes[SWITCH_PLANE_V], (*new_img)->stride[SWITCH_PLANE_V],
                                          img->d_w, img->d_h);
                }
        }
#else
        return;
#endif
}

switch_img_copy_rect()

switch_image_t* switch_img_copy_rect	(	switch_image_t *	img,
		uint32_t	x,
		uint32_t	y,
		uint32_t	w,
		uint32_t	h
	)

Copy part of an image to a new image.

Parameters

[in]	img	Image descriptor
[in]	x	Leftmost pos to be read from
[in]	y	Topmost pos to be read from
[in]	w	Max width to be read from
[in]	h	Max height to be read from

Returns

NULL if failed to copy, otherwise a valid image descriptor.

Definition at line 687 of file switch_core_video.c.

References switch_lab_color_t::a, switch_rgb_color_s::b, switch_lab_color_t::b, b, vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, switch_rgb_color_s::g, switch_hsl_color_s::h, if(), switch_hsl_color_s::l, switch_lab_color_t::l, M_PI, MIN, vpx_image::planes, switch_rgb_color_s::r, switch_hsl_color_s::s, switch_assert, switch_img_copy(), SWITCH_IMG_FMT_PLANAR, switch_img_free(), switch_img_set_rect(), SWITCH_PLANE_PACKED, SWITCH_PLANE_Y, vpx_img_wrap(), switch_xyz_color_t::x, switch_xyz_color_t::y, and switch_xyz_color_t::z.

Referenced by switch_core_media_bug_patch_spy_frame().

{
#ifdef SWITCH_HAVE_VPX
        switch_image_t *new_img = NULL, *tmp;
        uint8_t *data;

        switch_assert(img);

        if (x >= img->d_w || y >= img->d_h) return NULL;

        if (!(img->fmt & SWITCH_IMG_FMT_PLANAR)) {
                data = img->planes[SWITCH_PLANE_PACKED];
        } else {
                data = img->planes[SWITCH_PLANE_Y];
        }

        tmp = (switch_image_t *)vpx_img_wrap(NULL, img->fmt, img->d_w, img->d_h, 1, data);
        if (!tmp) return NULL;

        w = MIN(img->d_w - x, w);
        h = MIN(img->d_h - y, h);

        if (!switch_img_set_rect(tmp, x, y, w, h)) {
                switch_img_copy(tmp, &new_img);
        }

        switch_img_free(&tmp);

        return new_img;
#else
        return NULL;
#endif
}

switch_img_data_url()

switch_status_t switch_img_data_url	(	switch_image_t *	img,
		char **	urlP,
		const char *	type,
		int	quality
	)

Definition at line 3241 of file switch_core_video.c.

References buffer, vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, vpx_image::planes, vpx_image::stride, switch_assert, switch_b64_encode(), switch_buffer_create_dynamic(), switch_buffer_destroy(), switch_buffer_get_head_pointer(), switch_buffer_inuse(), SWITCH_CHANNEL_LOG, SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_I420, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_PLANE_PACKED, SWITCH_PLANE_U, SWITCH_PLANE_V, SWITCH_PLANE_Y, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_zmalloc.

{
#ifndef SWITCH_HAVE_YUV
        return SWITCH_STATUS_FALSE;
#else
        int comp = STBI_rgb;
        unsigned char *data = NULL;
        int stride_in_bytes = 0;
        int ret = 0;
        switch_buffer_t *buffer = NULL;
        const char *header = NULL;
        int header_len = 0;

        if (!type) return SWITCH_STATUS_FALSE;

        if (img->fmt == SWITCH_IMG_FMT_I420) {
                comp = STBI_rgb;
                stride_in_bytes = img->d_w * 3;

                data = malloc(stride_in_bytes * img->d_h);
                switch_assert(data);

                I420ToRAW(img->planes[SWITCH_PLANE_Y], img->stride[SWITCH_PLANE_Y],
                        img->planes[SWITCH_PLANE_U], img->stride[SWITCH_PLANE_U],
                        img->planes[SWITCH_PLANE_V], img->stride[SWITCH_PLANE_V],
                        data, stride_in_bytes,
                        img->d_w, img->d_h);
        } else if (img->fmt == SWITCH_IMG_FMT_ARGB) {
                comp = STBI_rgb_alpha;
                stride_in_bytes = img->d_w * 4;

                data = malloc(stride_in_bytes * img->d_h);
                switch_assert(data);

#if SWITCH_BYTE_ORDER == __BIG_ENDIAN
                ARGBToRGBA(img->planes[SWITCH_PLANE_PACKED], stride_in_bytes, data, stride_in_bytes, img->d_w, img->d_h);
#else
                ARGBToABGR(img->planes[SWITCH_PLANE_PACKED], stride_in_bytes, data, stride_in_bytes, img->d_w, img->d_h);
#endif
        } else {
                return SWITCH_STATUS_FALSE;
        }

        switch_buffer_create_dynamic(&buffer, 1024, 1024, 0);

        if (!strcmp(type, "png")) {
                header = "data:image/png;base64,";
                ret = stbi_write_png_to_func(data_url_write_func, (void *)buffer, img->d_w, img->d_h, comp, (const void *)data, stride_in_bytes);
        } else if (!strcmp(type, "jpeg") || !strcmp(type, "jpeg")) {
                header = "data:image/jpeg;base64,";
                ret = stbi_write_jpg_to_func(data_url_write_func, (void *)buffer, img->d_w, img->d_h, comp, (const void *)data, quality);
        } else {
                ret = 0;
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "unsupported file format [%s]\n", type);
        }

        if (ret && switch_buffer_inuse(buffer) > 0) {
                switch_size_t blen = switch_buffer_inuse(buffer);
                switch_size_t olen = blen * 4 + strlen(header) + 1;
                uint8_t *data = switch_buffer_get_head_pointer(buffer);
                unsigned char *out = NULL;

                switch_zmalloc(out, olen);
                header_len = strlen(header);
                memcpy(out, header, header_len);
                switch_b64_encode(data, blen, out + header_len, olen - header_len);
                *urlP = (char *)out;
        }

        free(data);
        switch_buffer_destroy(&buffer);

        return ret ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
#endif /* SWITCH_HAVE_YUV */
}

switch_img_data_url_png()

switch_status_t switch_img_data_url_png	(	switch_image_t *	img,
		char **	urlP
	)

Definition at line 3109 of file switch_core_video.c.

References SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(), and SWITCH_STATUS_FALSE.

{
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "This function is not available, libpng not installed\n");
        return SWITCH_STATUS_FALSE;
}

switch_img_draw_text()

void switch_img_draw_text	(	switch_image_t *	IMG,
		int	x,
		int	y,
		switch_rgb_color_t	color,
		uint16_t	font_size,
		char *	text
	)

switch_img_fill()

void switch_img_fill	(	switch_image_t *	img,
		int	x,
		int	y,
		int	w,
		int	h,
		switch_rgb_color_t *	color
	)

Fill image with color.

Parameters

[in]	img	Image descriptor
[in]	x	Leftmost pos to be read from
[in]	y	Topmost pos to be read from
[in]	w	Max width to be read from
[in]	h	Max height to be read from
[in]	color	RGB color

Definition at line 1576 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, memset(), MIN, vpx_image::planes, vpx_image::stride, SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_I420, SWITCH_PLANE_PACKED, SWITCH_PLANE_U, SWITCH_PLANE_V, SWITCH_PLANE_Y, switch_yuv_color_s::u, switch_yuv_color_s::v, and switch_yuv_color_s::y.

Referenced by switch_core_media_bug_patch_spy_frame(), switch_core_session_write_blank_video(), switch_img_letterbox(), switch_img_write_text_img(), video_bug_thread(), video_helper_thread(), and video_write_thread().

{
#ifdef SWITCH_HAVE_YUV
        int len, i, max_h;
        switch_yuv_color_t yuv_color;

        if (x < 0 || y < 0 || x >= img->d_w || y >= img->d_h) return;

        if (img->fmt == SWITCH_IMG_FMT_I420) {
                switch_color_rgb2yuv(color, &yuv_color);

                max_h = MIN(y + h, img->d_h);
                len = MIN(w, img->d_w - x);

                if (x & 1) { x++; len--; }
                if (y & 1) y++;
                if (len <= 0) return;

                for (i = y; i < max_h; i++) {
                        memset(img->planes[SWITCH_PLANE_Y] + img->stride[SWITCH_PLANE_Y] * i + x, yuv_color.y, len);
                }

                if ((len & 1) && (x + len) < img->d_w - 1) len++;

                len /= 2;

                for (i = y; i < max_h; i += 2) {
                        memset(img->planes[SWITCH_PLANE_U] + img->stride[SWITCH_PLANE_U] * (i / 2) + x / 2, yuv_color.u, len);
                        memset(img->planes[SWITCH_PLANE_V] + img->stride[SWITCH_PLANE_V] * (i / 2) + x / 2, yuv_color.v, len);
                }
        } else if (img->fmt == SWITCH_IMG_FMT_ARGB) {
                for (i = 0; i < img->d_w; i++) {
                        *((switch_rgb_color_t *)img->planes[SWITCH_PLANE_PACKED] + i) = *color;
                }

                for (i = 1; i < img->d_h; i++) {
                        memcpy( img->planes[SWITCH_PLANE_PACKED] + i * img->d_w * 4,
                                        img->planes[SWITCH_PLANE_PACKED], img->d_w * 4);
                }
        }
#endif
}

switch_img_fill_noalpha()

void switch_img_fill_noalpha	(	switch_image_t *	img,
		int	x,
		int	y,
		int	w,
		int	h,
		switch_rgb_color_t *	color
	)

Definition at line 1437 of file switch_core_video.c.

References switch_rgb_color_s::a, vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, vpx_image::planes, vpx_image::stride, SWITCH_IMG_FMT_ARGB, and SWITCH_PLANE_PACKED.

{
#ifdef SWITCH_HAVE_YUV
        int i;

        if (img->fmt == SWITCH_IMG_FMT_ARGB) {
                int max_w = img->d_w;
                int max_h = img->d_h;
                int j;
                switch_rgb_color_t *rgb; 

                for (i = 0; i < max_h; i++) {           
                        for (j = 0; j < max_w; j++) {
                                rgb = (switch_rgb_color_t *)(img->planes[SWITCH_PLANE_PACKED] + i * img->stride[SWITCH_PLANE_PACKED] + j * 4);

                                if (rgb->a != 0) {
                                        continue;
                                }
                                
                                *rgb = *color;
                        }
                }
        }

#endif
}

switch_img_find_position()

void switch_img_find_position	(	switch_img_position_t	pos,
		int	sw,
		int	sh,
		int	iw,
		int	ih,
		int *	xP,
		int *	yP
	)

Definition at line 3687 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, POS_CENTER_BOT, POS_CENTER_MID, POS_CENTER_TOP, POS_LEFT_BOT, POS_LEFT_MID, POS_LEFT_TOP, POS_NONE, POS_RIGHT_BOT, POS_RIGHT_MID, POS_RIGHT_TOP, SWITCH_CHANNEL_LOG, SWITCH_DECLARE, switch_img_alloc(), SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_GD, switch_img_free(), switch_img_read_file(), SWITCH_LOG_ERROR, switch_log_printf(), and vpx_image::user_priv.

Referenced by switch_core_media_bug_patch_spy_frame(), video_bug_thread(), and video_write_overlay_callback().

{
        switch(pos) {
        case POS_NONE:
        case POS_LEFT_TOP:
                *xP = 0;
                *yP = 0;
                break;
        case POS_LEFT_MID:
                *xP = 0;
                *yP = (sh - ih) / 2;
                break;
        case POS_LEFT_BOT:
                *xP = 0;
                *yP = (sh - ih);
                break;
        case POS_CENTER_TOP:
                *xP = (sw - iw) / 2;
                *yP = 0;
                break;
        case POS_CENTER_MID:
                *xP = (sw - iw) / 2;
                *yP = (sh - ih) / 2;
                break;
        case POS_CENTER_BOT:
                *xP = (sw - iw) / 2;
                *yP = (sh - ih);
                break;
        case POS_RIGHT_TOP:
                *xP = (sw - iw);
                *yP = 0;
                break;
        case POS_RIGHT_MID:
                *xP = (sw - iw);
                *yP = (sh - ih) / 2;
                break;
        case POS_RIGHT_BOT:
                *xP = (sw - iw);
                *yP = (sh - ih);
                break;
        };

}

switch_img_fit()

switch_status_t switch_img_fit	(	switch_image_t **	srcP,
		int	width,
		int	height,
		switch_img_fit_t	fit
	)

Definition at line 3401 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, fmt, switch_assert, SWITCH_FIT_NECESSARY, SWITCH_FIT_SCALE, SWITCH_FIT_SIZE_AND_SCALE, switch_img_calc_fit(), SWITCH_IMG_FMT_444A, SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_ARGB_LE, SWITCH_IMG_FMT_BGR24, SWITCH_IMG_FMT_I420, SWITCH_IMG_FMT_I42016, SWITCH_IMG_FMT_I422, SWITCH_IMG_FMT_I42216, SWITCH_IMG_FMT_I440, SWITCH_IMG_FMT_I44016, SWITCH_IMG_FMT_I444, SWITCH_IMG_FMT_I44416, SWITCH_IMG_FMT_NONE, SWITCH_IMG_FMT_RGB24, SWITCH_IMG_FMT_RGB32, SWITCH_IMG_FMT_RGB32_LE, SWITCH_IMG_FMT_RGB555, SWITCH_IMG_FMT_RGB555_LE, SWITCH_IMG_FMT_RGB565, SWITCH_IMG_FMT_RGB565_LE, SWITCH_IMG_FMT_UYVY, SWITCH_IMG_FMT_VPXI420, SWITCH_IMG_FMT_VPXYV12, SWITCH_IMG_FMT_YUY2, SWITCH_IMG_FMT_YV12, SWITCH_IMG_FMT_YVYU, switch_img_free(), switch_img_scale(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_media_bug_patch_spy_frame(), video_bug_thread(), video_write_overlay_callback(), and video_write_thread().

{
        switch_image_t *src, *tmp = NULL;
        int new_w = 0, new_h = 0;

        switch_assert(srcP);
        switch_assert(width && height);

        src = *srcP;

        if (!src || (src->d_w == width && src->d_h == height)) {
                return SWITCH_STATUS_SUCCESS;
        }

        if (fit == SWITCH_FIT_NECESSARY && src->d_w <= width && src->d_h < height) {
                return SWITCH_STATUS_SUCCESS;
        }

        if (fit == SWITCH_FIT_SCALE) {
                switch_img_scale(src, &tmp, width, height);
                switch_img_free(&src);
                *srcP = tmp;
                return SWITCH_STATUS_SUCCESS;
        }

        switch_img_calc_fit(src, width, height, &new_w, &new_h);
        
        if (new_w && new_h) {
                if (switch_img_scale(src, &tmp, new_w, new_h) == SWITCH_STATUS_SUCCESS) {
                        switch_img_free(&src);
                        *srcP = tmp;

                        if (fit == SWITCH_FIT_SIZE_AND_SCALE) {
                                src = *srcP;
                                tmp = NULL;
                                switch_img_scale(src, &tmp, width, height);
                                switch_img_free(&src);
                                *srcP = tmp;
                        }

                        return SWITCH_STATUS_SUCCESS;
                }
        }

        return SWITCH_STATUS_FALSE;
}

switch_img_free()

void switch_img_free

(

switch_image_t **

img

)

Close an image descriptor.

Frees all allocated storage associated with an image descriptor.

Parameters

[in]

img

pointer to pointer of Image descriptor

Definition at line 295 of file switch_core_video.c.

References switch_assert, SWITCH_IMG_FMT_GD, SWITCH_IMG_FMT_I44016, switch_safe_free, and vpx_img_free().

Referenced by flush_video_queue(), switch_chromakey_autocolor(), switch_chromakey_destroy(), switch_chromakey_process(), switch_core_media_bug_destroy(), switch_core_media_bug_patch_spy_frame(), switch_core_session_write_blank_video(), switch_core_session_write_video_frame(), switch_frame_buffer_free(), switch_frame_free(), switch_img_8bit(), switch_img_alloc(), switch_img_copy(), switch_img_copy_rect(), switch_img_find_position(), switch_img_fit(), switch_img_letterbox(), switch_img_mirror(), switch_img_patch_rect(), switch_img_rotate(), switch_img_rotate_copy(), switch_img_scale(), switch_ivr_video_write_overlay_session(), video_bug_thread(), video_helper_thread(), video_write_overlay_callback(), and video_write_thread().

{
#ifdef SWITCH_HAVE_VPX
        if (img && *img) {
                if ((*img)->fmt == SWITCH_IMG_FMT_GD) {
#ifdef HAVE_LIBGD
                        gdImageDestroy((gdImagePtr)(*img)->user_priv);
#endif
                } else {
                        if ((int)(intptr_t)(*img)->user_priv != 1) {
                                switch_safe_free((*img)->user_priv);
                        }
                }
                switch_assert((*img)->fmt <= SWITCH_IMG_FMT_I44016);
                switch_assert((*img)->d_w <= 7860 && (*img)->d_w > 0);
                switch_assert((*img)->d_h <= 4320 && (*img)->d_h > 0);
                vpx_img_free((vpx_image_t *)*img);
                *img = NULL;
        }
#endif
}

switch_img_from_raw()

switch_status_t switch_img_from_raw	(	switch_image_t **	destP,
		void *	src,
		switch_img_fmt_t	fmt,
		int	width,
		int	height
	)

convert raw memory to switch_img_t

if dest is NULL then a new img is created, user should destroy it later, otherwize it will re-used the dest img, and the dest img size must match the src width and height, width and height can be 0 in the latter case and it will figure out according to the dest img

Parameters

[in]	dest	The image descriptor
[in]	src	The raw data memory address
[in]	fmt	The raw data format
[in]	width	The raw data width
[in]	height	The raw data height

Definition at line 3524 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, vpx_image::planes, vpx_image::stride, SWITCH_CHANNEL_LOG, switch_img_alloc(), SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_I420, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
#ifdef SWITCH_HAVE_YUV
        uint32_t fourcc;
        int ret = -1;
        switch_image_t *dest = NULL;

        if (!destP) {
                return SWITCH_STATUS_FALSE;
        }

        dest = *destP;

        fourcc = switch_img_fmt2fourcc(fmt);

        if (fourcc == FOURCC_ANY) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "unsupported format: %d\n", fmt);
                return SWITCH_STATUS_FALSE;
        }

        if (!dest && width > 0 && height > 0) dest = switch_img_alloc(NULL, SWITCH_IMG_FMT_I420, width, height, 1);
        if (!dest) return SWITCH_STATUS_FALSE;

        if (width == 0 || height == 0) {
                width = dest->d_w;
                height = dest->d_h;
        }

/*
        int ConvertToI420(const uint8_t* src_frame, size_t src_size,
                        uint8_t* dst_y, int dst_stride_y,
                        uint8_t* dst_u, int dst_stride_u,
                        uint8_t* dst_v, int dst_stride_v,
                        int crop_x, int crop_y,
                        int src_width, int src_height,
                        int crop_width, int crop_height,
                        enum RotationMode rotation,
                        uint32 format);

        src_size is only used when FOURCC_MJPG which we don't support so always 0
*/

        if (dest->fmt == SWITCH_IMG_FMT_I420) {
                ret = ConvertToI420(src, 0,
                                        dest->planes[0], dest->stride[0],
                                        dest->planes[1], dest->stride[1],
                                        dest->planes[2], dest->stride[2],
                                        0, 0,
                                        width, height,
                                        width, height,
                                        0, fourcc);
        } else if (dest->fmt == SWITCH_IMG_FMT_ARGB) {
                ConvertToARGB(src, 0,
                                        dest->planes[0], width * 4,
                                        0, 0,
                                        width, height,
                                        width, height,
                                        0, fourcc);
        }

        *destP = dest;

        return ret == 0 ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
#else
        return SWITCH_STATUS_FALSE;
#endif
}

switch_img_gray()

void switch_img_gray	(	switch_image_t *	img,
		int	x,
		int	y,
		int	w,
		int	h
	)

Definition at line 1546 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, memset(), MIN, vpx_image::planes, vpx_image::stride, SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_I420, SWITCH_PLANE_PACKED, SWITCH_PLANE_U, and SWITCH_PLANE_V.

{
#ifdef SWITCH_HAVE_YUV

        if (x < 0 || y < 0 || x >= img->d_w || y >= img->d_h) return;

        if (img->fmt == SWITCH_IMG_FMT_ARGB) {
                ARGBGray(img->planes[SWITCH_PLANE_PACKED], img->stride[SWITCH_PLANE_PACKED], x, y, w, h);
        } else if (img->fmt == SWITCH_IMG_FMT_I420) {
                int len, i, max_h;

                max_h = MIN(y + h, img->d_h);
                len = MIN(w, img->d_w - x);

                if (x & 1) { x++; len--; }
                if (y & 1) y++;
                if (len <= 0) return;

                if ((len & 1) && (x + len) < img->d_w - 1) len++;

                len /= 2;

                for (i = y; i < max_h; i += 2) {
                        memset(img->planes[SWITCH_PLANE_U] + img->stride[SWITCH_PLANE_U] * (i / 2) + x / 2, 128, len);
                        memset(img->planes[SWITCH_PLANE_V] + img->stride[SWITCH_PLANE_V] * (i / 2) + x / 2, 128, len);
                }
        }
#endif
}

switch_img_letterbox()

switch_status_t switch_img_letterbox	(	switch_image_t *	img,
		switch_image_t **	imgP,
		int	width,
		int	height,
		const char *	color
	)

Definition at line 3318 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, switch_assert, switch_color_set_rgb(), switch_img_alloc(), switch_img_copy(), switch_img_fill(), SWITCH_IMG_FMT_I420, switch_img_free(), switch_img_patch(), switch_img_scale(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_session_write_video_frame().

{
        int img_w = 0, img_h = 0;
        double screen_aspect = 0, img_aspect = 0;
        int x_pos = 0;
        int y_pos = 0;
        switch_image_t *IMG = NULL, *scale_img = NULL;
        switch_rgb_color_t bgcolor = { 0 };

        switch_assert(imgP);
        *imgP = NULL;

        if (img->d_w == width && img->d_h == height) {
                switch_img_copy(img, imgP);
                return SWITCH_STATUS_SUCCESS;
        }

        IMG = switch_img_alloc(NULL, SWITCH_IMG_FMT_I420, width, height, 1);
        switch_color_set_rgb(&bgcolor, color);
        switch_img_fill(IMG, 0, 0, IMG->d_w, IMG->d_h, &bgcolor);

        img_w = IMG->d_w;
        img_h = IMG->d_h;

        screen_aspect = (double) IMG->d_w / IMG->d_h;
        img_aspect = (double) img->d_w / img->d_h;


        if (screen_aspect > img_aspect) {
                img_w = img_aspect * IMG->d_h;
                x_pos = (IMG->d_w - img_w) / 2;
        } else if (screen_aspect < img_aspect) {
                img_h = IMG->d_w / img_aspect;
                y_pos = (IMG->d_h - img_h) / 2;
        }

        switch_img_scale(img, &scale_img, img_w, img_h);
        switch_img_patch(IMG, scale_img, x_pos, y_pos);
        switch_img_free(&scale_img);

        *imgP = IMG;

        return SWITCH_STATUS_SUCCESS;
}

switch_img_mirror()

switch_status_t switch_img_mirror	(	switch_image_t *	src,
		switch_image_t **	destP
	)

Definition at line 3643 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, vpx_image::planes, vpx_image::stride, SWITCH_CHANNEL_LOG, switch_img_alloc(), SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_I420, switch_img_free(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_PLANE_PACKED, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
#ifdef SWITCH_HAVE_YUV
        switch_image_t *dest = NULL;
        int ret = 0;

        if (!destP) {
                return SWITCH_STATUS_FALSE;
        }

        dest = *destP;

        if (dest && src->fmt != dest->fmt) switch_img_free(&dest);

        if (!dest) dest = switch_img_alloc(NULL, src->fmt, src->d_w, src->d_h, 1);

        if (src->fmt == SWITCH_IMG_FMT_I420) {
                ret = I420Mirror(src->planes[0], src->stride[0],
                                                 src->planes[1], src->stride[1],
                                                 src->planes[2], src->stride[2],
                                                 dest->planes[0], dest->stride[0],
                                                 dest->planes[1], dest->stride[1],
                                                 dest->planes[2], dest->stride[2],
                                                 src->d_w, src->d_h);
        } else if (src->fmt == SWITCH_IMG_FMT_ARGB) {
                ret = ARGBMirror(src->planes[SWITCH_PLANE_PACKED], src->d_w * 4,
                                                 dest->planes[SWITCH_PLANE_PACKED], src->d_w * 4,
                                                 src->d_w, src->d_h);
                
        }

        *destP = dest;

        if (ret != 0) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Mirror Error: ret: %d\n", ret);
                return SWITCH_STATUS_FALSE;
        }

        return SWITCH_STATUS_SUCCESS;
#else
        return SWITCH_STATUS_FALSE;
#endif
}

switch_img_overlay()

void switch_img_overlay	(	switch_image_t *	IMG,
		switch_image_t *	img,
		int	x,
		int	y,
		uint8_t	percent
	)

put a small img over a big IMG at position x,y, with alpha transparency

Both IMG and img must be non-NULL

Parameters

[in]	IMG	The BIG Image descriptor
[in]	img	The small Image descriptor
[in]	x	Leftmost pos
[in]	y	Topmost pos
[in]	percent	Alaha value from 0(completely transparent) to 100(opaque)

Definition at line 1647 of file switch_core_video.c.

References switch_rgb_color_s::a, switch_rgb_color_s::b, vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, switch_rgb_color_s::g, MIN, switch_rgb_color_s::r, switch_assert, switch_img_draw_pixel(), SWITCH_IMG_FMT_I420, and switch_img_get_rgb_pixel().

Referenced by video_write_overlay_callback().

{
        int i, j, len, max_h;
        switch_rgb_color_t RGB = {0}, rgb = {0}, c = {0};
        int xoff = 0, yoff = 0;
        uint8_t alpha = (int8_t)((255 * percent) / 100);


        switch_assert(IMG->fmt == SWITCH_IMG_FMT_I420);

        if (x < 0) {
                xoff = -x;
                x = 0;
        }

        if (y < 0) {
                yoff = -y;
                y = 0;
        }

        max_h = MIN(y + img->d_h - yoff, IMG->d_h);
        len = MIN(img->d_w - xoff, IMG->d_w - x);

        if (x & 1) { x++; len--; }
        if (y & 1) y++;
        if (len <= 0) return;

        for (i = y; i < max_h; i++) {
                for (j = 0; j < len; j++) {
                        switch_img_get_rgb_pixel(IMG, &RGB, x + j, i);
                        switch_img_get_rgb_pixel(img, &rgb, j + xoff, i - y + yoff);

                        if (rgb.a > 0) {
                                c.r = ((RGB.r * (255 - alpha)) >> 8) + ((rgb.r * alpha) >> 8);
                                c.g = ((RGB.g * (255 - alpha)) >> 8) + ((rgb.g * alpha) >> 8);
                                c.b = ((RGB.b * (255 - alpha)) >> 8) + ((rgb.b * alpha) >> 8);
                        } else {
                                c.r = RGB.r;
                                c.g = RGB.g;
                                c.b = RGB.b;
                        }

                        switch_img_draw_pixel(IMG, x + j, i, &c);
                }
        }
}

switch_img_patch()

void switch_img_patch	(	switch_image_t *	IMG,
		switch_image_t *	img,
		int	x,
		int	y
	)

patch a small img to a big IMG at position x,y

Both IMG and img must be non-NULL

Parameters

[in]	IMG	The BIG Image descriptor
[in]	img	The small Image descriptor
[in]	x	Leftmost pos to patch to
[in]	y	Topmost pos to patch to

Definition at line 441 of file switch_core_video.c.

References switch_rgb_color_s::a, switch_rgb_color_s::b, vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, switch_rgb_color_s::g, MIN, vpx_image::planes, switch_rgb_color_s::r, vpx_image::stride, switch_assert, SWITCH_CHANNEL_LOG, SWITCH_FALSE, switch_img_draw_pixel(), SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_GD, SWITCH_IMG_FMT_I420, switch_img_get_rgb_pixel(), switch_img_patch_rgb(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_PLANE_PACKED, SWITCH_PLANE_U, SWITCH_PLANE_V, SWITCH_PLANE_Y, and vpx_image::user_priv.

Referenced by switch_core_media_bug_patch_spy_frame(), switch_img_letterbox(), switch_img_patch_rect(), and video_bug_thread().

{
        int i, len, max_h;
        int xoff = 0, yoff = 0;

        if (img->fmt == SWITCH_IMG_FMT_ARGB && IMG->fmt == SWITCH_IMG_FMT_ARGB) {
                switch_img_patch_rgb(IMG, img, x, y, SWITCH_FALSE);
                return;
        }

        switch_assert(IMG->fmt == SWITCH_IMG_FMT_I420);

        if (img->fmt == SWITCH_IMG_FMT_ARGB) {
                int max_w = MIN(img->d_w, IMG->d_w - abs(x));
                int max_h = MIN(img->d_h, IMG->d_h - abs(y));
                int j;
                uint8_t alpha;
                switch_rgb_color_t *rgb;

                for (i = 0; i < max_h; i++) {
                        for (j = 0; j < max_w; j++) {
                                rgb = (switch_rgb_color_t *)(img->planes[SWITCH_PLANE_PACKED] + i * img->stride[SWITCH_PLANE_PACKED] + j * 4);
                                alpha = rgb->a;

                                if (alpha == 255) {
                                        switch_img_draw_pixel(IMG, x + j, y + i, rgb);
                                } else if (alpha != 0) {
                                        switch_rgb_color_t RGB = { 0 };
                                        
                                        switch_img_get_rgb_pixel(IMG, &RGB, x + j, y + i);
                                        RGB.a = 255;
                                        RGB.r = ((RGB.r * (255 - alpha)) >> 8) + ((rgb->r * alpha) >> 8);
                                        RGB.g = ((RGB.g * (255 - alpha)) >> 8) + ((rgb->g * alpha) >> 8);
                                        RGB.b = ((RGB.b * (255 - alpha)) >> 8) + ((rgb->b * alpha) >> 8);
                                        
                                        switch_img_draw_pixel(IMG, x + j, y + i, &RGB);
                                }
                        }
                }

                return;

#ifdef HAVE_LIBGD
        } else if (img->fmt == SWITCH_IMG_FMT_GD) {
                gdImagePtr gd = (gdImagePtr)img->user_priv;
                switch_rgb_color_t rgb_color;
                int pixel;
                int i, j;

                switch_assert(gd);

                if (!gd->trueColor) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "GD is experimental, only true color image is supported\n");
                        return;
                }
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "truecolor: %d alpha: %d, transparent? %d\n", gd->trueColor, gd->saveAlphaFlag, gd->transparent);

                for(i = 0; i < img->d_h; i++) {
                        for(j = 0; j < img->d_w; j++) {
                                pixel = gd->tpixels[i][j];
                                rgb_color.a = 255; // TODO: handle transparent
                                rgb_color.r = gdTrueColorGetRed(pixel);
                                rgb_color.g = gdTrueColorGetGreen(pixel);
                                rgb_color.b = gdTrueColorGetBlue(pixel);
                                switch_img_draw_pixel(IMG, x + j, y + i, &rgb_color);
                        }
                }

                return;
#endif

        }

        if (x < 0) {
                xoff = -x;
                x = 0;
        }

        if (y < 0) {
                yoff = -y;
                y = 0;
        }

        max_h = MIN(y + img->d_h - yoff, IMG->d_h);
        len = MIN(img->d_w - xoff, IMG->d_w - x);


        if (x & 0x1) { x++; len--; }
        if (y & 0x1) y++;
        if (len <= 0) return;

        for (i = y; i < max_h; i++) {
                memcpy(IMG->planes[SWITCH_PLANE_Y] + IMG->stride[SWITCH_PLANE_Y] * i + x, img->planes[SWITCH_PLANE_Y] + img->stride[SWITCH_PLANE_Y] * (i - y + yoff) + xoff, len);
        }

        if ((len & 1) && (x + len) < img->d_w - 1) len++;

        len /= 2;

        for (i = y; i < max_h; i += 2) {
                memcpy(IMG->planes[SWITCH_PLANE_U] + IMG->stride[SWITCH_PLANE_U] * (i / 2) + x / 2, img->planes[SWITCH_PLANE_U] + img->stride[SWITCH_PLANE_U] * ((i - y + yoff) / 2) + xoff / 2, len);
                memcpy(IMG->planes[SWITCH_PLANE_V] + IMG->stride[SWITCH_PLANE_V] * (i / 2) + x / 2, img->planes[SWITCH_PLANE_V] + img->stride[SWITCH_PLANE_V] * ((i - y + yoff) / 2) + xoff / 2, len);
        }
}

switch_img_patch_hole()

void switch_img_patch_hole	(	switch_image_t *	IMG,
		switch_image_t *	img,
		int	x,
		int	y,
		switch_image_rect_t *	rect
	)

Definition at line 2274 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, switch_image_rect::h, MIN, vpx_image::planes, vpx_image::stride, switch_assert, SWITCH_IMG_FMT_I420, SWITCH_PLANE_U, SWITCH_PLANE_V, SWITCH_PLANE_Y, switch_image_rect::w, switch_image_rect::x, and switch_image_rect::y.

{
        int i, len;

        switch_assert(img->fmt == SWITCH_IMG_FMT_I420);
        switch_assert(IMG->fmt == SWITCH_IMG_FMT_I420);

        len = MIN(img->d_w, IMG->d_w - x);
        if (len <= 0) return;

        for (i = y; i < (y + img->d_h) && i < IMG->d_h; i++) {
                if (rect && i >= rect->y && i < (rect->y + rect->h)) {
                        int size = rect->x > x ? rect->x - x : 0;
                        memcpy(IMG->planes[SWITCH_PLANE_Y] + IMG->stride[SWITCH_PLANE_Y] * i + x, img->planes[SWITCH_PLANE_Y] + img->stride[SWITCH_PLANE_Y] * (i - y), size);
                        size = MIN(img->d_w - rect->w - size, IMG->d_w - (rect->x + rect->w));
                        memcpy(IMG->planes[SWITCH_PLANE_Y] + IMG->stride[SWITCH_PLANE_Y] * i + rect->x + rect->w, img->planes[SWITCH_PLANE_Y] + img->stride[SWITCH_PLANE_Y] * (i - y) + rect->w + (rect->x - x), size);
                } else {
                        memcpy(IMG->planes[SWITCH_PLANE_Y] + IMG->stride[SWITCH_PLANE_Y] * i + x, img->planes[SWITCH_PLANE_Y] + img->stride[SWITCH_PLANE_Y] * (i - y), len);
                }
        }

        len /= 2;

        for (i = y; i < (y + img->d_h) && i < IMG->d_h; i += 2) {
                if (rect && i > rect->y && i < (rect->y + rect->h)) {
                        int size = rect->x > x ? rect->x - x : 0;

                        size /= 2;
                        memcpy(IMG->planes[SWITCH_PLANE_U] + IMG->stride[SWITCH_PLANE_U] * (i / 2) + x / 2, img->planes[SWITCH_PLANE_U] + img->stride[SWITCH_PLANE_U] * ((i - y) / 2), size);
                        memcpy(IMG->planes[SWITCH_PLANE_V] + IMG->stride[SWITCH_PLANE_V] * (i / 2) + x / 2, img->planes[SWITCH_PLANE_V] + img->stride[SWITCH_PLANE_V] * ((i - y) / 2), size);
                        size = MIN(img->d_w - rect->w - size, IMG->d_w - (rect->x + rect->w)) / 2;
                        memcpy(IMG->planes[SWITCH_PLANE_U] + IMG->stride[SWITCH_PLANE_U] * (i / 2) + (rect->x + rect->w) / 2, img->planes[SWITCH_PLANE_U] + img->stride[SWITCH_PLANE_U] * ((i - y) / 2) + (rect->w + (rect->x - x)) / 2, size);
                        memcpy(IMG->planes[SWITCH_PLANE_V] + IMG->stride[SWITCH_PLANE_V] * (i / 2) + (rect->x + rect->w) / 2, img->planes[SWITCH_PLANE_V] + img->stride[SWITCH_PLANE_V] * ((i - y) / 2) + (rect->w + (rect->x - x)) / 2, size);
                } else {
                        memcpy(IMG->planes[SWITCH_PLANE_U] + IMG->stride[SWITCH_PLANE_U] * (i / 2) + x / 2, img->planes[SWITCH_PLANE_U] + img->stride[SWITCH_PLANE_U] * ((i - y) / 2), len);
                        memcpy(IMG->planes[SWITCH_PLANE_V] + IMG->stride[SWITCH_PLANE_V] * (i / 2) + x / 2, img->planes[SWITCH_PLANE_V] + img->stride[SWITCH_PLANE_V] * ((i - y) / 2), len);
                }
        }
}

switch_img_patch_rect()

void switch_img_patch_rect	(	switch_image_t *	IMG,
		int	X,
		int	Y,
		switch_image_t *	img,
		uint32_t	x,
		uint32_t	y,
		uint32_t	w,
		uint32_t	h
	)

patch part of a small img (x,y,w,h) to a big IMG at position X,Y

Both IMG and img must be non-NULL

Parameters

[in]	IMG	The BIG Image descriptor
[in]	X	Leftmost pos to patch to IMG
[in]	Y	Topmost pos to patch to IMG
[in]	img	The small Image descriptor
[in]	x	Leftmost pos to be read from img
[in]	y	Topmost pos to be read from
[in]	w	Max width to be read from img
[in]	h	Max height to be read from img

Definition at line 546 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, MIN, vpx_image::planes, vpx_image::stride, switch_img_copy(), SWITCH_IMG_FMT_PLANAR, switch_img_free(), switch_img_patch(), switch_img_set_rect(), SWITCH_PLANE_PACKED, SWITCH_PLANE_Y, and vpx_img_wrap().

{
#ifdef SWITCH_HAVE_VPX
        switch_image_t *tmp = NULL;
        uint8_t *data;

        if (x >= img->d_w || y >= img->d_h) return;

        if (w == img->d_w && h == img->d_h) {
                switch_img_patch(IMG, img, X, Y);
                return;
        }

        if (!(img->fmt & SWITCH_IMG_FMT_PLANAR)) {
                data = img->planes[SWITCH_PLANE_PACKED];
        } else {
                data = img->planes[SWITCH_PLANE_Y];
        }

        if (img->d_w == img->stride[0]) {
                tmp = (switch_image_t *)vpx_img_wrap(NULL, img->fmt, img->d_w, img->d_h, 1, data);
        } else {
                switch_img_copy(img, &tmp);
        }

        if (!tmp) return;

        w = MIN(img->d_w - x, w);
        h = MIN(img->d_h - y, h);

        if (!switch_img_set_rect(tmp, x, y, w, h)) {
                switch_img_patch(IMG, tmp, X, Y);
        }

        switch_img_free(&tmp);
#endif
}

switch_img_patch_rgb()

void switch_img_patch_rgb	(	switch_image_t *	IMG,
		switch_image_t *	img,
		int	x,
		int	y,
		switch_bool_t	noalpha
	)

patch a small img to a big IMG at position x,y

Both IMG and img must be non-NULL

Parameters

[in]	IMG	The BIG Image descriptor
[in]	img	The small Image descriptor
[in]	x	Leftmost pos to patch to
[in]	y	Topmost pos to patch to
[in]	noalpha	skip writing to non-transparent pixels

Definition at line 390 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, MIN, vpx_image::planes, vpx_image::stride, SWITCH_IMG_FMT_ARGB, and SWITCH_PLANE_PACKED.

Referenced by switch_img_patch().

{
#ifdef SWITCH_HAVE_YUV
        int i;

        if (noalpha) {
                switch_img_patch_rgb_noalpha(IMG, img, x, y);
                return;
        }

        if (img->fmt == SWITCH_IMG_FMT_ARGB && IMG->fmt == SWITCH_IMG_FMT_ARGB) {
                uint8_t* src_argb0 = img->planes[SWITCH_PLANE_PACKED];
                int src_stride_argb0 = img->stride[SWITCH_PLANE_PACKED];
                uint8_t* src_argb1 = IMG->planes[SWITCH_PLANE_PACKED];
                int src_stride_argb1 = IMG->stride[SWITCH_PLANE_PACKED];
                uint8_t* dst_argb = IMG->planes[SWITCH_PLANE_PACKED];
                int dst_stride_argb = IMG->stride[SWITCH_PLANE_PACKED];
                int width = MIN(img->d_w, IMG->d_w - abs(x));
                int height = MIN(img->d_h, IMG->d_h - abs(y));
                void (*ARGBBlendRow)(const uint8_t* src_argb, const uint8_t* src_argb1, uint8_t* dst_argb, int width) = GetARGBBlend();

                // switch_img_attenuate(img);

                // Coalesce rows. we have same size images, treat as a single row
                if (src_stride_argb0 == width * 4 &&
                        src_stride_argb1 == width * 4 &&
                        x == 0 && y == 0) {
                        width *= height;
                        height = 1;
                        src_stride_argb0 = src_stride_argb1 = dst_stride_argb = 0;
                }

                if (y) {
                        src_argb1 += (y * IMG->d_w * 4);
                        dst_argb  += (y * IMG->d_w * 4);
                }
                if (x) {
                        src_argb1 += (x * 4);
                        dst_argb  += (x * 4);
                }

                for (i = 0; i < height; ++i) {
                        ARGBBlendRow(src_argb0, src_argb1, dst_argb, width);
                        src_argb0 += src_stride_argb0;
                        src_argb1 += src_stride_argb1;
                        dst_argb += dst_stride_argb;
                }
        }
#endif
}

switch_img_read_file()

switch_image_t* switch_img_read_file

(

const char *

file_name

)

Definition at line 3773 of file switch_core_video.c.

Referenced by switch_img_find_position().

{
        return NULL;
}

switch_img_read_from_file()

switch_image_t* switch_img_read_from_file	(	const char *	file_name,
		switch_img_fmt_t	img_fmt
	)

Read an image file to switch_image_t.

Definition at line 3117 of file switch_core_video.c.

References vpx_image::planes, vpx_image::stride, switch_assert, switch_img_alloc(), SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_I420, SWITCH_PLANE_PACKED, SWITCH_PLANE_U, SWITCH_PLANE_V, and SWITCH_PLANE_Y.

{
#ifdef SWITCH_HAVE_YUV
        int width = 0, height = 0, channels = 0;
        int comp = STBI_rgb;
        unsigned char *data = NULL;

        if (img_fmt == SWITCH_IMG_FMT_I420) {
                comp = STBI_rgb;
        } else if (img_fmt == SWITCH_IMG_FMT_ARGB) {
                comp = STBI_rgb_alpha;
        } else {
                return NULL;
        }

        data = stbi_load(file_name, &width, &height, &channels, comp);
        // switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "%dx%d channels=%d\n", width, height, channels);

        if (data && width > 0 && height > 0) {
                switch_image_t *img = switch_img_alloc(NULL, img_fmt, width, height, 1);
                switch_assert(img);

                if (img_fmt == SWITCH_IMG_FMT_I420) {
                        RAWToI420(data, width * 3,
                                        img->planes[SWITCH_PLANE_Y], img->stride[SWITCH_PLANE_Y],
                                        img->planes[SWITCH_PLANE_U], img->stride[SWITCH_PLANE_U],
                                        img->planes[SWITCH_PLANE_V], img->stride[SWITCH_PLANE_V],
                                        width, height);
                } else if (img_fmt == SWITCH_IMG_FMT_ARGB) {
#if SWITCH_BYTE_ORDER == __BIG_ENDIAN
                        RGBAToARGB(data, width * 4, img->planes[SWITCH_PLANE_PACKED], img->stride[SWITCH_PLANE_PACKED], width, height);
#else
                        ABGRToARGB(data, width * 4, img->planes[SWITCH_PLANE_PACKED], img->stride[SWITCH_PLANE_PACKED], width, height);
#endif
                }

                stbi_image_free(data);

                return img;
        } else if (data) {
                stbi_image_free(data);
        }
#endif

        return NULL;
}

switch_img_read_png()

switch_image_t* switch_img_read_png	(	const char *	file_name,
		switch_img_fmt_t	img_fmt
	)

Definition at line 3097 of file switch_core_video.c.

References SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, and switch_log_printf().

Referenced by switch_ivr_video_write_overlay_session(), and video_helper_thread().

{
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "This function is not available, libpng not installed\n");
        return NULL;
}

switch_img_read_png_from_memory()

switch_image_t* switch_img_read_png_from_memory	(	void *	mem,
		size_t	size,
		switch_img_fmt_t	img_fmt
	)

switch_img_rotate()

void switch_img_rotate	(	switch_image_t **	img,
		switch_image_rotation_mode_t	mode
	)

Flip the image vertically (top for bottom)

Adjusts the image descriptor's pointers and strides to make the image be referenced upside-down.

Parameters

[in]

img

Image descriptor

Returns

0 if the requested rectangle is valid, nonzero otherwise.

Definition at line 262 of file switch_core_video.c.

References vpx_image::planes, SRM_270, SRM_90, vpx_image::stride, switch_assert, switch_img_alloc(), SWITCH_IMG_FMT_I420, switch_img_free(), SWITCH_PLANE_U, SWITCH_PLANE_V, and SWITCH_PLANE_Y.

{
#ifdef SWITCH_HAVE_YUV
        switch_image_t *tmp_img;

        switch_assert(img);


        if ((*img)->fmt != SWITCH_IMG_FMT_I420) return;

        if (mode == SRM_90 || mode == SRM_270) {
                tmp_img = switch_img_alloc(NULL, (*img)->fmt, (*img)->d_h, (*img)->d_w, 1);
        } else {
                tmp_img = switch_img_alloc(NULL, (*img)->fmt, (*img)->d_w, (*img)->d_h, 1);
        }

        switch_assert(tmp_img);

        I420Rotate((*img)->planes[SWITCH_PLANE_Y], (*img)->stride[SWITCH_PLANE_Y],
                           (*img)->planes[SWITCH_PLANE_U], (*img)->stride[SWITCH_PLANE_U],
                           (*img)->planes[SWITCH_PLANE_V], (*img)->stride[SWITCH_PLANE_V],
                           tmp_img->planes[SWITCH_PLANE_Y], tmp_img->stride[SWITCH_PLANE_Y],
                           tmp_img->planes[SWITCH_PLANE_U], tmp_img->stride[SWITCH_PLANE_U],
                           tmp_img->planes[SWITCH_PLANE_V], tmp_img->stride[SWITCH_PLANE_V],
                           (*img)->d_w, (*img)->d_h, (int)mode);


        switch_img_free(img);
        *img = tmp_img;

#endif
}

switch_img_rotate_copy()

void switch_img_rotate_copy	(	switch_image_t *	img,
		switch_image_t **	new_img,
		switch_image_rotation_mode_t	mode
	)

Definition at line 650 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, vpx_image::planes, SRM_270, SRM_90, vpx_image::stride, switch_assert, switch_img_alloc(), SWITCH_IMG_FMT_I420, switch_img_free(), SWITCH_PLANE_U, SWITCH_PLANE_V, and SWITCH_PLANE_Y.

{
        switch_assert(img);
        switch_assert(new_img);

#ifdef SWITCH_HAVE_YUV
        if (img->fmt != SWITCH_IMG_FMT_I420) abort();

        if (*new_img != NULL) {
                if (img->fmt != (*new_img)->fmt || img->d_w != (*new_img)->d_w || img->d_h != (*new_img)->d_h) {
                        switch_img_free(new_img);
                }
        }

        if (*new_img == NULL) {
                if (mode == SRM_90 || mode == SRM_270) {
                        *new_img = switch_img_alloc(NULL, img->fmt, img->d_h, img->d_w, 1);
                } else {
                        *new_img = switch_img_alloc(NULL, img->fmt, img->d_w, img->d_h, 1);
                }
        }

        switch_assert(*new_img);


        I420Rotate(img->planes[SWITCH_PLANE_Y], img->stride[SWITCH_PLANE_Y],
                           img->planes[SWITCH_PLANE_U], img->stride[SWITCH_PLANE_U],
                           img->planes[SWITCH_PLANE_V], img->stride[SWITCH_PLANE_V],
                           (*new_img)->planes[SWITCH_PLANE_Y], (*new_img)->stride[SWITCH_PLANE_Y],
                           (*new_img)->planes[SWITCH_PLANE_U], (*new_img)->stride[SWITCH_PLANE_U],
                           (*new_img)->planes[SWITCH_PLANE_V], (*new_img)->stride[SWITCH_PLANE_V],
                           img->d_w, img->d_h, (int)mode);
#else
        return;
#endif
}

switch_img_scale()

switch_status_t switch_img_scale	(	switch_image_t *	src,
		switch_image_t **	destP,
		int	width,
		int	height
	)

Definition at line 3592 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, vpx_image::planes, vpx_image::stride, switch_assert, SWITCH_CHANNEL_LOG, switch_img_alloc(), SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_I420, switch_img_free(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_PLANE_PACKED, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_media_bug_patch_spy_frame(), switch_img_fit(), and switch_img_letterbox().

{
#ifdef SWITCH_HAVE_YUV
        switch_image_t *dest = NULL;
        int ret = 0;

        if (!destP) {
                return SWITCH_STATUS_FALSE;
        }

        dest = *destP;

        switch_assert(width > 0);
        switch_assert(height > 0);
        
        if (dest && src->fmt != dest->fmt) switch_img_free(&dest);

        if (!dest) dest = switch_img_alloc(NULL, src->fmt, width, height, 1);

        if (src->fmt == SWITCH_IMG_FMT_I420) {
                ret = I420Scale(src->planes[0], src->stride[0],
                                                src->planes[1], src->stride[1],
                                                src->planes[2], src->stride[2],
                                                src->d_w, src->d_h,
                                                dest->planes[0], dest->stride[0],
                                                dest->planes[1], dest->stride[1],
                                                dest->planes[2], dest->stride[2],
                                                width, height,
                                                kFilterBox);
        } else if (src->fmt == SWITCH_IMG_FMT_ARGB) {
                ret = ARGBScale(src->planes[SWITCH_PLANE_PACKED], src->d_w * 4,
                                src->d_w, src->d_h,
                                dest->planes[SWITCH_PLANE_PACKED], width * 4,
                                width, height,
                                kFilterBox);
        }

        *destP = dest;

        if (ret != 0) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Scaling Error: ret: %d\n", ret);
                return SWITCH_STATUS_FALSE;
        }

        return SWITCH_STATUS_SUCCESS;
#else
        return SWITCH_STATUS_FALSE;
#endif
}

switch_img_sepia()

void switch_img_sepia	(	switch_image_t *	img,
		int	x,
		int	y,
		int	w,
		int	h
	)

Definition at line 1517 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, memset(), MIN, vpx_image::planes, vpx_image::stride, SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_I420, SWITCH_PLANE_PACKED, SWITCH_PLANE_U, and SWITCH_PLANE_V.

{
#ifdef SWITCH_HAVE_YUV
        if (x < 0 || y < 0 || x >= img->d_w || y >= img->d_h) return;

        if (img->fmt == SWITCH_IMG_FMT_ARGB) {
                ARGBSepia(img->planes[SWITCH_PLANE_PACKED], img->stride[SWITCH_PLANE_PACKED], x, y, w, h);
        } else if (img->fmt == SWITCH_IMG_FMT_I420) {
                int len, i, max_h;

                max_h = MIN(y + h, img->d_h);
                len = MIN(w, img->d_w - x);

                if (x & 1) { x++; len--; }
                if (y & 1) y++;
                if (len <= 0) return;

                if ((len & 1) && (x + len) < img->d_w - 1) len++;

                len /= 2;

                for (i = y; i < max_h; i += 2) {
                        memset(img->planes[SWITCH_PLANE_U] + img->stride[SWITCH_PLANE_U] * (i / 2) + x / 2, 108, len);
                        memset(img->planes[SWITCH_PLANE_V] + img->stride[SWITCH_PLANE_V] * (i / 2) + x / 2, 137, len);
                }
        }
#endif
}

switch_img_set_rect()

int switch_img_set_rect	(	switch_image_t *	img,
		unsigned int	x,
		unsigned int	y,
		unsigned int	w,
		unsigned int	h
	)

Set the rectangle identifying the displayed portion of the image.

Updates the displayed rectangle (aka viewport) on the image surface to match the specified coordinates and size.

Parameters

[in]	img	Image descriptor
[in]	x	leftmost column
[in]	y	topmost row
[in]	w	width
[in]	h	height

Returns

0 if the requested rectangle is valid, nonzero otherwise.

Definition at line 249 of file switch_core_video.c.

References vpx_img_set_rect().

Referenced by switch_img_copy_rect(), and switch_img_patch_rect().

{
#ifdef SWITCH_HAVE_VPX
        return vpx_img_set_rect((vpx_image_t *)img, x, y, w, h);
#else
        return 0;
#endif
}

switch_img_to_raw()

switch_status_t switch_img_to_raw	(	switch_image_t *	src,
		void *	dest,
		int	stride,
		switch_img_fmt_t	fmt
	)

convert img to raw format

dest should be pre-allocated and big enough for the target fmt

Parameters

[in]	src	The image descriptor
[in]	dest	The target memory address
[in]	stride	Bytes in a row for the destination. Pass 0 if the buffer has contiguous rows. Can be negative. A multiple of 16 is optimal.
[in]	fmt	The target format

Definition at line 3487 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, vpx_image::planes, vpx_image::stride, switch_assert, SWITCH_CHANNEL_LOG, SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_I420, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_PLANE_PACKED, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
#ifdef SWITCH_HAVE_YUV
        uint32_t fourcc;
        int ret;

        switch_assert(dest);

        fourcc = switch_img_fmt2fourcc(fmt);

        if (fourcc == FOURCC_ANY) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "unsupported format: %d\n", fmt);
                return SWITCH_STATUS_FALSE;
        }

        if (src->fmt == SWITCH_IMG_FMT_I420) {
                ret = ConvertFromI420(src->planes[0], src->stride[0],
                                                src->planes[1], src->stride[1],
                                                src->planes[2], src->stride[2],
                                                dest, stride,
                                                src->d_w, src->d_h,
                                                fourcc);
        } else if (src->fmt == SWITCH_IMG_FMT_ARGB && fmt == src->fmt) {
                ret = ARGBCopy(src->planes[SWITCH_PLANE_PACKED], src->stride[SWITCH_PLANE_PACKED],
                                                dest, stride,
                                                src->d_w, src->d_h);
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Convertion not supported %d -> %d\n", src->fmt, fmt);
                return SWITCH_STATUS_FALSE;
        }

        return ret == 0 ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
#else
        return SWITCH_STATUS_FALSE;
#endif
}

switch_img_txt_handle_create()

switch_status_t switch_img_txt_handle_create	(	switch_img_txt_handle_t **	handleP,
		const char *	font_family,
		const char *	font_color,
		const char *	bgcolor,
		uint16_t	font_size,
		double	angle,
		switch_memory_pool_t *	pool
	)

Created a text handle.

Parameters

[out]	handleP	Pointer to the text handle pointer
[in]	font_family	Font family
[in]	font_color	Font color in #RRGGBB format
[in]	bgcolor	Background color in #RRGGBB format
[in]	font_size	Font size in point
[in]	angle	Angle to rotate
[in]	pool	APR memory pool

Definition at line 1864 of file switch_core_video.c.

References switch_img_txt_handle_s::angle, switch_img_txt_handle_s::bgcolor, switch_img_txt_handle_s::color, switch_img_txt_handle_s::font_family, switch_img_txt_handle_s::font_size, switch_directories::fonts_dir, switch_img_txt_handle_s::free_pool, init_gradient_table(), pool, switch_img_txt_handle_s::pool, SWITCH_CHANNEL_LOG, switch_color_set_rgb(), switch_core_alloc, switch_core_destroy_memory_pool, switch_core_new_memory_pool, switch_core_sprintf(), switch_core_strdup, switch_file_exists(), SWITCH_GLOBAL_dirs, switch_is_file_path(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_PATH_SEPARATOR, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and zstr.

Referenced by switch_img_write_text_img().

{
        int free_pool = 0;
        switch_img_txt_handle_t *new_handle;

        if (!pool) {
                free_pool = 1;
                switch_core_new_memory_pool(&pool);
        }

        new_handle = switch_core_alloc(pool, sizeof(*new_handle));

#if SWITCH_HAVE_FREETYPE
        if (FT_Init_FreeType(&new_handle->library)) {
                return SWITCH_STATUS_FALSE;
        }
/*#else
        return SWITCH_STATUS_FALSE; */
#endif

        new_handle->pool = pool;
        new_handle->free_pool = free_pool;

        if (zstr(font_family)) {
                font_family = switch_core_sprintf(new_handle->pool, "%s%s%s",SWITCH_GLOBAL_dirs.fonts_dir, SWITCH_PATH_SEPARATOR, "FreeSans.ttf");
        }

        if (!switch_is_file_path(font_family)) {
                new_handle->font_family = switch_core_sprintf(new_handle->pool, "%s%s%s",SWITCH_GLOBAL_dirs.fonts_dir, SWITCH_PATH_SEPARATOR, font_family);
        } else {
                new_handle->font_family = switch_core_strdup(new_handle->pool, font_family);
        }

        if (switch_file_exists(new_handle->font_family, new_handle->pool) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Font %s does not exist\n", new_handle->font_family);
#if SWITCH_HAVE_FREETYPE
                if (new_handle->library) {
                        FT_Done_FreeType(new_handle->library);
                        new_handle->library = NULL;
                }
#endif
                if (free_pool) {
                        switch_core_destroy_memory_pool(&pool);
                }
                *handleP = NULL;
                return SWITCH_STATUS_FALSE;
        }

        new_handle->font_size = font_size;
        new_handle->angle = angle;

        switch_color_set_rgb(&new_handle->color, font_color);
        switch_color_set_rgb(&new_handle->bgcolor, bgcolor);

        init_gradient_table(new_handle);

        *handleP = new_handle;

        return SWITCH_STATUS_SUCCESS;
}

switch_img_txt_handle_destroy()

void switch_img_txt_handle_destroy

(

switch_img_txt_handle_t **

handleP

)

Free a text handle.

Parameters

[in]

handleP

Pointer to the text handle pointer

Definition at line 1927 of file switch_core_video.c.

References switch_rgb_color_s::a, switch_rgb_color_s::b, switch_img_txt_handle_s::color, vpx_image::d_h, vpx_image::d_w, switch_img_txt_handle_s::free_pool, switch_rgb_color_s::g, switch_img_txt_handle_s::gradient_table, MAX_GRADIENT, pool, switch_img_txt_handle_s::pool, switch_rgb_color_s::r, switch_assert, SWITCH_CHANNEL_LOG, switch_core_destroy_memory_pool, switch_img_draw_pixel(), switch_img_get_rgb_pixel(), switch_log_printf(), SWITCH_LOG_WARNING, and switch_img_txt_handle_s::use_bgcolor.

Referenced by switch_img_write_text_img().

{
        switch_img_txt_handle_t *old_handle;
        switch_memory_pool_t *pool;

        switch_assert(handleP);

        old_handle = *handleP;
        *handleP = NULL;
        if (!old_handle) return;


#if SWITCH_HAVE_FREETYPE
        if (old_handle->library) {
                FT_Done_FreeType(old_handle->library);
                old_handle->library = NULL;
        }
#endif
        pool = old_handle->pool;

        if (old_handle->free_pool) {
                switch_core_destroy_memory_pool(&pool);
                pool = NULL;
                old_handle = NULL;
        }

}

switch_img_txt_handle_render()

uint32_t switch_img_txt_handle_render	(	switch_img_txt_handle_t *	handle,
		switch_image_t *	img,
		int	x,
		int	y,
		const char *	text,
		const char *	font_family,
		const char *	font_color,
		const char *	bgcolor,
		uint16_t	font_size,
		double	angle
	)

Render text to an img.

Parameters

[in]	handle	Pointer to the text handle pointer
[in]	img	The image to be render text on
[in]	x	Leftmost position
[in]	y	Topmost position
[in]	text	Text to render
[in]	font_family	Font to use, NULL to use the handle font
[in]	font_color	Font color, NULL to use the handle color
[in]	bgcolor	Background color, NULL for transparency
[in]	font_size	Font size in point
[in]	angle	Angle to rotate

Definition at line 2025 of file switch_core_video.c.

References switch_img_txt_handle_s::angle, switch_img_txt_handle_s::bgcolor, switch_img_txt_handle_s::color, vpx_image::fmt, switch_img_txt_handle_s::font_family, switch_img_txt_handle_s::font_size, index, init_gradient_table(), switch_img_txt_handle_s::pool, switch_assert, SWITCH_CHANNEL_LOG, switch_color_set_rgb(), switch_core_strdup, SWITCH_FALSE, SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_I420, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_TRUE, switch_u8_get_char(), switch_img_txt_handle_s::use_bgcolor, and zstr.

Referenced by switch_img_write_text_img().

{
#if SWITCH_HAVE_FREETYPE
        FT_GlyphSlot  slot;
        FT_Matrix     matrix; /* transformation matrix */
        FT_Vector     pen;    /* untransformed origin  */
        FT_Error      error;
        //int           target_height;
        int           index = 0;
        FT_ULong      ch;
        FT_Face face;
        uint32_t width = 0;
        int this_x = 0, last_x = 0, space = 0;
        uint32_t ret;

        if (zstr(text)) return 0;

        if (!handle) return 0;

        switch_assert(!img || img->fmt == SWITCH_IMG_FMT_I420 || img->fmt == SWITCH_IMG_FMT_ARGB);

        if (font_family) {
                handle->font_family = switch_core_strdup(handle->pool, font_family);
        } else {
                font_family = handle->font_family;
        }

        if (font_size) {
                handle->font_size = font_size;
        } else {
                font_size = handle->font_size;
        }

        if (font_color) {
                switch_color_set_rgb(&handle->color, font_color);
        }

        if (bgcolor) {
                switch_color_set_rgb(&handle->bgcolor, bgcolor);
                handle->use_bgcolor = SWITCH_TRUE;
        } else {
                handle->use_bgcolor = SWITCH_FALSE;
        }

        handle->angle = angle;

        //angle         = 0; (45.0 / 360 ) * 3.14159 * 2;

        //target_height = img->d_h;

        error = FT_New_Face(handle->library, font_family, 0, &face); /* create face object */
        if (error) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to open font %s\n", font_family);
                return 0;
        }

        error = FT_Set_Char_Size(face, 64 * font_size, 0, 96, 0); /* set character size */
        if (error) return 0;

        slot = face->glyph;

        if (handle->use_bgcolor && slot->bitmap.pixel_mode != FT_PIXEL_MODE_MONO) {
                init_gradient_table(handle);
        }

        /* set up matrix */
        matrix.xx = (FT_Fixed)( cos( angle ) * 0x10000L );
        matrix.xy = (FT_Fixed)(-sin( angle ) * 0x10000L );
        matrix.yx = (FT_Fixed)( sin( angle ) * 0x10000L );
        matrix.yy = (FT_Fixed)( cos( angle ) * 0x10000L );

        pen.x = x;
        pen.y = y;

        while(*(text + index)) {
                ch = switch_u8_get_char((char *)text, &index);

                if (ch == '\n') {
                        pen.x = x;
                        pen.y += (font_size + font_size / 4);
                        continue;
                }

                /* set transformation */
                FT_Set_Transform(face, &matrix, &pen);

                /* load glyph image into the slot (erase previous one) */
                error = FT_Load_Char(face, ch, FT_LOAD_RENDER);

                if (error) continue;

                this_x = pen.x + slot->bitmap_left;

                if (img) {
                        /* now, draw to our target surface (convert position) */
                        draw_bitmap(handle, img, &slot->bitmap, this_x, pen.y - slot->bitmap_top + font_size);
                }

                if (last_x) {
                        space = this_x - last_x;
                } else {
                        space = 0;
                }

                last_x = this_x;

                width += space;

                /* increment pen position */
                pen.x += slot->advance.x >> 6;
                pen.y += slot->advance.y >> 6;
        }

        ret = width + slot->bitmap.width * 5;

        FT_Done_Face(face);

        return ret;
#else
        return 0;
#endif
}

switch_img_wrap()

switch_image_t* switch_img_wrap	(	switch_image_t *	img,
		switch_img_fmt_t	fmt,
		unsigned int	d_w,
		unsigned int	d_h,
		unsigned int	align,
		unsigned char *	img_data
	)

Open a descriptor, using existing storage for the underlying image.

Returns a descriptor for storing an image of the given format. The storage for descriptor has been allocated elsewhere, and a descriptor is desired to "wrap" that storage.

Parameters

[in]	img	Pointer to storage for descriptor. If this parameter is NULL, the storage for the descriptor will be allocated on the heap.
[in]	fmt	Format for the image
[in]	d_w	Width of the image
[in]	d_h	Height of the image
[in]	align	Alignment, in bytes, of each row in the image.
[in]	img_data	Storage to use for the image

Returns

Returns a pointer to the initialized image descriptor. If the img parameter is non-null, the value of the img parameter will be returned.

Definition at line 235 of file switch_core_video.c.

References vpx_img_wrap().

{
#ifdef SWITCH_HAVE_VPX
        return (switch_image_t *)vpx_img_wrap((vpx_image_t *)img, (vpx_img_fmt_t)fmt, d_w, d_h, align, img_data);
#else
        return NULL;
#endif
}

switch_img_write_png()

switch_status_t switch_img_write_png	(	switch_image_t *	img,
		char *	file_name
	)

Definition at line 3103 of file switch_core_video.c.

References SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, switch_log_printf(), and SWITCH_STATUS_FALSE.

{
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "This function is not available, libpng not installed\n");
        return SWITCH_STATUS_FALSE;
}

switch_img_write_text_img()

switch_image_t* switch_img_write_text_img	(	int	w,
		int	h,
		switch_bool_t	full,
		const char *	text
	)

Definition at line 2151 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, end_of, memset(), vpx_image::planes, switch_assert, switch_color_set_rgb(), switch_img_alloc(), switch_img_fill(), SWITCH_IMG_FMT_ARGB, switch_img_txt_handle_create(), switch_img_txt_handle_destroy(), switch_img_txt_handle_render(), SWITCH_PLANE_PACKED, switch_safe_free, switch_split, switch_url_decode(), and zstr.

{
        const char *fg ="#cccccc";
        const char *bg = "#142e55";
        // const char *bg = NULL; // use a NULL bg for transparent
        const char *font_face = NULL;
        const char *fontsz = "4%";
        char *txt = "Value Optimized Out!";
        int argc = 0;
        char *argv[6] = { 0 };
        switch_rgb_color_t bgcolor = { 0 };
        int pre_width = 0, width = 0, font_size = 0, height = 0;
        char *duptxt = strdup(text);
        switch_img_txt_handle_t *txthandle = NULL;
        switch_image_t *txtimg = NULL;
        int x = 0, y = 0;

        if (!duptxt) {
                return NULL;
        }

        if (strchr(text, ':')) {
                argc = switch_split(duptxt, ':', argv);

                if (argc > 0 && !zstr(argv[0])) {
                        fg = argv[0];
                }

                if (argc > 1 && !zstr(argv[1])) {
                        bg = argv[1];
                        if (!strcasecmp(bg, "transparent")) {
                                bg = NULL;
                        }
                }

                if (argc > 2 && !zstr(argv[2])) {
                        font_face = argv[2];
                }

                if (argc > 3 && !zstr(argv[3])) {
                        fontsz = argv[3];
                }

                if (argc > 4) {
                        txt = argv[4];
                }
        } else txt = duptxt;

        if (!txt) txt = duptxt;

        if (strrchr(fontsz, '%')) {
                font_size = 1 + ((int) (float)h * (atof(fontsz) / 100.0f));
        } else {
                font_size = atoi(fontsz);
        }

        switch_url_decode(txt);

        while (*txt == ' ') txt++;
        while (end_of(txt) == ' ') end_of(txt) = '\0';

        switch_img_txt_handle_create(&txthandle, font_face, fg, bg, font_size, 0, NULL);

        pre_width = switch_img_txt_handle_render(txthandle,
                                                                                         NULL,
                                                                                         font_size / 2, font_size / 2,
                                                                                         txt, NULL, fg, bg, 0, 0);

        height = font_size * 2;

        if (full && w > width) {
                width = w;
        } else {
                width = pre_width;
        }

        if (width == 0 || height == 0) {
                txtimg = NULL;
                goto done;
        }
        
        //if (bg) {
        //      txtimg = switch_img_alloc(NULL, SWITCH_IMG_FMT_I420, width, height, 1);
        //      switch_assert(txtimg);
        //      switch_img_fill(txtimg, 0, 0, txtimg->d_w, txtimg->d_h, &bgcolor);
        //} else {
        txtimg = switch_img_alloc(NULL, SWITCH_IMG_FMT_ARGB, width, height, 1);
        switch_assert(txtimg);
        //memset(txtimg->planes[SWITCH_PLANE_PACKED], 0, width * height * 4);
        if (bg) {
                switch_color_set_rgb(&bgcolor, bg);
                switch_img_fill(txtimg, 0, 0, txtimg->d_w, txtimg->d_h, &bgcolor);
        } else {
                memset(txtimg->planes[SWITCH_PLANE_PACKED], 0, width * height * 4);
        }
                //}

        x = font_size / 2;
        y = font_size / 2;

        if (full) {
                x = (txtimg->d_w / 2) - (pre_width / 2);
        }

        switch_img_txt_handle_render(txthandle,
                                                                txtimg,
                                                                x, y,
                                                                txt, NULL, fg, bg, 0, 0);

 done:
        
        switch_img_txt_handle_destroy(&txthandle);

        switch_safe_free(duptxt);

        return txtimg;
}

switch_img_write_to_file()

switch_status_t switch_img_write_to_file	(	switch_image_t *	img,
		const char *	file_name,
		int	quality
	)

Write an image file, supported formats png,jpg,bmp,tga,hdr.

Parameters

[in]	img	The image descriptor
[in]	file_name	The file_name to write
[in]	quality	Only used in jpg, 1 ~ 100

Definition at line 3164 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, vpx_image::fmt, vpx_image::planes, vpx_image::stride, switch_assert, SWITCH_CHANNEL_LOG, SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_I420, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_PLANE_PACKED, SWITCH_PLANE_U, SWITCH_PLANE_V, SWITCH_PLANE_Y, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
#ifndef SWITCH_HAVE_YUV
        return SWITCH_STATUS_FALSE;
#else
        int comp = STBI_rgb;
        unsigned char *data = NULL;
        const char *ext = strrchr(file_name, '.');
        int stride_in_bytes = 0;
        int ret = 0;

        if (!ext) return SWITCH_STATUS_FALSE;

        ext++;

        if (img->fmt == SWITCH_IMG_FMT_I420) {
                comp = STBI_rgb;
                stride_in_bytes = img->d_w * 3;

                data = malloc(stride_in_bytes * img->d_h);
                switch_assert(data);

                I420ToRAW(img->planes[SWITCH_PLANE_Y], img->stride[SWITCH_PLANE_Y],
                        img->planes[SWITCH_PLANE_U], img->stride[SWITCH_PLANE_U],
                        img->planes[SWITCH_PLANE_V], img->stride[SWITCH_PLANE_V],
                        data, stride_in_bytes,
                        img->d_w, img->d_h);
        } else if (img->fmt == SWITCH_IMG_FMT_ARGB) {
                comp = STBI_rgb_alpha;
                stride_in_bytes = img->d_w * 4;

                data = malloc(stride_in_bytes * img->d_h);
                switch_assert(data);

#if SWITCH_BYTE_ORDER == __BIG_ENDIAN
                ARGBToRGBA(img->planes[SWITCH_PLANE_PACKED], stride_in_bytes, data, stride_in_bytes, img->d_w, img->d_h);
#else
                ARGBToABGR(img->planes[SWITCH_PLANE_PACKED], stride_in_bytes, data, stride_in_bytes, img->d_w, img->d_h);
#endif
        } else {
                return SWITCH_STATUS_FALSE;
        }

        if (!strcasecmp(ext, "png")) {
                ret = stbi_write_png(file_name, img->d_w, img->d_h, comp, (const void *)data, stride_in_bytes);
        } else if (!strcasecmp(ext, "jpg") || !strcasecmp(ext, "jpeg")) {
                ret = stbi_write_jpg(file_name, img->d_w, img->d_h, comp, (const void *)data, quality);
        } else if (!strcasecmp(ext, "bmp")) {
                ret = stbi_write_bmp(file_name, img->d_w, img->d_h, comp, (const void *)data);
        } else if (!strcasecmp(ext, "tga")) {
                ret = stbi_write_tga(file_name, img->d_w, img->d_h, comp, (const void *)data);
        } else if (!strcasecmp(ext, "hdr")) {
                ret = stbi_write_hdr(file_name, img->d_w, img->d_h, comp, (const float *)data);
        } else {
                ret = 0;
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "unsupported file format [%s]", ext);
        }

        free(data);

        return ret ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
#endif
}

switch_png_free()

void switch_png_free

(

switch_png_t **

pngP

)

switch_png_open()

switch_status_t switch_png_open	(	switch_png_t **	pngP,
		const char *	file_name
	)

switch_png_patch_img()

switch_status_t switch_png_patch_img	(	switch_png_t *	use_png,
		switch_image_t *	img,
		int	x,
		int	y
	)

switch_RGBAToARGB()

switch_status_t switch_RGBAToARGB	(	const uint8_t *	src_frame,
		int	src_stride_frame,
		uint8_t *	dst_argb,
		int	dst_stride_argb,
		int	width,
		int	height
	)

Definition at line 3833 of file switch_core_video.c.

References SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
#ifdef SWITCH_HAVE_YUV
        int ret = RGBAToARGB(src_frame, src_stride_frame, dst_argb, dst_stride_argb, width, height);

        return ret == 0 ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
#else
        return SWITCH_STATUS_FALSE;
#endif
}