switch_core_video.c File Reference

#include <switch.h>
#include <switch_utf8.h>

Include dependency graph for switch_core_video.c:

Go to the source code of this file.

Data Structures
struct	pos_el
struct	fit_el
struct	switch_img_txt_handle_s

Macros
#define	MIN(a, b)   ((a) < (b) ? (a) : (b))
#define	MAX(a, b)   ((a) > (b) ? (a) : (b))
#define	CLAMP(val)   MAX(0, MIN(val, 255))
#define	MAX_GRADIENT   8
#define	SWITCH_IMG_MAX_WIDTH   1920 * 2
#define	SWITCH_IMG_MAX_HEIGHT   1080 * 2

Functions
static void	switch_img_get_rgb_pixel (switch_image_t *img, switch_rgb_color_t *rgb, int x, int y)
static void	switch_img_draw_pixel (switch_image_t *img, int x, int y, switch_rgb_color_t *color)
	Convert RGB color to YUV. More...
switch_img_position_t	parse_img_position (const char *name)
switch_img_fit_t	parse_img_fit (const char *name)
switch_bool_t	switch_core_has_video (void)
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_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_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_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)
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_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...
static void	scv_tag (void *buffer, int w, int x, int y, uint8_t n)
void	switch_img_add_text (void *buffer, int w, int x, int y, char *s)
void	switch_color_set_rgb (switch_rgb_color_t *color, const char *str)
	Set RGB color with a string. More...
void	switch_color_set_yuv (switch_yuv_color_t *color, const char *str)
	Set YUV color with a string. More...
static void	init_gradient_table (switch_img_txt_handle_t *handle)
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...
switch_image_t *	switch_img_write_text_img (int w, int h, switch_bool_t full, const char *text)
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_img_patch_png (switch_image_t *img, int x, int y, const char *file_name)
switch_image_t *	switch_img_read_png (const char *file_name, switch_img_fmt_t img_fmt)
switch_status_t	switch_img_write_png (switch_image_t *img, 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_status_t	switch_img_fit (switch_image_t **srcP, int width, int height, switch_img_fit_t fit)
switch_status_t	switch_img_to_raw (switch_image_t *src, void *dest, switch_size_t size, switch_img_fmt_t fmt)
	convert img to raw format More...
switch_status_t	switch_img_from_raw (switch_image_t *dest, void *src, switch_img_fmt_t fmt, int width, int height)
	convert raw memory to switch_img_t More...
switch_status_t	switch_img_scale (switch_image_t *src, switch_image_t **destP, int width, int height)
void	switch_img_find_position (switch_img_position_t pos, int sw, int sh, int iw, int ih, int *xP, int *yP)
switch_image_t *	switch_img_read_file (const char *file_name)
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)

Variables
static struct pos_el	POS_TABLE []
static struct fit_el	IMG_FIT_TABLE []
static uint8_t	scv_art [14][16]

Macro Definition Documentation

#define CLAMP

(

val

)

MAX(0, MIN(val, 255))

Definition at line 770 of file switch_core_video.c.

#define MAX	(		a,
			b
	)		((a) > (b) ? (a) : (b))

Definition at line 286 of file switch_core_video.c.

#define MAX_GRADIENT   8

Definition at line 808 of file switch_core_video.c.

Referenced by init_gradient_table().

#define MIN	(		a,
			b
	)		((a) < (b) ? (a) : (b))

Definition at line 282 of file switch_core_video.c.

Referenced by switch_img_copy_rect(), switch_img_fill(), switch_img_overlay(), switch_img_patch(), switch_img_patch_hole(), and switch_img_patch_rect().

#define SWITCH_IMG_MAX_HEIGHT   1080 * 2

Definition at line 1273 of file switch_core_video.c.

#define SWITCH_IMG_MAX_WIDTH   1920 * 2

Definition at line 1272 of file switch_core_video.c.

Function Documentation

static void init_gradient_table ( switch_img_txt_handle_t *  handle )

