Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	gx_display_driver_4bpp_canvas_copy.c	Lines:	42	42	100.0 %
Date:	2024-12-05 08:52:37	Branches:	20	20	100.0 %


/***************************************************************************
 * Copyright (c) 2024 Microsoft Corporation
 *
 * This program and the accompanying materials are made available under the
 * terms of the MIT License which is available at
 * https://opensource.org/licenses/MIT.
 *
 * SPDX-License-Identifier: MIT
 **************************************************************************/


/**************************************************************************/
/**************************************************************************/
/**                                                                       */
/** GUIX Component                                                        */
/**                                                                       */
/**   Display Management (Display)                                        */
/**                                                                       */
/**************************************************************************/

#define GX_SOURCE_CODE


/* Include necessary system files.  */

#include "gx_api.h"
#include "gx_display.h"
#include "gx_utility.h"

/**************************************************************************/
/*                                                                        */
/*  FUNCTION                                               RELEASE        */
/*                                                                        */
/*    _gx_display_driver_4bpp_canvas_copy                 PORTABLE C      */
/*                                                           6.1          */
/*  AUTHOR                                                                */
/*                                                                        */
/*    Kenneth Maxwell, Microsoft Corporation                              */
/*                                                                        */
/*  DESCRIPTION                                                           */
/*                                                                        */
/*    Generic 4bpp canvas copy function.                                  */
/*                                                                        */
/*  INPUT                                                                 */
/*                                                                        */
/*   canvas                                 The canvas to copy from       */
/*   composite                              The canvas to copy to         */
/*                                                                        */
/*  OUTPUT                                                                */
/*                                                                        */
/*    None                                                                */
/*                                                                        */
/*  CALLS                                                                 */
/*                                                                        */
/*    _gx_utility_rectangle_shift           Move the rectangle            */
/*    _gx_utility_rectangle_overlap_detect  Detect two rectangles being   */
/*                                            overlap to each other       */
/*    memcpy                                Move canvas data              */
/*                                                                        */
/*  CALLED BY                                                             */
/*                                                                        */
/*    GUIX Internal Code                                                  */
/*                                                                        */
/*  RELEASE HISTORY                                                       */
/*                                                                        */
/*    DATE              NAME                      DESCRIPTION             */
/*                                                                        */
/*  05-19-2020     Kenneth Maxwell          Initial Version 6.0           */
/*  09-30-2020     Kenneth Maxwell          Modified comment(s),          */
/*                                            resulting in version 6.1    */
/*                                                                        */
/**************************************************************************/
VOID _gx_display_driver_4bpp_canvas_copy(GX_CANVAS *canvas, GX_CANVAS *composite)
{
GX_RECTANGLE dirty;
GX_RECTANGLE overlap;
GX_UBYTE    *read;
GX_UBYTE    *write;
GX_UBYTE     color;
INT          row;
INT          column;
UINT         read_pos;
UINT         write_pos;
GX_UBYTE     read_mask;
GX_UBYTE     write_mask;
INT          readstride;
INT          writestride;
INT          offset;

    dirty.gx_rectangle_left = dirty.gx_rectangle_top = 0;
    dirty.gx_rectangle_right = (GX_VALUE)(canvas -> gx_canvas_x_resolution - 1);
    dirty.gx_rectangle_bottom = (GX_VALUE)(canvas -> gx_canvas_y_resolution - 1);
    readstride = (canvas->gx_canvas_x_resolution + 1) >> 1;
    writestride = (composite->gx_canvas_x_resolution + 1) >> 1;

    _gx_utility_rectangle_shift(&dirty, canvas -> gx_canvas_display_offset_x, canvas -> gx_canvas_display_offset_y);

    if (_gx_utility_rectangle_overlap_detect(&dirty, &composite -> gx_canvas_dirty_area, &overlap))
    {
        offset = overlap.gx_rectangle_left - dirty.gx_rectangle_left;
        read_pos = (UINT)((overlap.gx_rectangle_top - dirty.gx_rectangle_top) * readstride + (offset >> 1));
        write_pos = (UINT)(overlap.gx_rectangle_top * writestride + (overlap.gx_rectangle_left >> 1));

        for (row = overlap.gx_rectangle_top; row <= overlap.gx_rectangle_bottom; row++)
        {
            read = (GX_UBYTE *)canvas->gx_canvas_memory;
            write = (GX_UBYTE *)composite->gx_canvas_memory;

            read += read_pos;
            write += write_pos;
            /* If position is odd, it means the low bits. */
            if (offset & 0x01)
            {
                read_mask = 0x0f;
            }
            else
            {
                read_mask = 0xf0;
            }

            if (overlap.gx_rectangle_left & 0x01)
            {
                write_mask = 0x0f;
            }
            else
            {
                write_mask = 0xf0;
            }

            for (column = overlap.gx_rectangle_left; column <= overlap.gx_rectangle_right; column++)
            {
                color = (*read) & read_mask;
                *write = (GX_UBYTE)((*write) & (~write_mask));

                if (color)
                {
                    /* Read and write have same mask bits. */
                    if (read_mask & write_mask)
                    {
                        *write |= color;
                    }
                    else
                    {
                        /* Read and write are malposed. */
                        /* If position is odd, it means the low bits. */
                        if (write_mask & 0x01)
                        {
                            *write |= (GX_UBYTE)(color >> 4);
                        }
                        else
                        {
                            *write |= (GX_UBYTE)(color << 4);
                        }
                    }
                }

                read_mask >>= 4;
                write_mask >>= 4;
                if (!read_mask)
                {
                    read++;
                    read_mask = 0xf0;
                }
                if (!write_mask)
                {
                    write++;
                    write_mask = 0xf0;
                }
            }
            write_pos = (UINT)((INT)write_pos + writestride);
            read_pos = (UINT)((INT)read_pos + readstride);
        }
    }
}