static

Definition at line 827 of file switch_core_video.c.

References switch_rgb_color_s::b, switch_img_txt_handle_s::bgcolor, switch_img_txt_handle_s::color, switch_rgb_color_s::g, switch_img_txt_handle_s::gradient_table, MAX_GRADIENT, and switch_rgb_color_s::r.

Referenced by switch_img_txt_handle_create(), and switch_img_txt_handle_render().

{
        int i;
        switch_rgb_color_t *color;

        switch_rgb_color_t *c1 = &handle->bgcolor;
        switch_rgb_color_t *c2 = &handle->color;

        for (i = 0; i < MAX_GRADIENT; i++) {
                color = &handle->gradient_table[i];
                color->r = c1->r + (c2->r - c1->r) * i / MAX_GRADIENT;
                color->g = c1->g + (c2->g - c1->g) * i / MAX_GRADIENT;
                color->b = c1->b + (c2->b - c1->b) * i / MAX_GRADIENT;
        }
}

switch_img_fit_t parse_img_fit

(

const char *

name

)

Definition at line 139 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;
}

switch_img_position_t parse_img_position

(

const char *

name

)

Definition at line 107 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;
}

static void scv_tag ( void *  buffer, int  w, int  x, int  y, uint8_t  n  )

static

Definition at line 698 of file switch_core_video.c.

Referenced by switch_img_add_text().

{
        int i = 0, j=0;
        uint8_t *p = buffer;

        if (n > 13) return;

        for(i=0; i<8; i++) {
                for (j=0; j<16; j++) {
                        *( p + (y + j) * w + (x + i)) = (scv_art[n][j] & 0x80 >> i) ? 0xFF : 0x00;
                }
        }
}

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 734 of file switch_core_video.c.

References zstr.

Referenced by switch_color_set_yuv(), switch_core_media_bug_patch_spy_frame(), switch_img_letterbox(), switch_img_txt_handle_create(), switch_img_txt_handle_render(), switch_img_write_text_img(), and video_helper_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;
                }
        }
}

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 792 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_bool_t switch_core_has_video

(

void

)

Definition at line 156 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_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 2252 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_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 2270 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
}

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

Definition at line 712 of file switch_core_video.c.

References 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_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 169 of file switch_core_video.c.

References SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_GD, switch_img_free(), and vpx_img_alloc().

Referenced by switch_img_copy(), switch_img_from_raw(), switch_img_letterbox(), 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
#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

        return (switch_image_t *)vpx_img_alloc((vpx_image_t *)img, (vpx_img_fmt_t)fmt, d_w, d_h, align);
#else
        return NULL;
#endif
}

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 420 of file switch_core_video.c.

References switch_assert, 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.

Referenced by find_free_frame(), 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(), and video_write_overlay_callback().

{
        switch_assert(img);
        switch_assert(new_img);

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

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

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

        switch_assert(*new_img);

        if (img->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 (img->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
        return;
#endif
}

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 496 of file switch_core_video.c.

References MIN, switch_assert, switch_img_copy(), SWITCH_IMG_FMT_PLANAR, switch_img_free(), switch_img_set_rect(), SWITCH_PLANE_PACKED, SWITCH_PLANE_Y, and vpx_img_wrap().

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
}

static void switch_img_draw_pixel ( switch_image_t *  img, int  x, int  y, switch_rgb_color_t *  color  )

inlinestatic

Convert RGB color to YUV.

Parameters

[in]	rgb	RGB color pointer
[out]	yuv	YUV color pointer

Convert YUV color to RGB

Parameters

[in]	yuv	YUV color pointer
[out]	rgb	RGB color pointer

Draw a pixel on an image

Parameters

[in]	img	Image descriptor
[in]	x	leftmost pos
[in]	y	topmost pos
[in]	color	RGB color

Definition at line 530 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, vpx_image::planes, switch_rgb_color_s::r, 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_img_overlay(), and switch_img_patch().

{
#ifdef SWITCH_HAVE_YUV  
        switch_yuv_color_t yuv;

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

                img->planes[SWITCH_PLANE_Y][y * img->stride[SWITCH_PLANE_Y] + x] = yuv.y;

                if (((x & 0x1) == 0) && ((y & 0x1) == 0)) {// only draw on even position
                        img->planes[SWITCH_PLANE_U][y / 2 * img->stride[SWITCH_PLANE_U] + x / 2] = yuv.u;
                        img->planes[SWITCH_PLANE_V][y / 2 * img->stride[SWITCH_PLANE_V] + x / 2] = yuv.v;
                }
        } else if (img->fmt == SWITCH_IMG_FMT_ARGB) {
                uint8_t *alpha = img->planes[SWITCH_PLANE_PACKED] + img->d_w * 4 * y + x * 4;
                *(alpha    ) = color->a;
                *(alpha + 1) = color->r;
                *(alpha + 2) = color->g;
                *(alpha + 3) = color->b;
        }
#endif
}

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 556 of file switch_core_video.c.

References memset(), MIN, 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_img_letterbox(), switch_img_write_text_img(), and video_helper_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++) {
                        *(img->planes[SWITCH_PLANE_PACKED] + i * 4    ) = color->a;
                        *(img->planes[SWITCH_PLANE_PACKED] + i * 4 + 1) = color->r;
                        *(img->planes[SWITCH_PLANE_PACKED] + i * 4 + 2) = color->g;
                        *(img->planes[SWITCH_PLANE_PACKED] + i * 4 + 3) = color->b;
                }

                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
}

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 2160 of file switch_core_video.c.

References 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, and POS_RIGHT_TOP.

Referenced by switch_core_media_bug_patch_spy_frame(), 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_status_t switch_img_fit	(	switch_image_t **	srcP,
		int	width,
		int	height,
		switch_img_fit_t	fit
	)

Definition at line 1927 of file switch_core_video.c.

References vpx_image::d_h, vpx_image::d_w, switch_assert, SWITCH_FIT_SCALE, SWITCH_FIT_SIZE_AND_SCALE, switch_img_free(), switch_img_scale(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_media_bug_patch_spy_frame(), and video_write_overlay_callback().

{
        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_SCALE) {
                switch_img_scale(src, &tmp, width, height);
                switch_img_free(&src);
                *srcP = tmp;
                return SWITCH_STATUS_SUCCESS;
        }

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

        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;
                                switch_img_scale(src, &tmp, width, height);
                                switch_img_free(&src);
                                *srcP = tmp;
                        }

                        return SWITCH_STATUS_SUCCESS;
                }
        }

        return SWITCH_STATUS_FALSE;
}

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 264 of file switch_core_video.c.

References SWITCH_IMG_FMT_GD, switch_safe_free, and vpx_img_free().

Referenced by switch_core_media_bug_close(), switch_core_media_bug_patch_spy_frame(), switch_core_session_write_video_frame(), switch_frame_buffer_free(), switch_frame_free(), switch_img_alloc(), switch_img_copy(), switch_img_copy_rect(), switch_img_fit(), switch_img_letterbox(), switch_img_patch_rect(), switch_img_rotate(), switch_img_rotate_copy(), 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 {
                        switch_safe_free((*img)->user_priv);
                }
                vpx_img_free((vpx_image_t *)*img);
                *img = NULL;
        }
#endif
}