Generated by: GCOVR (Version 4.1)

Line	Branch	Exec	Source
1			/***************************************************************************
2			* Copyright (c) 2024 Microsoft Corporation
3			*
4			* This program and the accompanying materials are made available under the
5			* terms of the MIT License which is available at
6			* https://opensource.org/licenses/MIT.
7			*
8			* SPDX-License-Identifier: MIT
9			**************************************************************************/
10
11
12			/**************************************************************************/
13			/**************************************************************************/
14			/** */
15			/** GUIX Component */
16			/** */
17			/** Display Management (Display) */
18			/** */
19			/**************************************************************************/
20
21			#define GX_SOURCE_CODE
22
23
24			/* Include necessary system files. */
25
26			#include "gx_api.h"
27			#include "gx_display.h"
28			#include "gx_utility.h"
29
30			/**************************************************************************/
31			/* */
32			/* FUNCTION RELEASE */
33			/* */
34			/* _gx_display_driver_4bpp_canvas_copy PORTABLE C */
35			/* 6.1 */
36			/* AUTHOR */
37			/* */
38			/* Kenneth Maxwell, Microsoft Corporation */
39			/* */
40			/* DESCRIPTION */
41			/* */
42			/* Generic 4bpp canvas copy function. */
43			/* */
44			/* INPUT */
45			/* */
46			/* canvas The canvas to copy from */
47			/* composite The canvas to copy to */
48			/* */
49			/* OUTPUT */
50			/* */
51			/* None */
52			/* */
53			/* CALLS */
54			/* */
55			/* _gx_utility_rectangle_shift Move the rectangle */
56			/* _gx_utility_rectangle_overlap_detect Detect two rectangles being */
57			/* overlap to each other */
58			/* memcpy Move canvas data */
59			/* */
60			/* CALLED BY */
61			/* */
62			/* GUIX Internal Code */
63			/* */
64			/* RELEASE HISTORY */
65			/* */
66			/* DATE NAME DESCRIPTION */
67			/* */
68			/* 05-19-2020 Kenneth Maxwell Initial Version 6.0 */
69			/* 09-30-2020 Kenneth Maxwell Modified comment(s), */
70			/* resulting in version 6.1 */
71			/* */
72			/**************************************************************************/
73		46	VOID _gx_display_driver_4bpp_canvas_copy(GX_CANVAS canvas, GX_CANVAS composite)
74			{
75			GX_RECTANGLE dirty;
76			GX_RECTANGLE overlap;
77			GX_UBYTE *read;
78			GX_UBYTE *write;
79			GX_UBYTE color;
80			INT row;
81			INT column;
82			UINT read_pos;
83			UINT write_pos;
84			GX_UBYTE read_mask;
85			GX_UBYTE write_mask;
86			INT readstride;
87			INT writestride;
88			INT offset;
89
90		46	dirty.gx_rectangle_left = dirty.gx_rectangle_top = 0;
91		46	dirty.gx_rectangle_right = (GX_VALUE)(canvas -> gx_canvas_x_resolution - 1);
92		46	dirty.gx_rectangle_bottom = (GX_VALUE)(canvas -> gx_canvas_y_resolution - 1);
93		46	readstride = (canvas->gx_canvas_x_resolution + 1) >> 1;
94		46	writestride = (composite->gx_canvas_x_resolution + 1) >> 1;
95
96		46	_gx_utility_rectangle_shift(&dirty, canvas -> gx_canvas_display_offset_x, canvas -> gx_canvas_display_offset_y);
97
98	✓✓	46	if (_gx_utility_rectangle_overlap_detect(&dirty, &composite -> gx_canvas_dirty_area, &overlap))
99			{
100		38	offset = overlap.gx_rectangle_left - dirty.gx_rectangle_left;
101		38	read_pos = (UINT)((overlap.gx_rectangle_top - dirty.gx_rectangle_top) * readstride + (offset >> 1));
102		38	write_pos = (UINT)(overlap.gx_rectangle_top * writestride + (overlap.gx_rectangle_left >> 1));
103
104	✓✓	8678	for (row = overlap.gx_rectangle_top; row <= overlap.gx_rectangle_bottom; row++)
105			{
106		8640	read = (GX_UBYTE *)canvas->gx_canvas_memory;
107		8640	write = (GX_UBYTE *)composite->gx_canvas_memory;
108
109		8640	read += read_pos;
110		8640	write += write_pos;
111			/* If position is odd, it means the low bits. */
112	✓✓	8640	if (offset & 0x01)
113			{
114		724	read_mask = 0x0f;
115			}
116			else
117			{
118		7916	read_mask = 0xf0;
119			}
120
121	✓✓	8640	if (overlap.gx_rectangle_left & 0x01)
122			{
123		651	write_mask = 0x0f;
124			}
125			else
126			{
127		7989	write_mask = 0xf0;
128			}
129
130	✓✓	4499601	for (column = overlap.gx_rectangle_left; column <= overlap.gx_rectangle_right; column++)
131			{
132		4490961	color = (*read) & read_mask;
133		4490961	write = (GX_UBYTE)((write) & (~write_mask));
134
135	✓✓	4490961	if (color)
136			{
137			/* Read and write have same mask bits. */
138	✓✓	3221304	if (read_mask & write_mask)
139			{
140		3214772	*write \|= color;
141			}
142			else
143			{
144			/* Read and write are malposed. */
145			/* If position is odd, it means the low bits. */
146	✓✓	6532	if (write_mask & 0x01)
147			{
148		3266	*write \|= (GX_UBYTE)(color >> 4);
149			}
150			else
151			{
152		3266	*write \|= (GX_UBYTE)(color << 4);
153			}
154			}
155			}
156
157		4490961	read_mask >>= 4;
158		4490961	write_mask >>= 4;
159	✓✓	4490961	if (!read_mask)
160			{
161		2244844	read++;
162		2244844	read_mask = 0xf0;
163			}
164	✓✓	4490961	if (!write_mask)
165			{
166		2244771	write++;
167		2244771	write_mask = 0xf0;
168			}
169			}
170		8640	write_pos = (UINT)((INT)write_pos + writestride);
171		8640	read_pos = (UINT)((INT)read_pos + readstride);
172			}
173			}
174		46	}
175