switch_status_t switch_img_from_raw	(	switch_image_t *	dest,
		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 2063 of file switch_core_video.c.

References SWITCH_CHANNEL_LOG, switch_img_alloc(), 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;

        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* src_frame, size_t src_size,
                        uint8* dst_y, int dst_stride_y,
                        uint8* dst_u, int dst_stride_u,
                        uint8* 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
*/

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

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

static void switch_img_get_rgb_pixel ( switch_image_t *  img, switch_rgb_color_t *  rgb, int  x, int  y  )

inlinestatic

Definition at line 614 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, vpx_image::planes, switch_rgb_color_s::r, SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_I420, and SWITCH_PLANE_PACKED.

Referenced by switch_img_overlay(), and switch_img_patch().

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

        if (img->fmt == SWITCH_IMG_FMT_I420) {
                switch_yuv_color_t yuv;

                switch_img_get_yuv_pixel(img, &yuv, x, y);
                switch_color_yuv2rgb(&yuv, rgb);
        } else if (img->fmt == SWITCH_IMG_FMT_ARGB) {
                uint8_t *a = img->planes[SWITCH_PLANE_PACKED] + img->d_w * 4 * y + 4 * x;
                rgb->a = *a;
                rgb->r = *(++a);
                rgb->g = *(++a);
                rgb->b = *(++a);
        }
#endif  
}

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

Definition at line 1882 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;
}

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 634 of file switch_core_video.c.

References switch_rgb_color_s::b, 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);
                }
        }
}

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 289 of file switch_core_video.c.

References switch_rgb_color_s::a, switch_rgb_color_s::b, switch_rgb_color_s::g, MIN, switch_rgb_color_s::r, switch_assert, SWITCH_CHANNEL_LOG, switch_img_draw_pixel(), SWITCH_IMG_FMT_ARGB, SWITCH_IMG_FMT_GD, SWITCH_IMG_FMT_I420, switch_img_get_rgb_pixel(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_PLANE_PACKED, SWITCH_PLANE_U, SWITCH_PLANE_V, and SWITCH_PLANE_Y.

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;

        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++) {
                                alpha = img->planes[SWITCH_PLANE_PACKED][i * img->stride[SWITCH_PLANE_PACKED] + j * 4];

                                if (alpha > 0) {
                                        switch_rgb_color_t RGB = { 0 };

                                        switch_img_get_rgb_pixel(IMG, &RGB, x + j, y + i);
                                        rgb = (switch_rgb_color_t *)(img->planes[SWITCH_PLANE_PACKED] + i * img->stride[SWITCH_PLANE_PACKED] + j * 4);

                                        if (alpha < 255) {
                                                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);
                                        } else {
                                                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);
        }
}

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 1232 of file switch_core_video.c.

References MIN, switch_assert, SWITCH_IMG_FMT_I420, SWITCH_PLANE_U, SWITCH_PLANE_V, and SWITCH_PLANE_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_status_t switch_img_patch_png	(	switch_image_t *	img,
		int	x,
		int	y,
		const char *	file_name
	)

Definition at line 1862 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;
}

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 392 of file switch_core_video.c.

References MIN, vpx_image::planes, 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;
        uint8_t *data;

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

        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;

        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_image_t* switch_img_read_file

(

const char *

file_name

)

Definition at line 2246 of file switch_core_video.c.

{
        return NULL;
}

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

Definition at line 1868 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;
}

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 231 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
}

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

Definition at line 459 of file switch_core_video.c.

References SRM_270, SRM_90, 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_w) {
                        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_status_t switch_img_scale	(	switch_image_t *	src,
		switch_image_t **	destP,
		int	width,
		int	height
	)

Definition at line 2113 of file switch_core_video.c.

References 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_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(), switch_img_letterbox(), and video_bug_thread().

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

        if (destP) {
                dest = *destP;
        }

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

        switch_assert(src->fmt == dest->fmt);

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

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

        if (destP) {
                *destP = dest;
        }
        
        return SWITCH_STATUS_SUCCESS;
#else
        return SWITCH_STATUS_FALSE;
#endif
}

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 218 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_status_t switch_img_to_raw	(	switch_image_t *	src,
		void *	dest,
		switch_size_t	size,
		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]	size	The size of target memory address used for bounds check
[in]	fmt	The target format

Definition at line 2034 of file switch_core_video.c.

References switch_assert, SWITCH_CHANNEL_LOG, 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;

        switch_assert(src->fmt == SWITCH_IMG_FMT_I420); // todo: support other formats
        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;
        }

        ret = ConvertFromI420(src->planes[0], src->stride[0],
                                        src->planes[1], src->stride[1],
                                        src->planes[2], src->stride[2],
                                        dest, size,
                                        src->d_w, src->d_h,
                                        fourcc);

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

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 843 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, "FreeMono.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 (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;
}

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 900 of file switch_core_video.c.

References switch_img_txt_handle_s::free_pool, pool, switch_img_txt_handle_s::pool, switch_assert, and switch_core_destroy_memory_pool.

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

}

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 998 of file switch_core_video.c.

References init_gradient_table(), 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(), 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;
        }

        /* use 50pt at 100dpi */
        error = FT_Set_Char_Size(face, 64 * font_size, 0, 96, 96); /* 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_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 204 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_status_t switch_img_write_png	(	switch_image_t *	img,
		char *	file_name
	)

Definition at line 1874 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_image_t* switch_img_write_text_img	(	int	w,
		int	h,
		switch_bool_t	full,
		const char *	text
	)

Definition at line 1125 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_FMT_I420, switch_img_txt_handle_create(), switch_img_txt_handle_destroy(), switch_img_txt_handle_render(), SWITCH_PLANE_PACKED, switch_safe_free, switch_split, 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;
        int len = 0;
        char *duptxt = strdup(text);
        switch_img_txt_handle_t *txthandle = NULL;
        switch_image_t *txtimg = NULL;
        int x = 0, y = 0;

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

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

        if (len < 5) len = 5;


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

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

        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);
        switch_img_txt_handle_destroy(&txthandle);

        switch_safe_free(duptxt);

        return txtimg;
}

Variable Documentation

struct fit_el IMG_FIT_TABLE[]

static

Initial value:

= {
        {SWITCH_FIT_SIZE, "fit-size"},
        {SWITCH_FIT_SCALE, "fit-scale"},
        {SWITCH_FIT_SIZE_AND_SCALE, "fit-size-and-scale"},
        {SWITCH_FIT_NONE, NULL}
}

Definition at line 131 of file switch_core_video.c.

struct pos_el POS_TABLE[]

static

Initial value:

= {
        {POS_LEFT_TOP, "left-top"},
        {POS_LEFT_MID, "left-mid"},
        {POS_LEFT_BOT, "left-bot"},
        {POS_CENTER_TOP, "center-top"},
        {POS_CENTER_MID, "center-mid"},
        {POS_CENTER_BOT, "center-bot"},
        {POS_RIGHT_TOP, "right-top"},
        {POS_RIGHT_MID, "right-mid"},
        {POS_RIGHT_BOT, "right-bot"},
        {POS_NONE, "none"},
        {POS_NONE, NULL}
}

Definition at line 92 of file switch_core_video.c.

uint8_t scv_art[14][16]

static

Initial value:

= {
        {0x00, 0x7E, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x7E, 0x00},
        {0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x00},
        {0x00, 0x7E, 0x02, 0x02, 0x02, 0x02, 0x02, 0x7E, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x7E, 0x00},
        {0x00, 0x7E, 0x02, 0x02, 0x02, 0x02, 0x02, 0x7E, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x7E, 0x00},
        {0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x7E, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x00},
        {0x00, 0x7E, 0x40, 0x40, 0x40, 0x40, 0x40, 0x7E, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x7E, 0x00},
        {0x00, 0x7E, 0x40, 0x40, 0x40, 0x40, 0x40, 0x7E, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x7E, 0x00},
        {0x00, 0x7E, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x00},
        {0x00, 0x7E, 0x42, 0x42, 0x42, 0x42, 0x42, 0x7E, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x7E, 0x00},
        {0x00, 0x7E, 0x42, 0x42, 0x42, 0x42, 0x42, 0x7E, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x7E, 0x00},
        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00}, 
        {0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 
        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 
        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 
}

Definition at line 681 of file switch_core_video.c.