Aksal/nuttx-apps
1
0
Fork 1
mirror of https://github.com/apache/nuttx-apps.git synced 2026-08-01 20:29:00 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

include/debug.h: fix checkpatch fallout in touched apps files

Browse source 
Clean up style issues in the files touched by the <nuttx/debug.h> include
migration so the full apps-side PR passes checkpatch.

Signed-off-by: Piyush Patle <piyushpatle228@gmail.com>
This commit is contained in:
Piyush Patle 2026-04-11 03:50:44 +05:30 • committed by Alan C. Assis
parent 9d849adfab
commit 96a003072d
21 changed files with 820 additions and 580 deletions
Download patch file Download diff file Expand all files Collapse all files

54
examples/nx/nx_events.c
View file

@ -52,25 +52,30 @@
static void nxeg_redraw(NXEGWINDOW hwnd, FAR const struct nxgl_rect_s *rect, static void nxeg_redraw(NXEGWINDOW hwnd, FAR const struct nxgl_rect_s *rect,
bool morem, FAR void *arg); bool morem, FAR void *arg);
static void nxeg_position(NXEGWINDOW hwnd, FAR const struct nxgl_size_s *size, static void nxeg_position(NXEGWINDOW hwnd,
FAR const struct nxgl_size_s *size,
FAR const struct nxgl_point_s *pos, FAR const struct nxgl_point_s *pos,
FAR const struct nxgl_rect_s *bounds, FAR const struct nxgl_rect_s *bounds,
FAR void *arg); FAR void *arg);
#ifdef CONFIG_NX_XYINPUT #ifdef CONFIG_NX_XYINPUT
static void nxeg_mousein(NXEGWINDOW hwnd, FAR const struct nxgl_point_s *pos, static void nxeg_mousein(NXEGWINDOW hwnd,
FAR const struct nxgl_point_s *pos,
uint8_t buttons, FAR void *arg); uint8_t buttons, FAR void *arg);
#endif #endif
#ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS #ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS
static void nxeg_tbredraw(NXEGWINDOW hwnd, FAR const struct nxgl_rect_s *rect, static void nxeg_tbredraw(NXEGWINDOW hwnd,
FAR const struct nxgl_rect_s *rect,
bool morem, FAR void *arg); bool morem, FAR void *arg);
static void nxeg_tbposition(NXEGWINDOW hwnd, FAR const struct nxgl_size_s *size, static void nxeg_tbposition(NXEGWINDOW hwnd,
FAR const struct nxgl_size_s *size,
FAR const struct nxgl_point_s *pos, FAR const struct nxgl_point_s *pos,
FAR const struct nxgl_rect_s *bounds, FAR const struct nxgl_rect_s *bounds,
FAR void *arg); FAR void *arg);
#ifdef CONFIG_NX_XYINPUT #ifdef CONFIG_NX_XYINPUT
static void nxeg_tbmousein(NXEGWINDOW hwnd, FAR const struct nxgl_point_s *pos, static void nxeg_tbmousein(NXEGWINDOW hwnd,
uint8_t buttons, FAR void *arg); FAR const struct nxgl_point_s *pos,
uint8_t buttons, FAR void *arg);
#endif #endif
#endif #endif
@ -137,6 +142,7 @@ static inline void nxeg_fillwindow(NXEGWINDOW hwnd,
printf("nxeg_fillwindow: nxtk_fillwindow failed: %d\n", errno); printf("nxeg_fillwindow: nxtk_fillwindow failed: %d\n", errno);
} }
#endif #endif
#ifdef CONFIG_NX_KBD #ifdef CONFIG_NX_KBD
nxeg_filltext(hwnd, rect, st); nxeg_filltext(hwnd, rect, st);
#endif #endif
@ -148,8 +154,8 @@ static inline void nxeg_fillwindow(NXEGWINDOW hwnd,
#ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS #ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS
static inline void nxeg_filltoolbar(NXTKWINDOW htb, static inline void nxeg_filltoolbar(NXTKWINDOW htb,
FAR const struct nxgl_rect_s *rect, FAR const struct nxgl_rect_s *rect,
nxgl_mxpixel_t color[CONFIG_NX_NPLANES]) nxgl_mxpixel_t color[CONFIG_NX_NPLANES])
{ {
int ret; int ret;
@ -181,7 +187,8 @@ static void nxeg_redraw(NXEGWINDOW hwnd, FAR const struct nxgl_rect_s *rect,
* Name: nxeg_position * Name: nxeg_position
****************************************************************************/ ****************************************************************************/
static void nxeg_position(NXEGWINDOW hwnd, FAR const struct nxgl_size_s *size, static void nxeg_position(NXEGWINDOW hwnd,
FAR const struct nxgl_size_s *size,
FAR const struct nxgl_point_s *pos, FAR const struct nxgl_point_s *pos,
FAR const struct nxgl_rect_s *bounds, FAR const struct nxgl_rect_s *bounds,
FAR void *arg) FAR void *arg)
@ -190,7 +197,8 @@ static void nxeg_position(NXEGWINDOW hwnd, FAR const struct nxgl_size_s *size,
/* Report the position */ /* Report the position */
printf("nxeg_position%d: hwnd=%p size=(%d,%d) pos=(%d,%d) bounds={(%d,%d),(%d,%d)}\n", printf("nxeg_position%d: hwnd=%p size=(%d,%d) pos=(%d,%d) "
"bounds={(%d,%d),(%d,%d)}\n",
st->wnum, hwnd, size->w, size->h, pos->x, pos->y, st->wnum, hwnd, size->w, size->h, pos->x, pos->y,
bounds->pt1.x, bounds->pt1.y, bounds->pt2.x, bounds->pt2.y); bounds->pt1.x, bounds->pt1.y, bounds->pt2.x, bounds->pt2.y);
@ -198,7 +206,9 @@ static void nxeg_position(NXEGWINDOW hwnd, FAR const struct nxgl_size_s *size,
if (!b_haveresolution) if (!b_haveresolution)
{ {
/* Save the window limits (these should be the same for all places and all windows */ /* Save the window limits (these should be the same for all places
* and all windows.
*/
g_xres = bounds->pt2.x; g_xres = bounds->pt2.x;
g_yres = bounds->pt2.y; g_yres = bounds->pt2.y;
@ -228,7 +238,8 @@ static void nxeg_mousein(NXEGWINDOW hwnd, FAR const struct nxgl_point_s *pos,
****************************************************************************/ ****************************************************************************/
#ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS #ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS
static void nxeg_tbredraw(NXEGWINDOW hwnd, FAR const struct nxgl_rect_s *rect, static void nxeg_tbredraw(NXEGWINDOW hwnd,
FAR const struct nxgl_rect_s *rect,
bool more, FAR void *arg) bool more, FAR void *arg)
{ {
FAR struct nxeg_state_s *st = (FAR struct nxeg_state_s *)arg; FAR struct nxeg_state_s *st = (FAR struct nxeg_state_s *)arg;
@ -245,16 +256,18 @@ static void nxeg_tbredraw(NXEGWINDOW hwnd, FAR const struct nxgl_rect_s *rect,
****************************************************************************/ ****************************************************************************/
#ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS #ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS
static void nxeg_tbposition(NXEGWINDOW hwnd, FAR const struct nxgl_size_s *size, static void nxeg_tbposition(NXEGWINDOW hwnd,
FAR const struct nxgl_point_s *pos, FAR const struct nxgl_size_s *size,
FAR const struct nxgl_rect_s *bounds, FAR const struct nxgl_point_s *pos,
FAR void *arg) FAR const struct nxgl_rect_s *bounds,
FAR void *arg)
{ {
FAR struct nxeg_state_s *st = (FAR struct nxeg_state_s *)arg; FAR struct nxeg_state_s *st = (FAR struct nxeg_state_s *)arg;
/* Report the position */ /* Report the position */
printf("nxeg_ptbosition%d: hwnd=%p size=(%d,%d) pos=(%d,%d) bounds={(%d,%d),(%d,%d)}\n", printf("nxeg_ptbosition%d: hwnd=%p size=(%d,%d) pos=(%d,%d) "
"bounds={(%d,%d),(%d,%d)}\n",
st->wnum, hwnd, size->w, size->h, pos->x, pos->y, st->wnum, hwnd, size->w, size->h, pos->x, pos->y,
bounds->pt1.x, bounds->pt1.y, bounds->pt2.x, bounds->pt2.y); bounds->pt1.x, bounds->pt1.y, bounds->pt2.x, bounds->pt2.y);
} }
@ -266,8 +279,9 @@ static void nxeg_tbposition(NXEGWINDOW hwnd, FAR const struct nxgl_size_s *size,
#ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS #ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS
#ifdef CONFIG_NX_XYINPUT #ifdef CONFIG_NX_XYINPUT
static void nxeg_tbmousein(NXEGWINDOW hwnd, FAR const struct nxgl_point_s *pos, static void nxeg_tbmousein(NXEGWINDOW hwnd,
uint8_t buttons, FAR void *arg) FAR const struct nxgl_point_s *pos,
uint8_t buttons, FAR void *arg)
{ {
FAR struct nxeg_state_s *st = (FAR struct nxeg_state_s *)arg; FAR struct nxeg_state_s *st = (FAR struct nxeg_state_s *)arg;
@ -291,7 +305,7 @@ FAR void *nx_listenerthread(FAR void *arg)
/* Process events forever */ /* Process events forever */
for (;;) for (; ; )
{ {
/* Handle the next event. If we were configured blocking, then /* Handle the next event. If we were configured blocking, then
* we will stay right here until the next event is received. Since * we will stay right here until the next event is received. Since

83
examples/nx/nx_kbdin.c
View file

@ -109,7 +109,8 @@ static void nxeg_fillchar(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect,
if (!nxgl_nullrect(&intersection)) if (!nxgl_nullrect(&intersection))
{ {
#ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS #ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS
ret = nxtk_bitmapwindow((NXTKWINDOW)hwnd, &intersection, (FAR const void **)&src, ret = nxtk_bitmapwindow((NXTKWINDOW)hwnd, &intersection,
(FAR const void **)&src,
&bm->bounds.pt1, &bm->bounds.pt1,
(unsigned int)bm->glyph->stride); (unsigned int)bm->glyph->stride);
if (ret < 0) if (ret < 0)
@ -165,7 +166,7 @@ nxeg_renderglyph(FAR struct nxeg_state_s *st,
/* Allocate memory to hold the glyph with its offsets */ /* Allocate memory to hold the glyph with its offsets */
glyph->stride = (glyph->width * CONFIG_EXAMPLES_NX_BPP + 7) / 8; glyph->stride = (glyph->width * CONFIG_EXAMPLES_NX_BPP + 7) / 8;
bmsize = glyph->stride * glyph->height; bmsize = glyph->stride * glyph->height;
glyph->bitmap = (FAR uint8_t *)malloc(bmsize); glyph->bitmap = (FAR uint8_t *)malloc(bmsize);
if (glyph->bitmap) if (glyph->bitmap)
@ -178,13 +179,13 @@ nxeg_renderglyph(FAR struct nxeg_state_s *st,
/* Pack 1-bit pixels into a 2-bits */ /* Pack 1-bit pixels into a 2-bits */
pixel &= 0x01; pixel &= 0x01;
pixel = (pixel) << 1 |pixel; pixel = (pixel) << 1 | pixel;
# endif # endif
# if CONFIG_EXAMPLES_NX_BPP < 4 # if CONFIG_EXAMPLES_NX_BPP < 4
/* Pack 2-bit pixels into a nibble */ /* Pack 2-bit pixels into a nibble */
pixel &= 0x03; pixel &= 0x03;
pixel = (pixel) << 2 |pixel; pixel = (pixel) << 2 | pixel;
# endif # endif
/* Pack 4-bit nibbles into a byte */ /* Pack 4-bit nibbles into a byte */
@ -222,7 +223,7 @@ nxeg_renderglyph(FAR struct nxeg_state_s *st,
/* Then render the glyph into the allocated memory */ /* Then render the glyph into the allocated memory */
ret = RENDERER((FAR nxgl_mxpixel_t*)glyph->bitmap, ret = RENDERER((FAR nxgl_mxpixel_t *)glyph->bitmap,
glyph->height, glyph->width, glyph->stride, glyph->height, glyph->width, glyph->stride,
bm, CONFIG_EXAMPLES_NX_FONTCOLOR); bm, CONFIG_EXAMPLES_NX_FONTCOLOR);
if (ret < 0) if (ret < 0)
@ -236,9 +237,9 @@ nxeg_renderglyph(FAR struct nxeg_state_s *st,
} }
else else
{ {
/* Make it permanent */ /* Make it permanent */
st->nglyphs++; st->nglyphs++;
} }
} }
} }
@ -269,6 +270,7 @@ nxeg_addspace(FAR struct nxeg_state_s *st, uint8_t ch)
st->nglyphs++; st->nglyphs++;
} }
return glyph; return glyph;
} }
@ -283,13 +285,14 @@ nxeg_findglyph(FAR struct nxeg_state_s *st, uint8_t ch)
/* First, try to find the glyph in the cache of pre-rendered glyphs */ /* First, try to find the glyph in the cache of pre-rendered glyphs */
for (i = 0; i < st->nglyphs; i++) for (i = 0; i < st->nglyphs; i++)
{ {
if (st->glyph[i].code == ch) if (st->glyph[i].code == ch)
{ {
return &st->glyph[i]; return &st->glyph[i];
} }
} }
return NULL; return NULL;
} }
@ -313,21 +316,22 @@ nxeg_getglyph(FAR struct nxeg_state_s *st, uint8_t ch)
bm = nxf_getbitmap(g_fonthandle, ch); bm = nxf_getbitmap(g_fonthandle, ch);
if (!bm) if (!bm)
{ {
/* No, there is no glyph for this code. Use space */ /* No, there is no glyph for this code. Use space. */
glyph = nxeg_findglyph(st, ' '); glyph = nxeg_findglyph(st, ' ');
if (!glyph) if (!glyph)
{ {
/* There isn't fake glyph for ' ' yet... create one */ /* There isn't a fake glyph for ' ' yet... create one */
glyph = nxeg_addspace(st, ' '); glyph = nxeg_addspace(st, ' ');
} }
} }
else else
{ {
glyph = nxeg_renderglyph(st, bm, ch); glyph = nxeg_renderglyph(st, bm, ch);
} }
} }
return glyph; return glyph;
} }
@ -346,41 +350,42 @@ nxeg_addchar(FAR struct nxeg_state_s *st, uint8_t ch)
if (st->nchars < NXTK_MAXKBDCHARS) if (st->nchars < NXTK_MAXKBDCHARS)
{ {
/* Yes, setup the bitmap */ /* Yes, setup the bitmap */
bm = &st->bm[st->nchars]; bm = &st->bm[st->nchars];
/* Find the matching glyph */ /* Find the matching glyph */
bm->glyph = nxeg_getglyph(st, ch); bm->glyph = nxeg_getglyph(st, ch);
if (!bm->glyph) if (!bm->glyph)
{ {
return NULL; return NULL;
} }
/* Set up the bounds for the bitmap */ /* Set up the bounds for the bitmap */
if (st->nchars <= 0) if (st->nchars <= 0)
{ {
/* The first character is one space from the left */ /* The first character is one space from the left */
leftx = st->spwidth; leftx = st->spwidth;
} }
else else
{ {
/* Otherwise, it is to the left of the preceding char */ /* Otherwise, it is to the left of the preceding char */
bmleft = &st->bm[st->nchars-1]; bmleft = &st->bm[st->nchars - 1];
leftx = bmleft->bounds.pt2.x + 1; leftx = bmleft->bounds.pt2.x + 1;
} }
bm->bounds.pt1.x = leftx; bm->bounds.pt1.x = leftx;
bm->bounds.pt1.y = 2; bm->bounds.pt1.y = 2;
bm->bounds.pt2.x = leftx + bm->glyph->width - 1; bm->bounds.pt2.x = leftx + bm->glyph->width - 1;
bm->bounds.pt2.y = 2 + bm->glyph->height - 1; bm->bounds.pt2.y = 2 + bm->glyph->height - 1;
st->nchars++; st->nchars++;
} }
return bm; return bm;
} }
@ -424,10 +429,12 @@ void nxeg_kbdin(NXWINDOW hwnd, uint8_t nch, FAR const uint8_t *ch,
****************************************************************************/ ****************************************************************************/
#ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS #ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS
void nxeg_tbkbdin(NXWINDOW hwnd, uint8_t nch, const uint8_t *ch, FAR void *arg) void nxeg_tbkbdin(NXWINDOW hwnd, uint8_t nch, const uint8_t *ch,
FAR void *arg)
{ {
FAR struct nxeg_state_s *st = (FAR struct nxeg_state_s *)arg; FAR struct nxeg_state_s *st = (FAR struct nxeg_state_s *)arg;
printf("nxeg_tbkbdin: ERROR -- toolbar should not received keyboard input\n"); printf("nxeg_tbkbdin: ERROR -- toolbar should not received keyboard "
"input\n");
printf("nxeg_tbkbdin%d: hwnd=%p nch=%d\n", st->wnum, hwnd, nch); printf("nxeg_tbkbdin%d: hwnd=%p nch=%d\n", st->wnum, hwnd, nch);
} }
#endif #endif

158
examples/nx/nx_main.c
View file

@ -54,6 +54,7 @@
****************************************************************************/ ****************************************************************************/
/* Configuration ************************************************************/ /* Configuration ************************************************************/
/* If not specified, assume that the hardware supports one video plane */ /* If not specified, assume that the hardware supports one video plane */
#ifndef CONFIG_EXAMPLES_NX_VPLANE #ifndef CONFIG_EXAMPLES_NX_VPLANE
@ -98,7 +99,10 @@ nxgl_coord_t g_yres;
bool b_haveresolution = false; bool b_haveresolution = false;
bool g_connected = false; bool g_connected = false;
sem_t g_semevent = {0}; sem_t g_semevent =
{
0
};
/* Colors used to fill window 1 & 2 */ /* Colors used to fill window 1 & 2 */
@ -181,14 +185,16 @@ static void nxeg_freestate(FAR struct nxeg_state_s *st)
{ {
for (i = 0; i < st->nglyphs; i++) for (i = 0; i < st->nglyphs; i++)
{ {
if (st->glyph[i].bitmap) if (st->glyph[i].bitmap)
{ {
free(st->glyph[i].bitmap); free(st->glyph[i].bitmap);
} }
st->glyph[i].bitmap = NULL;
st->glyph[i].bitmap = NULL;
} }
st->nchars = 0; st->nchars = 0;
} }
#endif #endif
} }
#endif #endif
@ -199,7 +205,7 @@ static void nxeg_freestate(FAR struct nxeg_state_s *st)
#ifdef CONFIG_EXAMPLES_NX_RAWWINDOWS #ifdef CONFIG_EXAMPLES_NX_RAWWINDOWS
static inline NXEGWINDOW nxeg_openwindow(FAR const struct nx_callback_s *cb, static inline NXEGWINDOW nxeg_openwindow(FAR const struct nx_callback_s *cb,
FAR struct nxeg_state_s *state) FAR struct nxeg_state_s *state)
{ {
NXEGWINDOW hwnd; NXEGWINDOW hwnd;
@ -209,8 +215,10 @@ static inline NXEGWINDOW nxeg_openwindow(FAR const struct nx_callback_s *cb,
printf("nxeg_openwindow: nx_openwindow failed: %d\n", errno); printf("nxeg_openwindow: nx_openwindow failed: %d\n", errno);
g_exitcode = NXEXIT_NXOPENWINDOW; g_exitcode = NXEXIT_NXOPENWINDOW;
} }
return hwnd; return hwnd;
} }
#else #else
static inline NXEGWINDOW nxeg_openwindow(FAR const struct nx_callback_s *cb, static inline NXEGWINDOW nxeg_openwindow(FAR const struct nx_callback_s *cb,
FAR struct nxeg_state_s *state) FAR struct nxeg_state_s *state)
@ -223,8 +231,10 @@ static inline NXEGWINDOW nxeg_openwindow(FAR const struct nx_callback_s *cb,
printf("nxeg_openwindow: nxtk_openwindow failed: %d\n", errno); printf("nxeg_openwindow: nxtk_openwindow failed: %d\n", errno);
g_exitcode = NXEXIT_NXOPENWINDOW; g_exitcode = NXEXIT_NXOPENWINDOW;
} }
return hwnd; return hwnd;
} }
#endif #endif
/**************************************************************************** /****************************************************************************
@ -232,7 +242,8 @@ static inline NXEGWINDOW nxeg_openwindow(FAR const struct nx_callback_s *cb,
****************************************************************************/ ****************************************************************************/
#ifdef CONFIG_EXAMPLES_NX_RAWWINDOWS #ifdef CONFIG_EXAMPLES_NX_RAWWINDOWS
static inline int nxeg_closewindow(NXEGWINDOW hwnd, FAR struct nxeg_state_s *state) static inline int nxeg_closewindow(NXEGWINDOW hwnd,
FAR struct nxeg_state_s *state)
{ {
int ret = nx_closewindow(hwnd); int ret = nx_closewindow(hwnd);
if (ret < 0) if (ret < 0)
@ -240,10 +251,13 @@ static inline int nxeg_closewindow(NXEGWINDOW hwnd, FAR struct nxeg_state_s *sta
printf("nxeg_closewindow: nx_closewindow failed: %d\n", errno); printf("nxeg_closewindow: nx_closewindow failed: %d\n", errno);
g_exitcode = NXEXIT_NXCLOSEWINDOW; g_exitcode = NXEXIT_NXCLOSEWINDOW;
} }
return ret; return ret;
} }
#else #else
static inline int nxeg_closewindow(NXEGWINDOW hwnd, FAR struct nxeg_state_s *state) static inline int nxeg_closewindow(NXEGWINDOW hwnd,
FAR struct nxeg_state_s *state)
{ {
int ret = nxtk_closewindow(hwnd); int ret = nxtk_closewindow(hwnd);
if (ret < 0) if (ret < 0)
@ -251,9 +265,11 @@ static inline int nxeg_closewindow(NXEGWINDOW hwnd, FAR struct nxeg_state_s *sta
printf("nxeg_closewindow: nxtk_closewindow failed: %d\n", errno); printf("nxeg_closewindow: nxtk_closewindow failed: %d\n", errno);
g_exitcode = NXEXIT_NXCLOSEWINDOW; g_exitcode = NXEXIT_NXCLOSEWINDOW;
} }
nxeg_freestate(state); nxeg_freestate(state);
return ret; return ret;
} }
#endif #endif
/**************************************************************************** /****************************************************************************
@ -261,7 +277,8 @@ static inline int nxeg_closewindow(NXEGWINDOW hwnd, FAR struct nxeg_state_s *sta
****************************************************************************/ ****************************************************************************/
#ifdef CONFIG_EXAMPLES_NX_RAWWINDOWS #ifdef CONFIG_EXAMPLES_NX_RAWWINDOWS
static inline int nxeg_setsize(NXEGWINDOW hwnd, FAR struct nxgl_size_s *size) static inline int nxeg_setsize(NXEGWINDOW hwnd,
FAR struct nxgl_size_s *size)
{ {
int ret = nx_setsize(hwnd, size); int ret = nx_setsize(hwnd, size);
if (ret < 0) if (ret < 0)
@ -269,10 +286,13 @@ static inline int nxeg_setsize(NXEGWINDOW hwnd, FAR struct nxgl_size_s *size)
printf("nxeg_setsize: nx_setsize failed: %d\n", errno); printf("nxeg_setsize: nx_setsize failed: %d\n", errno);
g_exitcode = NXEXIT_NXSETSIZE; g_exitcode = NXEXIT_NXSETSIZE;
} }
return ret; return ret;
} }
#else #else
static inline int nxeg_setsize(NXEGWINDOW hwnd, FAR struct nxgl_size_s *size) static inline int nxeg_setsize(NXEGWINDOW hwnd,
FAR struct nxgl_size_s *size)
{ {
int ret = nxtk_setsize(hwnd, size); int ret = nxtk_setsize(hwnd, size);
if (ret < 0) if (ret < 0)
@ -280,8 +300,10 @@ static inline int nxeg_setsize(NXEGWINDOW hwnd, FAR struct nxgl_size_s *size)
printf("nxeg_setsize: nxtk_setsize failed: %d\n", errno); printf("nxeg_setsize: nxtk_setsize failed: %d\n", errno);
g_exitcode = NXEXIT_NXSETSIZE; g_exitcode = NXEXIT_NXSETSIZE;
} }
return ret; return ret;
} }
#endif #endif
/**************************************************************************** /****************************************************************************
@ -289,7 +311,8 @@ static inline int nxeg_setsize(NXEGWINDOW hwnd, FAR struct nxgl_size_s *size)
****************************************************************************/ ****************************************************************************/
#ifdef CONFIG_EXAMPLES_NX_RAWWINDOWS #ifdef CONFIG_EXAMPLES_NX_RAWWINDOWS
static inline int nxeg_setposition(NXEGWINDOW hwnd, FAR struct nxgl_point_s *pos) static inline int nxeg_setposition(NXEGWINDOW hwnd,
FAR struct nxgl_point_s *pos)
{ {
int ret = nx_setposition(hwnd, pos); int ret = nx_setposition(hwnd, pos);
if (ret < 0) if (ret < 0)
@ -297,10 +320,13 @@ static inline int nxeg_setposition(NXEGWINDOW hwnd, FAR struct nxgl_point_s *pos
printf("nxeg_setposition: nx_setposition failed: %d\n", errno); printf("nxeg_setposition: nx_setposition failed: %d\n", errno);
g_exitcode = NXEXIT_NXSETPOSITION; g_exitcode = NXEXIT_NXSETPOSITION;
} }
return ret; return ret;
} }
#else #else
static inline int nxeg_setposition(NXEGWINDOW hwnd, FAR struct nxgl_point_s *pos) static inline int nxeg_setposition(NXEGWINDOW hwnd,
FAR struct nxgl_point_s *pos)
{ {
int ret = nxtk_setposition(hwnd, pos); int ret = nxtk_setposition(hwnd, pos);
if (ret < 0) if (ret < 0)
@ -308,8 +334,10 @@ static inline int nxeg_setposition(NXEGWINDOW hwnd, FAR struct nxgl_point_s *pos
printf("nxeg_setposition: nxtk_setposition failed: %d\n", errno); printf("nxeg_setposition: nxtk_setposition failed: %d\n", errno);
g_exitcode = NXEXIT_NXSETPOSITION; g_exitcode = NXEXIT_NXSETPOSITION;
} }
return ret; return ret;
} }
#endif #endif
/**************************************************************************** /****************************************************************************
@ -328,8 +356,10 @@ static inline int nxeq_opentoolbar(NXEGWINDOW hwnd, nxgl_coord_t height,
printf("nxeq_opentoolbar: nxtk_opentoolbar failed: %d\n", errno); printf("nxeq_opentoolbar: nxtk_opentoolbar failed: %d\n", errno);
g_exitcode = NXEXIT_NXOPENTOOLBAR; g_exitcode = NXEXIT_NXOPENTOOLBAR;
} }
return ret; return ret;
} }
#endif #endif
/**************************************************************************** /****************************************************************************
@ -345,8 +375,10 @@ static inline int nxeg_lower(NXEGWINDOW hwnd)
printf("nxeg_lower: nx_lower failed: %d\n", errno); printf("nxeg_lower: nx_lower failed: %d\n", errno);
g_exitcode = NXEXIT_NXLOWER; g_exitcode = NXEXIT_NXLOWER;
} }
return ret; return ret;
} }
#else #else
static inline int nxeg_lower(NXEGWINDOW hwnd) static inline int nxeg_lower(NXEGWINDOW hwnd)
{ {
@ -356,8 +388,10 @@ static inline int nxeg_lower(NXEGWINDOW hwnd)
printf("nxeg_lower: nxtk_lower failed: %d\n", errno); printf("nxeg_lower: nxtk_lower failed: %d\n", errno);
g_exitcode = NXEXIT_NXLOWER; g_exitcode = NXEXIT_NXLOWER;
} }
return ret; return ret;
} }
#endif #endif
/**************************************************************************** /****************************************************************************
@ -373,8 +407,10 @@ static inline int nxeg_raise(NXEGWINDOW hwnd)
printf("nxeg_raise: nx_raise failed: %d\n", errno); printf("nxeg_raise: nx_raise failed: %d\n", errno);
g_exitcode = NXEXIT_NXRAISE; g_exitcode = NXEXIT_NXRAISE;
} }
return ret; return ret;
} }
#else #else
static inline int nxeg_raise(NXEGWINDOW hwnd) static inline int nxeg_raise(NXEGWINDOW hwnd)
{ {
@ -384,8 +420,10 @@ static inline int nxeg_raise(NXEGWINDOW hwnd)
printf("nxeg_raise: nxtk_raise failed: %d\n", errno); printf("nxeg_raise: nxtk_raise failed: %d\n", errno);
g_exitcode = NXEXIT_NXRAISE; g_exitcode = NXEXIT_NXRAISE;
} }
return ret; return ret;
} }
#endif #endif
/**************************************************************************** /****************************************************************************
@ -416,7 +454,7 @@ static int nxeg_initialize(void)
ret = sched_setparam(0, &param); ret = sched_setparam(0, &param);
if (ret < 0) if (ret < 0)
{ {
printf("nxeg_initialize: sched_setparam failed: %d\n" , ret); printf("nxeg_initialize: sched_setparam failed: %d\n", ret);
g_exitcode = NXEXIT_SCHEDSETPARAM; g_exitcode = NXEXIT_SCHEDSETPARAM;
return ERROR; return ERROR;
} }
@ -426,7 +464,8 @@ static int nxeg_initialize(void)
ret = boardctl(BOARDIOC_NX_START, 0); ret = boardctl(BOARDIOC_NX_START, 0);
if (ret < 0) if (ret < 0)
{ {
printf("nxeg_initialize: Failed to start the NX server: %d\n", errno); printf("nxeg_initialize: Failed to start the NX server: %d\n",
errno);
g_exitcode = NXEXIT_TASKCREATE; g_exitcode = NXEXIT_TASKCREATE;
return ERROR; return ERROR;
} }
@ -436,54 +475,54 @@ static int nxeg_initialize(void)
g_hnx = nx_connect(); g_hnx = nx_connect();
if (g_hnx) if (g_hnx)
{ {
pthread_attr_t attr; pthread_attr_t attr;
#ifdef CONFIG_VNCSERVER #ifdef CONFIG_VNCSERVER
/* Setup the VNC server to support keyboard/mouse inputs */ /* Setup the VNC server to support keyboard/mouse inputs */
struct boardioc_vncstart_s vnc = struct boardioc_vncstart_s vnc =
{ {
0, g_hnx 0, g_hnx
}; };
ret = boardctl(BOARDIOC_VNC_START, (uintptr_t)&vnc); ret = boardctl(BOARDIOC_VNC_START, (uintptr_t)&vnc);
if (ret < 0) if (ret < 0)
{ {
printf("boardctl(BOARDIOC_VNC_START) failed: %d\n", ret); printf("boardctl(BOARDIOC_VNC_START) failed: %d\n", ret);
nx_disconnect(g_hnx); nx_disconnect(g_hnx);
g_exitcode = NXEXIT_FBINITIALIZE; g_exitcode = NXEXIT_FBINITIALIZE;
return ERROR; return ERROR;
} }
#endif #endif
/* Start a separate thread to listen for server events. This is probably /* Start a separate thread to listen for server events. This is
* the least efficient way to do this, but it makes this example flow more * probably the least efficient way to do this, but it makes this
* smoothly. * example flow more smoothly.
*/ */
pthread_attr_init(&attr); pthread_attr_init(&attr);
param.sched_priority = CONFIG_EXAMPLES_NX_LISTENERPRIO; param.sched_priority = CONFIG_EXAMPLES_NX_LISTENERPRIO;
pthread_attr_setschedparam(&attr, &param); pthread_attr_setschedparam(&attr, &param);
pthread_attr_setstacksize(&attr, CONFIG_EXAMPLES_NX_STACKSIZE); pthread_attr_setstacksize(&attr, CONFIG_EXAMPLES_NX_STACKSIZE);
ret = pthread_create(&thread, &attr, nx_listenerthread, NULL); ret = pthread_create(&thread, &attr, nx_listenerthread, NULL);
if (ret != 0) if (ret != 0)
{ {
printf("nxeg_initialize: pthread_create failed: %d\n", ret); printf("nxeg_initialize: pthread_create failed: %d\n", ret);
g_exitcode = NXEXIT_PTHREADCREATE; g_exitcode = NXEXIT_PTHREADCREATE;
return ERROR; return ERROR;
} }
/* Don't return until we are connected to the server */ /* Don't return until we are connected to the server */
while (!g_connected) while (!g_connected)
{ {
/* Wait for the listener thread to wake us up when we really /* Wait for the listener thread to wake us up when we really
* are connected. * are connected.
*/ */
sem_wait(&g_semevent); sem_wait(&g_semevent);
} }
} }
else else
{ {
@ -562,6 +601,7 @@ int main(int argc, FAR char *argv[])
{ {
sem_wait(&g_semevent); sem_wait(&g_semevent);
} }
printf("nx_main: Screen resolution (%d,%d)\n", g_xres, g_yres); printf("nx_main: Screen resolution (%d,%d)\n", g_xres, g_yres);
/* Set the size of the window 1 */ /* Set the size of the window 1 */
@ -576,9 +616,8 @@ int main(int argc, FAR char *argv[])
goto errout_with_hwnd1; goto errout_with_hwnd1;
} }
/* Sleep a bit -- both so that we can see the result of the above operations /* Sleep a bit. This lets us see the result of the above operations and,
* but also, in the multi-user case, so that the server can get a chance to * in the multi-user case, gives the server a chance to actually do them.
* actually do them!
*/ */
printf("nx_main: Sleeping\n\n"); printf("nx_main: Sleeping\n\n");
@ -605,7 +644,8 @@ int main(int argc, FAR char *argv[])
#ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS #ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS
printf("nx_main: Add toolbar to window #1\n"); printf("nx_main: Add toolbar to window #1\n");
ret = nxeq_opentoolbar(hwnd1, CONFIG_EXAMPLES_NX_TOOLBAR_HEIGHT, &g_tbcb, &g_wstate[0]); ret = nxeq_opentoolbar(hwnd1, CONFIG_EXAMPLES_NX_TOOLBAR_HEIGHT,
&g_tbcb, &g_wstate[0]);
if (ret < 0) if (ret < 0)
{ {
goto errout_with_hwnd1; goto errout_with_hwnd1;
@ -633,7 +673,7 @@ int main(int argc, FAR char *argv[])
printf("nx_main: Sleeping\n\n"); printf("nx_main: Sleeping\n\n");
sleep(1); sleep(1);
/* Set the size of the window 2 == size of window 1*/ /* Set the size of window 2 equal to the size of window 1 */
printf("nx_main: Set hwnd2 size to (%d,%d)\n", size.w, size.h); printf("nx_main: Set hwnd2 size to (%d,%d)\n", size.w, size.h);
ret = nxeg_setsize(hwnd2, &size); ret = nxeg_setsize(hwnd2, &size);
@ -666,7 +706,8 @@ int main(int argc, FAR char *argv[])
#ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS #ifndef CONFIG_EXAMPLES_NX_RAWWINDOWS
printf("nx_main: Add toolbar to window #2\n"); printf("nx_main: Add toolbar to window #2\n");
ret = nxeq_opentoolbar(hwnd2, CONFIG_EXAMPLES_NX_TOOLBAR_HEIGHT, &g_tbcb, &g_wstate[1]); ret = nxeq_opentoolbar(hwnd2, CONFIG_EXAMPLES_NX_TOOLBAR_HEIGHT,
&g_tbcb, &g_wstate[1]);
if (ret < 0) if (ret < 0)
{ {
goto errout_with_hwnd2; goto errout_with_hwnd2;
@ -770,6 +811,7 @@ errout_with_hwnd1:
nxeg_closewindow(hwnd1, &g_wstate[0]); nxeg_closewindow(hwnd1, &g_wstate[0]);
errout_with_nx: errout_with_nx:
/* Disconnect from the server */ /* Disconnect from the server */
printf("nx_main: Disconnect from the server\n"); printf("nx_main: Disconnect from the server\n");

72
examples/nxhello/nxhello_bkgd.c
View file

@ -76,19 +76,21 @@
****************************************************************************/ ****************************************************************************/
static void nxhello_redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect, static void nxhello_redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect,
bool morem, FAR void *arg); bool morem, FAR void *arg);
static void nxhello_position(NXWINDOW hwnd, FAR const struct nxgl_size_s *size, static void nxhello_position(NXWINDOW hwnd,
FAR const struct nxgl_point_s *pos, FAR const struct nxgl_size_s *size,
FAR const struct nxgl_rect_s *bounds, FAR const struct nxgl_point_s *pos,
FAR void *arg); FAR const struct nxgl_rect_s *bounds,
FAR void *arg);
#ifdef CONFIG_NX_XYINPUT #ifdef CONFIG_NX_XYINPUT
static void nxhello_mousein(NXWINDOW hwnd, FAR const struct nxgl_point_s *pos, static void nxhello_mousein(NXWINDOW hwnd,
uint8_t buttons, FAR void *arg); FAR const struct nxgl_point_s *pos,
uint8_t buttons, FAR void *arg);
#endif #endif
#ifdef CONFIG_NX_KBD #ifdef CONFIG_NX_KBD
static void nxhello_kbdin(NXWINDOW hwnd, uint8_t nch, FAR const uint8_t *ch, static void nxhello_kbdin(NXWINDOW hwnd, uint8_t nch,
FAR void *arg); FAR const uint8_t *ch, FAR void *arg);
#endif #endif
/**************************************************************************** /****************************************************************************
@ -125,7 +127,7 @@ const struct nx_callback_s g_nxhellocb =
****************************************************************************/ ****************************************************************************/
static void nxhello_redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect, static void nxhello_redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect,
bool more, FAR void *arg) bool more, FAR void *arg)
{ {
ginfo("hwnd=%p rect={(%d,%d),(%d,%d)} more=%s\n", ginfo("hwnd=%p rect={(%d,%d),(%d,%d)} more=%s\n",
hwnd, rect->pt1.x, rect->pt1.y, rect->pt2.x, rect->pt2.y, hwnd, rect->pt1.x, rect->pt1.y, rect->pt2.x, rect->pt2.y,
@ -136,10 +138,11 @@ static void nxhello_redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect,
* Name: nxhello_position * Name: nxhello_position
****************************************************************************/ ****************************************************************************/
static void nxhello_position(NXWINDOW hwnd, FAR const struct nxgl_size_s *size, static void nxhello_position(NXWINDOW hwnd,
FAR const struct nxgl_point_s *pos, FAR const struct nxgl_size_s *size,
FAR const struct nxgl_rect_s *bounds, FAR const struct nxgl_point_s *pos,
FAR void *arg) FAR const struct nxgl_rect_s *bounds,
FAR void *arg)
{ {
/* Report the position */ /* Report the position */
@ -171,8 +174,9 @@ static void nxhello_position(NXWINDOW hwnd, FAR const struct nxgl_size_s *size,
****************************************************************************/ ****************************************************************************/
#ifdef CONFIG_NX_XYINPUT #ifdef CONFIG_NX_XYINPUT
static void nxhello_mousein(NXWINDOW hwnd, FAR const struct nxgl_point_s *pos, static void nxhello_mousein(NXWINDOW hwnd,
uint8_t buttons, FAR void *arg) FAR const struct nxgl_point_s *pos,
uint8_t buttons, FAR void *arg)
{ {
printf("nxhello_mousein: hwnd=%p pos=(%d,%d) button=%02x\n", printf("nxhello_mousein: hwnd=%p pos=(%d,%d) button=%02x\n",
hwnd, pos->x, pos->y, buttons); hwnd, pos->x, pos->y, buttons);
@ -184,16 +188,16 @@ static void nxhello_mousein(NXWINDOW hwnd, FAR const struct nxgl_point_s *pos,
****************************************************************************/ ****************************************************************************/
#ifdef CONFIG_NX_KBD #ifdef CONFIG_NX_KBD
static void nxhello_kbdin(NXWINDOW hwnd, uint8_t nch, FAR const uint8_t *ch, static void nxhello_kbdin(NXWINDOW hwnd, uint8_t nch,
FAR void *arg) FAR const uint8_t *ch, FAR void *arg)
{ {
ginfo("hwnd=%p nch=%d\n", hwnd, nch); ginfo("hwnd=%p nch=%d\n", hwnd, nch);
/* In this example, there is no keyboard so a keyboard event is not /* In this example, there is no keyboard so a keyboard event is not
* expected. * expected.
*/ */
printf("nxhello_kbdin: Unexpected keyboard callback\n"); printf("nxhello_kbdin: Unexpected keyboard callback\n");
} }
#endif #endif
@ -212,7 +216,7 @@ static void nxhello_center(FAR struct nxgl_point_s *pos,
* hello world message. * hello world message.
*/ */
for (ptr = (uint8_t*)g_hello, width = 0; *ptr; ptr++) for (ptr = (uint8_t *)g_hello, width = 0; *ptr; ptr++)
{ {
/* Get the font bitmap for this character */ /* Get the font bitmap for this character */
@ -225,7 +229,7 @@ static void nxhello_center(FAR struct nxgl_point_s *pos,
} }
else else
{ {
/* Use the width of a space */ /* Use the width of a space */
width += fontset->spwidth; width += fontset->spwidth;
} }
@ -266,7 +270,7 @@ static void nxhello_initglyph(FAR uint8_t *glyph, uint8_t height,
/* Pack 1-bit pixels into a 2-bits */ /* Pack 1-bit pixels into a 2-bits */
pixel &= 0x01; pixel &= 0x01;
pixel = (pixel) << 1 |pixel; pixel = (pixel) << 1 | pixel;
# endif # endif
# if CONFIG_EXAMPLES_NXHELLO_BPP < 4 # if CONFIG_EXAMPLES_NXHELLO_BPP < 4
@ -274,7 +278,7 @@ static void nxhello_initglyph(FAR uint8_t *glyph, uint8_t height,
/* Pack 2-bit pixels into a nibble */ /* Pack 2-bit pixels into a nibble */
pixel &= 0x03; pixel &= 0x03;
pixel = (pixel) << 2 |pixel; pixel = (pixel) << 2 | pixel;
# endif # endif
@ -348,10 +352,10 @@ void nxhello_hello(NXWINDOW hwnd)
mxstride = (fontset->mxwidth * CONFIG_EXAMPLES_NXHELLO_BPP + 7) >> 3; mxstride = (fontset->mxwidth * CONFIG_EXAMPLES_NXHELLO_BPP + 7) >> 3;
glyphsize = (unsigned int)fontset->mxheight * mxstride; glyphsize = (unsigned int)fontset->mxheight * mxstride;
glyph = (FAR uint8_t*)malloc(glyphsize); glyph = (FAR uint8_t *)malloc(glyphsize);
/* NOTE: no check for failure to allocate the memory. In a real application /* NOTE: no check for failure to allocate the memory. In a real
* you would need to handle that event. * application you would need to handle that event.
*/ */
/* Get a position so the "Hello, World!" string will be centered on the /* Get a position so the "Hello, World!" string will be centered on the
@ -389,7 +393,7 @@ void nxhello_hello(NXWINDOW hwnd)
#if CONFIG_NX_NPLANES > 1 #if CONFIG_NX_NPLANES > 1
# warning "More logic is needed for the case where CONFIG_NX_PLANES > 1" # warning "More logic is needed for the case where CONFIG_NX_PLANES > 1"
#endif #endif
RENDERER((FAR nxgl_mxpixel_t*)glyph, fheight, fwidth, RENDERER((FAR nxgl_mxpixel_t *)glyph, fheight, fwidth,
fstride, fbm, CONFIG_EXAMPLES_NXHELLO_FONTCOLOR); fstride, fbm, CONFIG_EXAMPLES_NXHELLO_FONTCOLOR);
/* Describe the destination of the font with a rectangle */ /* Describe the destination of the font with a rectangle */
@ -411,15 +415,15 @@ void nxhello_hello(NXWINDOW hwnd)
printf("nxhello_write: nx_bitmapwindow failed: %d\n", errno); printf("nxhello_write: nx_bitmapwindow failed: %d\n", errno);
} }
/* Skip to the right the width of the font */ /* Skip to the right the width of the font */
pos.x += fwidth; pos.x += fwidth;
} }
else else
{ {
/* No bitmap (probably because the font is a space). Skip to the /* No bitmap (probably because the font is a space). Skip to the
* right the width of a space. * right the width of a space.
*/ */
pos.x += fontset->spwidth; pos.x += fontset->spwidth;
} }

75
examples/nxhello/nxhello_main.c
View file

@ -95,7 +95,8 @@ static inline int nxhello_initialize(void)
ret = boardctl(BOARDIOC_NX_START, 0); ret = boardctl(BOARDIOC_NX_START, 0);
if (ret < 0) if (ret < 0)
{ {
printf("nxhello_initialize: Failed to start the NX server: %d\n", errno); printf("nxhello_initialize: Failed to start the NX server: %d\n",
errno);
return ERROR; return ERROR;
} }
@ -104,52 +105,53 @@ static inline int nxhello_initialize(void)
g_nxhello.hnx = nx_connect(); g_nxhello.hnx = nx_connect();
if (g_nxhello.hnx) if (g_nxhello.hnx)
{ {
pthread_attr_t attr; pthread_attr_t attr;
#ifdef CONFIG_VNCSERVER #ifdef CONFIG_VNCSERVER
/* Setup the VNC server to support keyboard/mouse inputs */ /* Setup the VNC server to support keyboard/mouse inputs */
struct boardioc_vncstart_s vnc = struct boardioc_vncstart_s vnc =
{ {
0, g_nxhello.hnx 0, g_nxhello.hnx
}; };
ret = boardctl(BOARDIOC_VNC_START, (uintptr_t)&vnc); ret = boardctl(BOARDIOC_VNC_START, (uintptr_t)&vnc);
if (ret < 0) if (ret < 0)
{ {
printf("boardctl(BOARDIOC_VNC_START) failed: %d\n", ret); printf("boardctl(BOARDIOC_VNC_START) failed: %d\n", ret);
nx_disconnect(g_nxhello.hnx); nx_disconnect(g_nxhello.hnx);
return ERROR; return ERROR;
} }
#endif #endif
/* Start a separate thread to listen for server events. This is probably /* Start a separate thread to listen for server events. This is
* the least efficient way to do this, but it makes this example flow more * probably the least efficient way to do this, but it makes this
* smoothly. * example flow more smoothly.
*/ */
pthread_attr_init(&attr); pthread_attr_init(&attr);
param.sched_priority = CONFIG_EXAMPLES_NXHELLO_LISTENERPRIO; param.sched_priority = CONFIG_EXAMPLES_NXHELLO_LISTENERPRIO;
pthread_attr_setschedparam(&attr, &param); pthread_attr_setschedparam(&attr, &param);
pthread_attr_setstacksize(&attr, CONFIG_EXAMPLES_NXHELLO_LISTENER_STACKSIZE); pthread_attr_setstacksize(&attr,
CONFIG_EXAMPLES_NXHELLO_LISTENER_STACKSIZE);
ret = pthread_create(&thread, &attr, nxhello_listener, NULL); ret = pthread_create(&thread, &attr, nxhello_listener, NULL);
if (ret != 0) if (ret != 0)
{ {
printf("nxhello_initialize: pthread_create failed: %d\n", ret); printf("nxhello_initialize: pthread_create failed: %d\n", ret);
return ERROR; return ERROR;
} }
/* Don't return until we are connected to the server */ /* Don't return until we are connected to the server */
while (!g_nxhello.connected) while (!g_nxhello.connected)
{ {
/* Wait for the listener thread to wake us up when we really /* Wait for the listener thread to wake us up when we really
* are connected. * are connected.
*/ */
sem_wait(&g_nxhello.eventsem); sem_wait(&g_nxhello.eventsem);
} }
} }
else else
{ {
@ -225,7 +227,8 @@ int main(int argc, FAR char *argv[])
sem_wait(&g_nxhello.eventsem); sem_wait(&g_nxhello.eventsem);
} }
printf("nxhello_main: Screen resolution (%d,%d)\n", g_nxhello.xres, g_nxhello.yres); printf("nxhello_main: Screen resolution (%d,%d)\n",
g_nxhello.xres, g_nxhello.yres);
/* Now, say hello and exit, sleeping a little before each. */ /* Now, say hello and exit, sleeping a little before each. */

61
examples/nximage/nximage_bkgd.c
View file

@ -109,19 +109,21 @@ struct nximage_run_s
****************************************************************************/ ****************************************************************************/
static void nximage_redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect, static void nximage_redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect,
bool more, FAR void *arg); bool more, FAR void *arg);
static void nximage_position(NXWINDOW hwnd, FAR const struct nxgl_size_s *size, static void nximage_position(NXWINDOW hwnd,
FAR const struct nxgl_point_s *pos, FAR const struct nxgl_size_s *size,
FAR const struct nxgl_rect_s *bounds, FAR const struct nxgl_point_s *pos,
FAR void *arg); FAR const struct nxgl_rect_s *bounds,
FAR void *arg);
#ifdef CONFIG_NX_XYINPUT #ifdef CONFIG_NX_XYINPUT
static void nximage_mousein(NXWINDOW hwnd, FAR const struct nxgl_point_s *pos, static void nximage_mousein(NXWINDOW hwnd,
uint8_t buttons, FAR void *arg); FAR const struct nxgl_point_s *pos,
uint8_t buttons, FAR void *arg);
#endif #endif
#ifdef CONFIG_NX_KBD #ifdef CONFIG_NX_KBD
static void nximage_kbdin(NXWINDOW hwnd, uint8_t nch, FAR const uint8_t *ch, static void nximage_kbdin(NXWINDOW hwnd, uint8_t nch,
FAR void *arg); FAR const uint8_t *ch, FAR void *arg);
#endif #endif
/**************************************************************************** /****************************************************************************
@ -164,7 +166,7 @@ const struct nx_callback_s g_nximagecb =
****************************************************************************/ ****************************************************************************/
static void nximage_redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect, static void nximage_redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect,
bool more, FAR void *arg) bool more, FAR void *arg)
{ {
ginfo("hwnd=%p rect={(%d,%d),(%d,%d)} more=%s\n", ginfo("hwnd=%p rect={(%d,%d),(%d,%d)} more=%s\n",
hwnd, rect->pt1.x, rect->pt1.y, rect->pt2.x, rect->pt2.y, hwnd, rect->pt1.x, rect->pt1.y, rect->pt2.x, rect->pt2.y,
@ -179,10 +181,11 @@ static void nximage_redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect,
* *
****************************************************************************/ ****************************************************************************/
static void nximage_position(NXWINDOW hwnd, FAR const struct nxgl_size_s *size, static void nximage_position(NXWINDOW hwnd,
FAR const struct nxgl_point_s *pos, FAR const struct nxgl_size_s *size,
FAR const struct nxgl_rect_s *bounds, FAR const struct nxgl_point_s *pos,
FAR void *arg) FAR const struct nxgl_rect_s *bounds,
FAR void *arg)
{ {
/* Report the position */ /* Report the position */
@ -218,8 +221,9 @@ static void nximage_position(NXWINDOW hwnd, FAR const struct nxgl_size_s *size,
****************************************************************************/ ****************************************************************************/
#ifdef CONFIG_NX_XYINPUT #ifdef CONFIG_NX_XYINPUT
static void nximage_mousein(NXWINDOW hwnd, FAR const struct nxgl_point_s *pos, static void nximage_mousein(NXWINDOW hwnd,
uint8_t buttons, FAR void *arg) FAR const struct nxgl_point_s *pos,
uint8_t buttons, FAR void *arg)
{ {
printf("nximage_mousein: hwnd=%p pos=(%d,%d) button=%02x\n", printf("nximage_mousein: hwnd=%p pos=(%d,%d) button=%02x\n",
hwnd, pos->x, pos->y, buttons); hwnd, pos->x, pos->y, buttons);
@ -235,16 +239,16 @@ static void nximage_mousein(NXWINDOW hwnd, FAR const struct nxgl_point_s *pos,
****************************************************************************/ ****************************************************************************/
#ifdef CONFIG_NX_KBD #ifdef CONFIG_NX_KBD
static void nximage_kbdin(NXWINDOW hwnd, uint8_t nch, FAR const uint8_t *ch, static void nximage_kbdin(NXWINDOW hwnd, uint8_t nch,
FAR void *arg) FAR const uint8_t *ch, FAR void *arg)
{ {
ginfo("hwnd=%p nch=%d\n", hwnd, nch); ginfo("hwnd=%p nch=%d\n", hwnd, nch);
/* In this example, there is no keyboard so a keyboard event is not /* In this example, there is no keyboard so a keyboard event is not
* expected. * expected.
*/ */
printf("nximage_kbdin: Unexpected keyboard callback\n"); printf("nximage_kbdin: Unexpected keyboard callback\n");
} }
#endif #endif
@ -288,9 +292,9 @@ void nximage_image(NXWINDOW hwnd)
{ {
/* Read input row(s) */ /* Read input row(s) */
nximage_blitrow(g_runs[0].run, &state); nximage_blitrow(g_runs[0].run, &state);
#if NINPUT_ROWS > 1 #if NINPUT_ROWS > 1
nximage_blitrow(g_runs[1].run, &state); nximage_blitrow(g_runs[1].run, &state);
#endif #endif
/* Output rows before averaging */ /* Output rows before averaging */
@ -306,7 +310,8 @@ void nximage_image(NXWINDOW hwnd)
#if CONFIG_NX_NPLANES > 1 #if CONFIG_NX_NPLANES > 1
# warning "More logic is needed for the case where CONFIG_NX_PLANES > 1" # warning "More logic is needed for the case where CONFIG_NX_PLANES > 1"
#endif #endif
ret = nx_bitmap((NXWINDOW)hwnd, &dest, src, &pos, SCALED_WIDTH*sizeof(nxgl_mxpixel_t)); ret = nx_bitmap((NXWINDOW)hwnd, &dest, src, &pos,
SCALED_WIDTH * sizeof(nxgl_mxpixel_t));
if (ret < 0) if (ret < 0)
{ {
printf("nximage_image: nx_bitmapwindow failed: %d\n", errno); printf("nximage_image: nx_bitmapwindow failed: %d\n", errno);
@ -348,7 +353,8 @@ void nximage_image(NXWINDOW hwnd)
#if CONFIG_NX_NPLANES > 1 #if CONFIG_NX_NPLANES > 1
# warning "More logic is needed for the case where CONFIG_NX_PLANES > 1" # warning "More logic is needed for the case where CONFIG_NX_PLANES > 1"
#endif #endif
ret = nx_bitmap((NXWINDOW)hwnd, &dest, src, &pos, SCALED_WIDTH*sizeof(nxgl_mxpixel_t)); ret = nx_bitmap((NXWINDOW)hwnd, &dest, src, &pos,
SCALED_WIDTH * sizeof(nxgl_mxpixel_t));
if (ret < 0) if (ret < 0)
{ {
printf("nximage_image: nx_bitmapwindow failed: %d\n", errno); printf("nximage_image: nx_bitmapwindow failed: %d\n", errno);
@ -369,7 +375,8 @@ void nximage_image(NXWINDOW hwnd)
#if CONFIG_NX_NPLANES > 1 #if CONFIG_NX_NPLANES > 1
# warning "More logic is needed for the case where CONFIG_NX_PLANES > 1" # warning "More logic is needed for the case where CONFIG_NX_PLANES > 1"
#endif #endif
ret = nx_bitmap((NXWINDOW)hwnd, &dest, src, &pos, SCALED_WIDTH*sizeof(nxgl_mxpixel_t)); ret = nx_bitmap((NXWINDOW)hwnd, &dest, src, &pos,
SCALED_WIDTH * sizeof(nxgl_mxpixel_t));
if (ret < 0) if (ret < 0)
{ {
printf("nximage_image: nx_bitmapwindow failed: %d\n", errno); printf("nximage_image: nx_bitmapwindow failed: %d\n", errno);

79
examples/nximage/nximage_main.c
View file

@ -90,7 +90,7 @@ static inline int nximage_initialize(void)
ret = sched_setparam(0, &param); ret = sched_setparam(0, &param);
if (ret < 0) if (ret < 0)
{ {
printf("nximage_initialize: sched_setparam failed: %d\n" , ret); printf("nximage_initialize: sched_setparam failed: %d\n", ret);
return ERROR; return ERROR;
} }
@ -99,7 +99,8 @@ static inline int nximage_initialize(void)
ret = boardctl(BOARDIOC_NX_START, 0); ret = boardctl(BOARDIOC_NX_START, 0);
if (ret < 0) if (ret < 0)
{ {
printf("nximage_initialize: Failed to start the NX server: %d\n", errno); printf("nximage_initialize: Failed to start the NX server: %d\n",
errno);
return ERROR; return ERROR;
} }
@ -108,52 +109,53 @@ static inline int nximage_initialize(void)
g_nximage.hnx = nx_connect(); g_nximage.hnx = nx_connect();
if (g_nximage.hnx) if (g_nximage.hnx)
{ {
pthread_attr_t attr; pthread_attr_t attr;
#ifdef CONFIG_VNCSERVER #ifdef CONFIG_VNCSERVER
/* Setup the VNC server to support keyboard/mouse inputs */ /* Setup the VNC server to support keyboard/mouse inputs */
struct boardioc_vncstart_s vnc = struct boardioc_vncstart_s vnc =
{ {
0, g_nximage.hnx 0, g_nximage.hnx
}; };
ret = boardctl(BOARDIOC_VNC_START, (uintptr_t)&vnc); ret = boardctl(BOARDIOC_VNC_START, (uintptr_t)&vnc);
if (ret < 0) if (ret < 0)
{ {
printf("boardctl(BOARDIOC_VNC_START) failed: %d\n", ret); printf("boardctl(BOARDIOC_VNC_START) failed: %d\n", ret);
nx_disconnect(g_nximage.hnx); nx_disconnect(g_nximage.hnx);
return ERROR; return ERROR;
} }
#endif #endif
/* Start a separate thread to listen for server events. This is probably /* Start a separate thread to listen for server events. This is
* the least efficient way to do this, but it makes this example flow more * probably the least efficient way to do this, but it makes this
* smoothly. * example flow more smoothly.
*/ */
pthread_attr_init(&attr); pthread_attr_init(&attr);
param.sched_priority = CONFIG_EXAMPLES_NXIMAGE_LISTENERPRIO; param.sched_priority = CONFIG_EXAMPLES_NXIMAGE_LISTENERPRIO;
pthread_attr_setschedparam(&attr, &param); pthread_attr_setschedparam(&attr, &param);
pthread_attr_setstacksize(&attr, CONFIG_EXAMPLES_NXIMAGE_LISTENER_STACKSIZE); pthread_attr_setstacksize(&attr,
CONFIG_EXAMPLES_NXIMAGE_LISTENER_STACKSIZE);
ret = pthread_create(&thread, &attr, nximage_listener, NULL); ret = pthread_create(&thread, &attr, nximage_listener, NULL);
if (ret != 0) if (ret != 0)
{ {
printf("nximage_initialize: pthread_create failed: %d\n", ret); printf("nximage_initialize: pthread_create failed: %d\n", ret);
return ERROR; return ERROR;
} }
/* Don't return until we are connected to the server */ /* Don't return until we are connected to the server */
while (!g_nximage.connected) while (!g_nximage.connected)
{ {
/* Wait for the listener thread to wake us up when we really /* Wait for the listener thread to wake us up when we really
* are connected. * are connected.
*/ */
sem_wait(&g_nximage.eventsem); sem_wait(&g_nximage.eventsem);
} }
} }
else else
{ {
@ -194,7 +196,7 @@ int main(int argc, FAR char *argv[])
/* Set the background to the configured background color */ /* Set the background to the configured background color */
color = nximage_bgcolor(); color = nximage_bgcolor();
printf("nximage_main: Set background color=%u\n", color); printf("nximage_main: Set background color=%u\n", color);
ret = nx_setbgcolor(g_nximage.hnx, &color); ret = nx_setbgcolor(g_nximage.hnx, &color);
@ -222,7 +224,8 @@ int main(int argc, FAR char *argv[])
sem_wait(&g_nximage.eventsem); sem_wait(&g_nximage.eventsem);
} }
printf("nximage_main: Screen resolution (%d,%d)\n", g_nximage.xres, g_nximage.yres); printf("nximage_main: Screen resolution (%d,%d)\n",
g_nximage.xres, g_nximage.yres);
/* Now, put up the NuttX logo and wait a bit so that it visible. */ /* Now, put up the NuttX logo and wait a bit so that it visible. */

78
examples/nxlines/nxlines_main.c
View file

@ -51,6 +51,7 @@
****************************************************************************/ ****************************************************************************/
/* Configuration ************************************************************/ /* Configuration ************************************************************/
/* If not specified, assume that the hardware supports one video plane */ /* If not specified, assume that the hardware supports one video plane */
#ifndef CONFIG_EXAMPLES_NXLINES_VPLANE #ifndef CONFIG_EXAMPLES_NXLINES_VPLANE
@ -111,7 +112,7 @@ static inline int nxlines_initialize(void)
ret = sched_setparam(0, &param); ret = sched_setparam(0, &param);
if (ret < 0) if (ret < 0)
{ {
printf("nxlines_initialize: sched_setparam failed: %d\n" , ret); printf("nxlines_initialize: sched_setparam failed: %d\n", ret);
return ERROR; return ERROR;
} }
@ -120,7 +121,8 @@ static inline int nxlines_initialize(void)
ret = boardctl(BOARDIOC_NX_START, 0); ret = boardctl(BOARDIOC_NX_START, 0);
if (ret < 0) if (ret < 0)
{ {
printf("nxlines_initialize: Failed to start the NX server: %d\n", errno); printf("nxlines_initialize: Failed to start the NX server: %d\n",
errno);
return ERROR; return ERROR;
} }
@ -129,52 +131,53 @@ static inline int nxlines_initialize(void)
g_nxlines.hnx = nx_connect(); g_nxlines.hnx = nx_connect();
if (g_nxlines.hnx) if (g_nxlines.hnx)
{ {
pthread_attr_t attr; pthread_attr_t attr;
#ifdef CONFIG_VNCSERVER #ifdef CONFIG_VNCSERVER
/* Setup the VNC server to support keyboard/mouse inputs */ /* Setup the VNC server to support keyboard/mouse inputs */
struct boardioc_vncstart_s vnc = struct boardioc_vncstart_s vnc =
{ {
0, g_nxlines.hnx 0, g_nxlines.hnx
}; };
ret = boardctl(BOARDIOC_VNC_START, (uintptr_t)&vnc); ret = boardctl(BOARDIOC_VNC_START, (uintptr_t)&vnc);
if (ret < 0) if (ret < 0)
{ {
printf("boardctl(BOARDIOC_VNC_START) failed: %d\n", ret); printf("boardctl(BOARDIOC_VNC_START) failed: %d\n", ret);
nx_disconnect(g_nxlines.hnx); nx_disconnect(g_nxlines.hnx);
return ERROR; return ERROR;
} }
#endif #endif
/* Start a separate thread to listen for server events. This is probably /* Start a separate thread to listen for server events. This is
* the least efficient way to do this, but it makes this example flow more * probably the least efficient way to do this, but it makes this
* smoothly. * example flow more smoothly.
*/ */
pthread_attr_init(&attr); pthread_attr_init(&attr);
param.sched_priority = CONFIG_EXAMPLES_NXLINES_LISTENERPRIO; param.sched_priority = CONFIG_EXAMPLES_NXLINES_LISTENERPRIO;
pthread_attr_setschedparam(&attr, &param); pthread_attr_setschedparam(&attr, &param);
pthread_attr_setstacksize(&attr, CONFIG_EXAMPLES_NXLINES_LISTENER_STACKSIZE); pthread_attr_setstacksize(&attr,
CONFIG_EXAMPLES_NXLINES_LISTENER_STACKSIZE);
ret = pthread_create(&thread, &attr, nxlines_listener, NULL); ret = pthread_create(&thread, &attr, nxlines_listener, NULL);
if (ret != 0) if (ret != 0)
{ {
printf("nxlines_initialize: pthread_create failed: %d\n", ret); printf("nxlines_initialize: pthread_create failed: %d\n", ret);
return ERROR; return ERROR;
} }
/* Don't return until we are connected to the server */ /* Don't return until we are connected to the server */
while (!g_nxlines.connected) while (!g_nxlines.connected)
{ {
/* Wait for the listener thread to wake us up when we really /* Wait for the listener thread to wake us up when we really
* are connected. * are connected.
*/ */
sem_wait(&g_nxlines.eventsem); sem_wait(&g_nxlines.eventsem);
} }
} }
else else
{ {
@ -240,7 +243,8 @@ int main(int argc, FAR char *argv[])
sem_wait(&g_nxlines.eventsem); sem_wait(&g_nxlines.eventsem);
} }
printf("nxlines_main: Screen resolution (%d,%d)\n", g_nxlines.xres, g_nxlines.yres); printf("nxlines_main: Screen resolution (%d,%d)\n",
g_nxlines.xres, g_nxlines.yres);
/* Now, say perform the lines (these test does not return so the remaining /* Now, say perform the lines (these test does not return so the remaining
* logic is cosmetic). * logic is cosmetic).

9
examples/nxterm/nxterm_toolbar.c
View file

@ -54,12 +54,14 @@
static void nxtool_redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect, static void nxtool_redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect,
bool morem, FAR void *arg); bool morem, FAR void *arg);
static void nxtool_position(NXWINDOW hwnd, FAR const struct nxgl_size_s *size, static void nxtool_position(NXWINDOW hwnd,
FAR const struct nxgl_size_s *size,
FAR const struct nxgl_point_s *pos, FAR const struct nxgl_point_s *pos,
FAR const struct nxgl_rect_s *bounds, FAR const struct nxgl_rect_s *bounds,
FAR void *arg); FAR void *arg);
#ifdef CONFIG_NX_XYINPUT #ifdef CONFIG_NX_XYINPUT
static void nxtool_mousein(NXWINDOW hwnd, FAR const struct nxgl_point_s *pos, static void nxtool_mousein(NXWINDOW hwnd,
FAR const struct nxgl_point_s *pos,
uint8_t buttons, FAR void *arg); uint8_t buttons, FAR void *arg);
#endif #endif
@ -121,7 +123,8 @@ static void nxtool_redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect,
* Name: nxtool_position * Name: nxtool_position
****************************************************************************/ ****************************************************************************/
static void nxtool_position(NXWINDOW hwnd, FAR const struct nxgl_size_s *size, static void nxtool_position(NXWINDOW hwnd,
FAR const struct nxgl_size_s *size,
FAR const struct nxgl_point_s *pos, FAR const struct nxgl_point_s *pos,
FAR const struct nxgl_rect_s *bounds, FAR const struct nxgl_rect_s *bounds,
FAR void *arg) FAR void *arg)

16
examples/nxterm/nxterm_wndo.c
View file

@ -49,12 +49,14 @@
static void nxwndo_redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect, static void nxwndo_redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect,
bool morem, FAR void *arg); bool morem, FAR void *arg);
static void nxwndo_position(NXWINDOW hwnd, FAR const struct nxgl_size_s *size, static void nxwndo_position(NXWINDOW hwnd,
FAR const struct nxgl_size_s *size,
FAR const struct nxgl_point_s *pos, FAR const struct nxgl_point_s *pos,
FAR const struct nxgl_rect_s *bounds, FAR const struct nxgl_rect_s *bounds,
FAR void *arg); FAR void *arg);
#ifdef CONFIG_NX_XYINPUT #ifdef CONFIG_NX_XYINPUT
static void nxwndo_mousein(NXWINDOW hwnd, FAR const struct nxgl_point_s *pos, static void nxwndo_mousein(NXWINDOW hwnd,
FAR const struct nxgl_point_s *pos,
uint8_t buttons, FAR void *arg); uint8_t buttons, FAR void *arg);
#endif #endif
@ -119,7 +121,9 @@ static void nxwndo_redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect,
} }
else else
{ {
/* If the driver has not been opened, then just redraw the window color */ /* If the driver has not been opened, then just redraw the window
* color.
*/
wcolor[0] = CONFIG_EXAMPLES_NXTERM_WCOLOR; wcolor[0] = CONFIG_EXAMPLES_NXTERM_WCOLOR;
nxtk_fillwindow(hwnd, rect, wcolor); nxtk_fillwindow(hwnd, rect, wcolor);
@ -130,7 +134,8 @@ static void nxwndo_redraw(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect,
* Name: nxwndo_position * Name: nxwndo_position
****************************************************************************/ ****************************************************************************/
static void nxwndo_position(NXWINDOW hwnd, FAR const struct nxgl_size_s *size, static void nxwndo_position(NXWINDOW hwnd,
FAR const struct nxgl_size_s *size,
FAR const struct nxgl_point_s *pos, FAR const struct nxgl_point_s *pos,
FAR const struct nxgl_rect_s *bounds, FAR const struct nxgl_rect_s *bounds,
FAR void *arg) FAR void *arg)
@ -163,7 +168,8 @@ static void nxwndo_position(NXWINDOW hwnd, FAR const struct nxgl_size_s *size,
g_nxterm_vars.haveres = true; g_nxterm_vars.haveres = true;
sem_post(&g_nxterm_vars.eventsem); sem_post(&g_nxterm_vars.eventsem);
ginfo("Have xres=%d yres=%d\n", g_nxterm_vars.xres, g_nxterm_vars.yres); ginfo("Have xres=%d yres=%d\n",
g_nxterm_vars.xres, g_nxterm_vars.yres);
} }
} }

33
examples/nxtext/nxtext_bkgd.c
View file

@ -107,7 +107,8 @@ NXHANDLE g_bgwnd;
* Name: nxbg_redrawrect * Name: nxbg_redrawrect
****************************************************************************/ ****************************************************************************/
static void nxbg_redrawrect(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect) static void nxbg_redrawrect(NXWINDOW hwnd,
FAR const struct nxgl_rect_s *rect)
{ {
int ret; int ret;
int i; int i;
@ -172,7 +173,9 @@ static void nxbg_position(NXWINDOW hwnd, FAR const struct nxgl_size_s *size,
st->wsize.w = size->w; st->wsize.w = size->w;
st->wsize.h = size->h; st->wsize.h = size->h;
/* Save the window limits (these should be the same for all places and all windows */ /* Save the window limits (these should be the same for all places
* and all windows.
*/
g_xres = bounds->pt2.x + 1; g_xres = bounds->pt2.x + 1;
g_yres = bounds->pt2.y + 1; g_yres = bounds->pt2.y + 1;
@ -219,7 +222,8 @@ static void nxbg_kbdin(NXWINDOW hwnd, uint8_t nch, FAR const uint8_t *ch,
* only. * only.
****************************************************************************/ ****************************************************************************/
static inline void nxbg_movedisplay(NXWINDOW hwnd, int bottom, int lineheight) static inline void nxbg_movedisplay(NXWINDOW hwnd, int bottom,
int lineheight)
{ {
FAR struct nxtext_bitmap_s *bm; FAR struct nxtext_bitmap_s *bm;
struct nxgl_rect_s rect; struct nxgl_rect_s rect;
@ -227,10 +231,10 @@ static inline void nxbg_movedisplay(NXWINDOW hwnd, int bottom, int lineheight)
int ret; int ret;
int i; int i;
/* Move each row, one at a time. They could all be moved at once (by calling /* Move each row, one at a time. They could all be moved at once (by
* nxbg_redrawrect), but the since the region is cleared, then re-written, the * calling nxbg_redrawrect), but since the region is cleared, then
* effect would not be good. Below the region is also cleared and re-written, * rewritten, the effect would not be good. Below the region is also
* however, in much smaller chunks. * cleared and rewritten, however, in much smaller chunks.
*/ */
rect.pt1.x = 0; rect.pt1.x = 0;
@ -256,7 +260,8 @@ static inline void nxbg_movedisplay(NXWINDOW hwnd, int bottom, int lineheight)
for (i = 0; i < g_bgstate.nchars; i++) for (i = 0; i < g_bgstate.nchars; i++)
{ {
bm = &g_bgstate.bm[i]; bm = &g_bgstate.bm[i];
if (bm->pos.y <= rect.pt2.y && bm->pos.y + g_bgstate.fheight >= rect.pt1.y) if (bm->pos.y <= rect.pt2.y &&
bm->pos.y + g_bgstate.fheight >= rect.pt1.y)
{ {
nxtext_fillchar(hwnd, &rect, &g_bgstate, g_bghfont, bm); nxtext_fillchar(hwnd, &rect, &g_bgstate, g_bghfont, bm);
} }
@ -266,7 +271,7 @@ static inline void nxbg_movedisplay(NXWINDOW hwnd, int bottom, int lineheight)
/* Finally, clear the bottom part of the display */ /* Finally, clear the bottom part of the display */
rect.pt1.y = bottom; rect.pt1.y = bottom;
rect.pt2.y = g_bgstate.wsize.h- 1; rect.pt2.y = g_bgstate.wsize.h - 1;
ret = nx_fill(hwnd, &rect, g_bgstate.wcolor); ret = nx_fill(hwnd, &rect, g_bgstate.wcolor);
if (ret < 0) if (ret < 0)
@ -296,13 +301,15 @@ static inline void nxbg_scroll(NXWINDOW hwnd, int lineheight)
{ {
/* Yes... Delete the character by moving all of the data */ /* Yes... Delete the character by moving all of the data */
for (j = i; j < g_bgstate.nchars-1; j++) for (j = i; j < g_bgstate.nchars - 1; j++)
{ {
memcpy(&g_bgstate.bm[j], &g_bgstate.bm[j+1], sizeof(struct nxtext_bitmap_s)); memcpy(&g_bgstate.bm[j], &g_bgstate.bm[j + 1],
sizeof(struct nxtext_bitmap_s));
} }
/* Decrement the number of cached characters ('i' is not incremented /* Decrement the number of cached characters. 'i' is not
* in this case because it already points to the next character) * incremented in this case because it already points to the next
* character.
*/ */
g_bgstate.nchars--; g_bgstate.nchars--;

86
examples/nxtext/nxtext_main.c
View file

@ -60,6 +60,7 @@
****************************************************************************/ ****************************************************************************/
/* Configuration ************************************************************/ /* Configuration ************************************************************/
/* If not specified, assume that the hardware supports one video plane */ /* If not specified, assume that the hardware supports one video plane */
#ifndef CONFIG_EXAMPLES_NXTEXT_VPLANE #ifndef CONFIG_EXAMPLES_NXTEXT_VPLANE
@ -138,7 +139,10 @@ nxgl_coord_t g_yres;
bool b_haveresolution = false; bool b_haveresolution = false;
bool g_connected = false; bool g_connected = false;
sem_t g_semevent = {0}; sem_t g_semevent =
{
0
};
int g_exitcode = NXEXIT_SUCCESS; int g_exitcode = NXEXIT_SUCCESS;
@ -162,7 +166,7 @@ static int nxtext_initialize(void)
ret = sched_setparam(0, &param); ret = sched_setparam(0, &param);
if (ret < 0) if (ret < 0)
{ {
printf("nxtext_initialize: sched_setparam failed: %d\n" , ret); printf("nxtext_initialize: sched_setparam failed: %d\n", ret);
g_exitcode = NXEXIT_SCHEDSETPARAM; g_exitcode = NXEXIT_SCHEDSETPARAM;
return ERROR; return ERROR;
} }
@ -173,7 +177,8 @@ static int nxtext_initialize(void)
ret = boardctl(BOARDIOC_NX_START, 0); ret = boardctl(BOARDIOC_NX_START, 0);
if (ret < 0) if (ret < 0)
{ {
printf("nxtext_initialize: Failed to start the NX server: %d\n", errno); printf("nxtext_initialize: Failed to start the NX server: %d\n",
errno);
g_exitcode = NXEXIT_SERVERSTART; g_exitcode = NXEXIT_SERVERSTART;
return ERROR; return ERROR;
} }
@ -188,24 +193,24 @@ static int nxtext_initialize(void)
#ifdef CONFIG_VNCSERVER #ifdef CONFIG_VNCSERVER
/* Setup the VNC server to support keyboard/mouse inputs */ /* Setup the VNC server to support keyboard/mouse inputs */
struct boardioc_vncstart_s vnc = struct boardioc_vncstart_s vnc =
{ {
0, g_hnx 0, g_hnx
}; };
ret = boardctl(BOARDIOC_VNC_START, (uintptr_t)&vnc); ret = boardctl(BOARDIOC_VNC_START, (uintptr_t)&vnc);
if (ret < 0) if (ret < 0)
{ {
printf("boardctl(BOARDIOC_VNC_START) failed: %d\n", ret); printf("boardctl(BOARDIOC_VNC_START) failed: %d\n", ret);
nx_disconnect(g_hnx); nx_disconnect(g_hnx);
g_exitcode = NXEXIT_FBINITIALIZE; g_exitcode = NXEXIT_FBINITIALIZE;
return ERROR; return ERROR;
} }
#endif #endif
/* Start a separate thread to listen for server events. This is probably /* Start a separate thread to listen for server events. This is
* the least efficient way to do this, but it makes this example flow more * probably the least efficient way to do this, but it makes this
* smoothly. * example flow more smoothly.
*/ */
pthread_attr_init(&attr); pthread_attr_init(&attr);
@ -216,10 +221,10 @@ static int nxtext_initialize(void)
ret = pthread_create(&thread, &attr, nxtext_listener, NULL); ret = pthread_create(&thread, &attr, nxtext_listener, NULL);
if (ret != 0) if (ret != 0)
{ {
printf("nxtext_initialize: pthread_create failed: %d\n", ret); printf("nxtext_initialize: pthread_create failed: %d\n", ret);
g_exitcode = NXEXIT_PTHREADCREATE; g_exitcode = NXEXIT_PTHREADCREATE;
return ERROR; return ERROR;
} }
/* Don't return until we are connected to the server */ /* Don't return until we are connected to the server */
@ -277,7 +282,8 @@ int main(int argc, FAR char *argv[])
g_bghfont = nxf_getfonthandle(CONFIG_EXAMPLES_NXTEXT_BGFONTID); g_bghfont = nxf_getfonthandle(CONFIG_EXAMPLES_NXTEXT_BGFONTID);
if (!g_bghfont) if (!g_bghfont)
{ {
printf("nxtext_main: Failed to get background font handle: %d\n", errno); printf("nxtext_main: Failed to get background font handle: %d\n",
errno);
g_exitcode = NXEXIT_FONTOPEN; g_exitcode = NXEXIT_FONTOPEN;
goto errout; goto errout;
} }
@ -285,14 +291,16 @@ int main(int argc, FAR char *argv[])
g_puhfont = nxf_getfonthandle(CONFIG_EXAMPLES_NXTEXT_PUFONTID); g_puhfont = nxf_getfonthandle(CONFIG_EXAMPLES_NXTEXT_PUFONTID);
if (!g_puhfont) if (!g_puhfont)
{ {
printf("nxtext_main: Failed to get pop-up font handle: %d\n", errno); printf("nxtext_main: Failed to get pop-up font handle: %d\n",
errno);
g_exitcode = NXEXIT_FONTOPEN; g_exitcode = NXEXIT_FONTOPEN;
goto errout; goto errout;
} }
/* Set the background to the configured background color */ /* Set the background to the configured background color */
printf("nxtext_main: Set background color=%d\n", CONFIG_EXAMPLES_NXTEXT_BGCOLOR); printf("nxtext_main: Set background color=%d\n",
CONFIG_EXAMPLES_NXTEXT_BGCOLOR);
color = CONFIG_EXAMPLES_NXTEXT_BGCOLOR; color = CONFIG_EXAMPLES_NXTEXT_BGCOLOR;
ret = nx_setbgcolor(g_hnx, &color); ret = nx_setbgcolor(g_hnx, &color);
if (ret < 0) if (ret < 0)
@ -328,7 +336,7 @@ int main(int argc, FAR char *argv[])
popcnt = 0; popcnt = 0;
bkgndx = 0; bkgndx = 0;
for (;;) for (; ; )
{ {
/* Sleep for one second */ /* Sleep for one second */
@ -346,15 +354,18 @@ int main(int argc, FAR char *argv[])
hwnd = nxpu_open(); hwnd = nxpu_open();
#ifdef CONFIG_NX_KBD #ifdef CONFIG_NX_KBD
/* Give keyboard input to the top window (which should be the pop-up) */ /* Give keyboard input to the top window (which should be the
* pop-up).
*/
printf("nxtext_main: Send keyboard input: %s\n", g_pumsg); printf("nxtext_main: Send keyboard input: %s\n", g_pumsg);
ret = nx_kbdin(g_hnx, strlen((FAR const char *)g_pumsg), g_pumsg); ret = nx_kbdin(g_hnx, strlen((FAR const char *)g_pumsg),
g_pumsg);
if (ret < 0) if (ret < 0)
{ {
printf("nxtext_main: nx_kbdin failed: %d\n", errno); printf("nxtext_main: nx_kbdin failed: %d\n", errno);
goto errout_with_hwnd; goto errout_with_hwnd;
} }
#endif #endif
} }
else if (popcnt == 5) else if (popcnt == 5)
@ -367,11 +378,12 @@ int main(int argc, FAR char *argv[])
} }
/* Give another line of text to the background window. Force this /* Give another line of text to the background window. Force this
* text to go the background by calling the background window interfaces * text to the background by calling the background window
* directly. * interfaces directly.
*/ */
nxbg_write(g_bgwnd, (FAR const uint8_t *)g_bgmsg[bkgndx], strlen(g_bgmsg[bkgndx])); nxbg_write(g_bgwnd, (FAR const uint8_t *)g_bgmsg[bkgndx],
strlen(g_bgmsg[bkgndx]));
if (++bkgndx >= BGMSG_LINES) if (++bkgndx >= BGMSG_LINES)
{ {
bkgndx = 0; bkgndx = 0;
@ -386,13 +398,15 @@ errout_with_hwnd:
if (popcnt >= 3) if (popcnt >= 3)
{ {
printf("nxtext_main: Close pop-up\n"); printf("nxtext_main: Close pop-up\n");
nxpu_close(hwnd); nxpu_close(hwnd);
} }
//errout_with_bkgd: /* errout_with_bkgd: */
nx_releasebkgd(g_bgwnd); nx_releasebkgd(g_bgwnd);
errout_with_nx: errout_with_nx:
/* Disconnect from the server */ /* Disconnect from the server */
printf("nxtext_main: Disconnect from the server\n"); printf("nxtext_main: Disconnect from the server\n");

86
examples/nxtext/nxtext_putc.c
View file

@ -95,6 +95,7 @@ static void nxtext_freeglyph(FAR struct nxtext_glyph_s *glyph)
{ {
free(glyph->bitmap); free(glyph->bitmap);
} }
memset(glyph, 0, sizeof(struct nxtext_glyph_s)); memset(glyph, 0, sizeof(struct nxtext_glyph_s));
} }
@ -111,11 +112,11 @@ nxtext_allocglyph(FAR struct nxtext_state_s *st)
int i; int i;
/* Search through the glyph cache looking for an unused glyph. Also, keep /* Search through the glyph cache looking for an unused glyph. Also, keep
* track of the least used glyph as well. We need that if we have to replace * track of the least used glyph as well. We need that if we have to
* a glyph in the cache. * replace a glyph in the cache.
*/ */
for (i = 0; i < st->maxglyphs; i++) for (i = 0; i < st->maxglyphs; i++)
{ {
/* Is this glyph in use? */ /* Is this glyph in use? */
@ -149,9 +150,9 @@ nxtext_allocglyph(FAR struct nxtext_state_s *st)
if (luusecnt > 1) if (luusecnt > 1)
{ {
uint8_t decr = luusecnt - 1; uint8_t decr = luusecnt - 1;
for (i = 0; i < st->maxglyphs; i++) for (i = 0; i < st->maxglyphs; i++)
{ {
/* Is this glyph in use? */ /* Is this glyph in use? */
@ -180,7 +181,7 @@ nxtext_findglyph(FAR struct nxtext_state_s *st, uint8_t ch)
/* First, try to find the glyph in the cache of pre-rendered glyphs */ /* First, try to find the glyph in the cache of pre-rendered glyphs */
for (i = 0; i < st->maxglyphs; i++) for (i = 0; i < st->maxglyphs; i++)
{ {
FAR struct nxtext_glyph_s *glyph = &st->glyph[i]; FAR struct nxtext_glyph_s *glyph = &st->glyph[i];
if (glyph->usecnt > 0 && glyph->code == ch) if (glyph->usecnt > 0 && glyph->code == ch)
@ -189,7 +190,7 @@ nxtext_findglyph(FAR struct nxtext_state_s *st, uint8_t ch)
if (glyph->usecnt < MAX_USECNT) if (glyph->usecnt < MAX_USECNT)
{ {
glyph->usecnt++; glyph->usecnt++;
} }
/* And return the glyph that we found */ /* And return the glyph that we found */
@ -197,6 +198,7 @@ nxtext_findglyph(FAR struct nxtext_state_s *st, uint8_t ch)
return glyph; return glyph;
} }
} }
return NULL; return NULL;
} }
@ -248,13 +250,13 @@ nxtext_renderglyph(FAR struct nxtext_state_s *st,
/* Pack 1-bit pixels into a 2-bits */ /* Pack 1-bit pixels into a 2-bits */
pixel &= 0x01; pixel &= 0x01;
pixel = (pixel) << 1 |pixel; pixel = (pixel) << 1 | pixel;
# endif # endif
# if CONFIG_EXAMPLES_NXTEXT_BPP < 4 # if CONFIG_EXAMPLES_NXTEXT_BPP < 4
/* Pack 2-bit pixels into a nibble */ /* Pack 2-bit pixels into a nibble */
pixel &= 0x03; pixel &= 0x03;
pixel = (pixel) << 2 |pixel; pixel = (pixel) << 2 | pixel;
# endif # endif
/* Pack 4-bit nibbles into a byte */ /* Pack 4-bit nibbles into a byte */
@ -292,7 +294,7 @@ nxtext_renderglyph(FAR struct nxtext_state_s *st,
/* Then render the glyph into the allocated memory */ /* Then render the glyph into the allocated memory */
ret = RENDERER((FAR nxgl_mxpixel_t*)glyph->bitmap, ret = RENDERER((FAR nxgl_mxpixel_t *)glyph->bitmap,
glyph->height, glyph->width, glyph->stride, glyph->height, glyph->width, glyph->stride,
fbm, st->fcolor[0]); fbm, st->fcolor[0]);
if (ret < 0) if (ret < 0)
@ -312,7 +314,8 @@ nxtext_renderglyph(FAR struct nxtext_state_s *st,
* Name: nxtext_fontsize * Name: nxtext_fontsize
****************************************************************************/ ****************************************************************************/
static int nxtext_fontsize(NXHANDLE hfont, uint8_t ch, FAR struct nxgl_size_s *size) static int nxtext_fontsize(NXHANDLE hfont, uint8_t ch,
FAR struct nxgl_size_s *size)
{ {
FAR const struct nx_fontbitmap_s *fbm; FAR const struct nx_fontbitmap_s *fbm;
@ -379,37 +382,39 @@ nxtext_addchar(NXHANDLE hfont, FAR struct nxtext_state_s *st, uint8_t ch)
if (st->nchars < st->maxchars) if (st->nchars < st->maxchars)
{ {
/* Yes, setup the bitmap information */ /* Yes, setup the bitmap information */
bm = &st->bm[st->nchars]; bm = &st->bm[st->nchars];
bm->code = ch; bm->code = ch;
bm->flags = 0; bm->flags = 0;
bm->pos.x = st->fpos.x; bm->pos.x = st->fpos.x;
bm->pos.y = st->fpos.y; bm->pos.y = st->fpos.y;
/* Find (or create) the matching glyph */ /* Find (or create) the matching glyph */
glyph = nxtext_getglyph(hfont, st, ch); glyph = nxtext_getglyph(hfont, st, ch);
if (!glyph) if (!glyph)
{ {
/* No, there is no font for this code. Just mark this as a space. */ /* No, there is no font for this code. Just mark this as a
* space.
*/
bm->flags |= BMFLAGS_NOGLYPH; bm->flags |= BMFLAGS_NOGLYPH;
/* Set up the next character position */ /* Set up the next character position */
st->fpos.x += st->spwidth; st->fpos.x += st->spwidth;
} }
else else
{ {
/* Set up the next character position */ /* Set up the next character position */
st->fpos.x += glyph->width; st->fpos.x += glyph->width;
} }
/* Success.. increment nchars to retain this character */ /* Success.. increment nchars to retain this character */
st->nchars++; st->nchars++;
} }
return bm; return bm;
@ -465,7 +470,8 @@ void nxtext_newline(FAR struct nxtext_state_s *st)
* *
****************************************************************************/ ****************************************************************************/
void nxtext_putc(NXWINDOW hwnd, FAR struct nxtext_state_s *st, NXHANDLE hfont, uint8_t ch) void nxtext_putc(NXWINDOW hwnd, FAR struct nxtext_state_s *st,
NXHANDLE hfont, uint8_t ch)
{ {
FAR const struct nxtext_bitmap_s *bm; FAR const struct nxtext_bitmap_s *bm;
@ -562,13 +568,13 @@ void nxtext_fillchar(NXWINDOW hwnd, FAR const struct nxgl_rect_s *rect,
/* Find (or create) the glyph that goes with this font */ /* Find (or create) the glyph that goes with this font */
glyph = nxtext_getglyph(hfont, st, bm->code); glyph = nxtext_getglyph(hfont, st, bm->code);
if (!glyph) if (!glyph)
{ {
/* Shouldn't happen */ /* Shouldn't happen */
return; return;
} }
/* Blit the font bitmap into the window */ /* Blit the font bitmap into the window */

59
examples/pwfb/pwfb_main.c
View file

@ -57,6 +57,8 @@
#include "pwfb_internal.h" #include "pwfb_internal.h"
#define ARROW1_CURSOR_IMAGE g_arrow1##Cursor
/**************************************************************************** /****************************************************************************
* Private Data * Private Data
****************************************************************************/ ****************************************************************************/
@ -115,22 +117,22 @@ static bool pwfb_server_initialize(FAR struct pwfb_state_s *st)
#ifdef CONFIG_VNCSERVER #ifdef CONFIG_VNCSERVER
/* Setup the VNC server to support keyboard/mouse inputs */ /* Setup the VNC server to support keyboard/mouse inputs */
struct boardioc_vncstart_s vnc = struct boardioc_vncstart_s vnc =
{ {
0, st->hnx 0, st->hnx
}; };
ret = boardctl(BOARDIOC_VNC_START, (uintptr_t)&vnc); ret = boardctl(BOARDIOC_VNC_START, (uintptr_t)&vnc);
if (ret < 0) if (ret < 0)
{ {
printf("pwfb_server_initialize: ERROR: " printf("pwfb_server_initialize: ERROR: "
"boardctl(BOARDIOC_VNC_START) failed: %d\n", "boardctl(BOARDIOC_VNC_START) failed: %d\n",
ret); ret);
nx_disconnect(st->hnx); nx_disconnect(st->hnx);
g_exitcode = NXEXIT_FBINITIALIZE; g_exitcode = NXEXIT_FBINITIALIZE;
return ERROR; return ERROR;
} }
#endif #endif
} }
else else
@ -168,10 +170,10 @@ static bool pwfb_listener_initialize(FAR struct pwfb_state_s *st)
ret = pthread_create(&thread, &attr, pwfb_listener, st); ret = pthread_create(&thread, &attr, pwfb_listener, st);
if (ret != 0) if (ret != 0)
{ {
printf("pwfb_listener_initialize: ERROR: " printf("pwfb_listener_initialize: ERROR: "
"pthread_create failed: %d\n", "pthread_create failed: %d\n",
ret); ret);
return false; return false;
} }
/* Don't return until we are connected to the server */ /* Don't return until we are connected to the server */
@ -340,8 +342,8 @@ static bool pwfb_putc(FAR struct pwfb_state_s *st,
/* Render the glyph into the window */ /* Render the glyph into the window */
src = glyph->bitmap; src = glyph->bitmap;
ret = nxtk_bitmapwindow(wndo->hwnd, &bounds, &src, ret = nxtk_bitmapwindow(wndo->hwnd, &bounds, &src,
fpos, (unsigned int)glyph->stride); fpos, (unsigned int)glyph->stride);
if (ret < 0) if (ret < 0)
{ {
printf("pwfb_putc: ERROR: " printf("pwfb_putc: ERROR: "
@ -510,8 +512,8 @@ static bool pwfb_configure_cursor(FAR struct pwfb_state_s *st,
st->cursor.state = PFWB_CURSOR_MOVING; st->cursor.state = PFWB_CURSOR_MOVING;
st->cursor.countdown = CURSOR_MOVING_DELAY; st->cursor.countdown = CURSOR_MOVING_DELAY;
st->cursor.blinktime = 0; st->cursor.blinktime = 0;
st->cursor.xmax = itob16(st->xres - g_arrow1Cursor.size.w - 1); st->cursor.xmax = itob16(st->xres - ARROW1_CURSOR_IMAGE.size.w - 1);
st->cursor.ymax = itob16(st->yres - g_arrow1Cursor.size.h - 1); st->cursor.ymax = itob16(st->yres - ARROW1_CURSOR_IMAGE.size.h - 1);
st->cursor.xpos = itob16(pos->x); st->cursor.xpos = itob16(pos->x);
st->cursor.ypos = itob16(pos->y); st->cursor.ypos = itob16(pos->y);
st->cursor.deltax = dtob16(deltax); st->cursor.deltax = dtob16(deltax);
@ -519,7 +521,7 @@ static bool pwfb_configure_cursor(FAR struct pwfb_state_s *st,
/* Set the cursor image */ /* Set the cursor image */
ret = nxcursor_setimage(st->hnx, &g_arrow1Cursor); ret = nxcursor_setimage(st->hnx, &ARROW1_CURSOR_IMAGE);
if (ret < 0) if (ret < 0)
{ {
printf("pwfb_configure_cursor: ERROR: " printf("pwfb_configure_cursor: ERROR: "
@ -651,7 +653,8 @@ int main(int argc, FAR char *argv[])
pos.x = wstate.xres / 8; pos.x = wstate.xres / 8;
pos.y = wstate.yres / 8; pos.y = wstate.yres / 8;
if (!pwfb_configure_window(&wstate, 0, &size, &pos, g_wndomsg1, 4.200, 4.285)) if (!pwfb_configure_window(&wstate, 0, &size, &pos, g_wndomsg1,
4.200, 4.285))
{ {
printf("pwfb_main: ERROR: " printf("pwfb_main: ERROR: "
"pwfb_configure_window failed for window 1\n"); "pwfb_configure_window failed for window 1\n");
@ -681,7 +684,8 @@ int main(int argc, FAR char *argv[])
pos.x = wstate.xres / 4; pos.x = wstate.xres / 4;
pos.y = wstate.yres / 4; pos.y = wstate.yres / 4;
if (!pwfb_configure_window(&wstate, 1, &size, &pos, g_wndomsg2, -3.317, 5.0)) if (!pwfb_configure_window(&wstate, 1, &size, &pos, g_wndomsg2,
-3.317, 5.0))
{ {
printf("pwfb_main: ERROR: " printf("pwfb_main: ERROR: "
"pwfb_configure_window failed for window 2\n"); "pwfb_configure_window failed for window 2\n");
@ -711,7 +715,8 @@ int main(int argc, FAR char *argv[])
pos.x = (3 * wstate.xres) / 8; pos.x = (3 * wstate.xres) / 8;
pos.y = (3 * wstate.yres) / 8; pos.y = (3 * wstate.yres) / 8;
if (!pwfb_configure_window(&wstate, 2, &size, &pos, g_wndomsg3, 4.600, -3.852)) if (!pwfb_configure_window(&wstate, 2, &size, &pos, g_wndomsg3,
4.600, -3.852))
{ {
printf("pwfb_main: ERROR: " printf("pwfb_main: ERROR: "
"pwfb_configure_window failed for window 2\n"); "pwfb_configure_window failed for window 2\n");
@ -797,6 +802,7 @@ errout_with_hwnd1:
#endif #endif
errout_with_fontcache: errout_with_fontcache:
/* Release the font cache */ /* Release the font cache */
nxf_cache_disconnect(wstate.wndo[0].fcache); nxf_cache_disconnect(wstate.wndo[0].fcache);
@ -804,6 +810,7 @@ errout_with_fontcache:
nxf_cache_disconnect(wstate.wndo[2].fcache); nxf_cache_disconnect(wstate.wndo[2].fcache);
errout_with_nx: errout_with_nx:
/* Disconnect from the server */ /* Disconnect from the server */
printf("pwfb_main: Disconnect from the server\n"); printf("pwfb_main: Disconnect from the server\n");

65
examples/pwlines/pwlines_main.c
View file

@ -94,21 +94,21 @@ static bool pwlines_server_initialize(FAR struct pwlines_state_s *st)
#ifdef CONFIG_VNCSERVER #ifdef CONFIG_VNCSERVER
/* Setup the VNC server to support keyboard/mouse inputs */ /* Setup the VNC server to support keyboard/mouse inputs */
struct boardioc_vncstart_s vnc = struct boardioc_vncstart_s vnc =
{ {
0, st->hnx 0, st->hnx
}; };
ret = boardctl(BOARDIOC_VNC_START, (uintptr_t)&vnc); ret = boardctl(BOARDIOC_VNC_START, (uintptr_t)&vnc);
if (ret < 0) if (ret < 0)
{ {
printf("pwlines_server_initialize: ERROR: " printf("pwlines_server_initialize: ERROR: "
"boardctl(BOARDIOC_VNC_START) failed: %d\n", "boardctl(BOARDIOC_VNC_START) failed: %d\n",
ret); ret);
nx_disconnect(st->hnx); nx_disconnect(st->hnx);
return false; return false;
} }
#endif #endif
} }
else else
@ -141,15 +141,16 @@ static bool pwlines_listener_initialize(FAR struct pwlines_state_s *st)
pthread_attr_init(&attr); pthread_attr_init(&attr);
param.sched_priority = CONFIG_EXAMPLES_PWLINES_LISTENER_PRIO; param.sched_priority = CONFIG_EXAMPLES_PWLINES_LISTENER_PRIO;
pthread_attr_setschedparam(&attr, &param); pthread_attr_setschedparam(&attr, &param);
pthread_attr_setstacksize(&attr, CONFIG_EXAMPLES_PWLINES_LISTENER_STACKSIZE); pthread_attr_setstacksize(&attr,
CONFIG_EXAMPLES_PWLINES_LISTENER_STACKSIZE);
ret = pthread_create(&thread, &attr, pwlines_listener, st); ret = pthread_create(&thread, &attr, pwlines_listener, st);
if (ret != 0) if (ret != 0)
{ {
printf("pwlines_listener_initialize: ERROR: " printf("pwlines_listener_initialize: ERROR: "
"pthread_create failed: %d\n", "pthread_create failed: %d\n",
ret); ret);
return false; return false;
} }
/* Don't return until we are connected to the server */ /* Don't return until we are connected to the server */
@ -193,7 +194,8 @@ static bool pwlines_state_initialize(FAR struct pwlines_state_s *st)
* Name: pwlines_configure_window * Name: pwlines_configure_window
****************************************************************************/ ****************************************************************************/
static bool pwlines_configure_window(FAR struct pwlines_state_s *st, int wndx, static bool pwlines_configure_window(FAR struct pwlines_state_s *st,
int wndx,
FAR struct nxgl_size_s *size, FAR struct nxgl_size_s *size,
FAR struct nxgl_point_s *pos, FAR struct nxgl_point_s *pos,
double deltax, double deltay) double deltax, double deltay)
@ -353,8 +355,9 @@ int main(int argc, FAR char *argv[])
printf("pwlines_main: Open window 1\n"); printf("pwlines_main: Open window 1\n");
wstate.wndo[0].hwnd = nxtk_openwindow(wstate.hnx, NXBE_WINDOW_RAMBACKED, wstate.wndo[0].hwnd =
&g_pwlines_wncb, (FAR void *)&wstate); nxtk_openwindow(wstate.hnx, NXBE_WINDOW_RAMBACKED,
&g_pwlines_wncb, (FAR void *)&wstate);
if (wstate.wndo[0].hwnd == NULL) if (wstate.wndo[0].hwnd == NULL)
{ {
printf("pwlines_main: ERROR: " printf("pwlines_main: ERROR: "
@ -386,7 +389,8 @@ int main(int argc, FAR char *argv[])
pos.x = wstate.xres / 8; pos.x = wstate.xres / 8;
pos.y = wstate.yres / 8; pos.y = wstate.yres / 8;
if (!pwlines_configure_window(&wstate, 0, &size, &pos, 4.200, 4.285)) if (!pwlines_configure_window(&wstate, 0, &size, &pos,
4.200, 4.285))
{ {
printf("pwlines_main: ERROR: " printf("pwlines_main: ERROR: "
"pwlines_configure_window failed for window 1\n"); "pwlines_configure_window failed for window 1\n");
@ -397,8 +401,9 @@ int main(int argc, FAR char *argv[])
printf("pwlines_main: Open window 2\n"); printf("pwlines_main: Open window 2\n");
wstate.wndo[1].hwnd = nxtk_openwindow(wstate.hnx, NXBE_WINDOW_RAMBACKED, wstate.wndo[1].hwnd =
&g_pwlines_wncb, (FAR void *)&wstate); nxtk_openwindow(wstate.hnx, NXBE_WINDOW_RAMBACKED,
&g_pwlines_wncb, (FAR void *)&wstate);
if (wstate.wndo[1].hwnd == NULL) if (wstate.wndo[1].hwnd == NULL)
{ {
printf("pwlines_main: ERROR: " printf("pwlines_main: ERROR: "
@ -414,7 +419,8 @@ int main(int argc, FAR char *argv[])
pos.x = wstate.xres / 4; pos.x = wstate.xres / 4;
pos.y = wstate.yres / 4; pos.y = wstate.yres / 4;
if (!pwlines_configure_window(&wstate, 1, &size, &pos, -3.317, 5.0)) if (!pwlines_configure_window(&wstate, 1, &size, &pos,
-3.317, 5.0))
{ {
printf("pwlines_main: ERROR: " printf("pwlines_main: ERROR: "
"pwlines_configure_window failed for window 2\n"); "pwlines_configure_window failed for window 2\n");
@ -425,8 +431,9 @@ int main(int argc, FAR char *argv[])
printf("pwlines_main: Open window 3\n"); printf("pwlines_main: Open window 3\n");
wstate.wndo[2].hwnd = nxtk_openwindow(wstate.hnx, NXBE_WINDOW_RAMBACKED, wstate.wndo[2].hwnd =
&g_pwlines_wncb, (FAR void *)&wstate); nxtk_openwindow(wstate.hnx, NXBE_WINDOW_RAMBACKED,
&g_pwlines_wncb, (FAR void *)&wstate);
if (wstate.wndo[2].hwnd == NULL) if (wstate.wndo[2].hwnd == NULL)
{ {
printf("pwlines_main: ERROR: " printf("pwlines_main: ERROR: "
@ -442,7 +449,8 @@ int main(int argc, FAR char *argv[])
pos.x = (3 * wstate.xres) / 8; pos.x = (3 * wstate.xres) / 8;
pos.y = (3 * wstate.yres) / 8; pos.y = (3 * wstate.yres) / 8;
if (!pwlines_configure_window(&wstate, 2, &size, &pos, 4.600, -3.852)) if (!pwlines_configure_window(&wstate, 2, &size, &pos,
4.600, -3.852))
{ {
printf("pwlines_main: ERROR: " printf("pwlines_main: ERROR: "
"pwlines_configure_window failed for window 2\n"); "pwlines_configure_window failed for window 2\n");
@ -512,6 +520,7 @@ errout_with_hwnd1:
} }
errout_with_nx: errout_with_nx:
/* Disconnect from the server */ /* Disconnect from the server */
printf("pwlines_main: Disconnect from the server\n"); printf("pwlines_main: Disconnect from the server\n");

19
examples/qencoder/qe_main.c
View file

@ -307,11 +307,14 @@ int main(int argc, FAR char *argv[])
if (g_qeexample.use_qeindex) if (g_qeexample.use_qeindex)
{ {
ret = ioctl(fd, QEIOC_GETINDEX, (unsigned long)((uintptr_t)&index)); ret = ioctl(fd, QEIOC_GETINDEX,
(unsigned long)((uintptr_t)&index));
if (ret < 0) if (ret < 0)
{ {
printf("qe_main: ioctl(QEIOC_GETINDEX) failed: %d\n", errno); printf("qe_main: ioctl(QEIOC_GETINDEX) failed: %d\n",
printf("Your MCU probably does not support this ioctl call.\n"); errno);
printf("Your MCU probably does not support this ioctl "
"call.\n");
printf("Consider using this example without the -i option.\n"); printf("Consider using this example without the -i option.\n");
exitval = EXIT_FAILURE; exitval = EXIT_FAILURE;
goto errout_with_dev; goto errout_with_dev;
@ -321,13 +324,17 @@ int main(int argc, FAR char *argv[])
else else
{ {
printf("qe_main: %3d. pos: %" PRIi32 ", last index: %" PRIi32 ", hit indexes: %" \ printf("qe_main: %3d. pos: %" PRIi32 ", "
PRIi16 "\n", nloops + 1, index.qenc_pos, index.indx_pos, index.indx_cnt); "last index: %" PRIi32 ", "
"hit indexes: %" PRIi16 "\n",
nloops + 1, index.qenc_pos, index.indx_pos,
index.indx_cnt);
} }
} }
else else
{ {
ret = ioctl(fd, QEIOC_POSITION, (unsigned long)((uintptr_t)&position)); ret = ioctl(fd, QEIOC_POSITION,
(unsigned long)((uintptr_t)&position));
if (ret < 0) if (ret < 0)
{ {
printf("qe_main: ioctl(QEIOC_POSITION) failed: %d\n", errno); printf("qe_main: ioctl(QEIOC_POSITION) failed: %d\n", errno);

5
fsutils/flash_eraseall/flash_eraseall.c
View file

@ -71,13 +71,14 @@ int flash_eraseall(FAR const char *driver)
if (ret < 0) if (ret < 0)
{ {
errcode = errno; errcode = errno;
ferr("ERROR: MTD ioctl(%04x) failed: %d\n", MTDIOC_BULKERASE, errcode); ferr("ERROR: MTD ioctl(%04x) failed: %d\n",
MTDIOC_BULKERASE, errcode);
ret = -errcode; ret = -errcode;
} }
/* Close the block driver */ /* Close the block driver */
close(fd); close(fd);
} }
return ret; return ret;

25
graphics/tiff/tiff_addstrip.c
View file

@ -65,13 +65,15 @@
* tiff_initialize(). * tiff_initialize().
* *
* Input Parameters: * Input Parameters:
* info - A pointer to the caller allocated parameter passing/TIFF state instance. * info - A pointer to the caller allocated parameter passing/TIFF
* state instance.
* buffer - A buffer containing a single row of data. * buffer - A buffer containing a single row of data.
* *
* Returned Value: * Returned Value:
* Zero (OK) on success. A negated errno value on failure. * Zero (OK) on success. A negated errno value on failure.
* *
****************************************************************************/ ****************************************************************************/
int tiff_convstrip(FAR struct tiff_info_s *info, FAR const uint8_t *strip) int tiff_convstrip(FAR struct tiff_info_s *info, FAR const uint8_t *strip)
{ {
#ifdef CONFIG_DEBUG_GRAPHICS #ifdef CONFIG_DEBUG_GRAPHICS
@ -100,9 +102,9 @@ int tiff_convstrip(FAR struct tiff_info_s *info, FAR const uint8_t *strip)
/* Convert RGB565 to RGB888 */ /* Convert RGB565 to RGB888 */
rgb565 = *src++; rgb565 = *src++;
*dest++ = (rgb565 >> (11-3)) & 0xf8; /* Move bits 11-15 to 3-7 */ *dest++ = (rgb565 >> (11 - 3)) & 0xf8; /* Move bits 11-15 to 3-7 */
*dest++ = (rgb565 >> ( 5-2)) & 0xfc; /* Move bits 5-10 to 2-7 */ *dest++ = (rgb565 >> (5 - 2)) & 0xfc; /* Move bits 5-10 to 2-7 */
*dest++ = (rgb565 << ( 3)) & 0xf8; /* Move bits 0- 4 to 3-7 */ *dest++ = (rgb565 << 3) & 0xf8; /* Move bits 0- 4 to 3-7 */
/* Update the byte count */ /* Update the byte count */
@ -113,7 +115,7 @@ int tiff_convstrip(FAR struct tiff_info_s *info, FAR const uint8_t *strip)
/* Flush the conversion buffer to tmpfile2 when it becomes full */ /* Flush the conversion buffer to tmpfile2 when it becomes full */
if (nbytes > (info->iosize-3)) if (nbytes > (info->iosize - 3))
{ {
ret = tiff_write(info->tmp2fd, info->iobuffer, nbytes); ret = tiff_write(info->tmp2fd, info->iobuffer, nbytes);
if (ret < 0) if (ret < 0)
@ -134,6 +136,7 @@ int tiff_convstrip(FAR struct tiff_info_s *info, FAR const uint8_t *strip)
#ifdef CONFIG_DEBUG_GRAPHICS #ifdef CONFIG_DEBUG_GRAPHICS
DEBUGASSERT(ntotal == info->bps); DEBUGASSERT(ntotal == info->bps);
#endif #endif
return ret; return ret;
} }
@ -150,7 +153,8 @@ int tiff_convstrip(FAR struct tiff_info_s *info, FAR const uint8_t *strip)
* tiff_initialize(). * tiff_initialize().
* *
* Input Parameters: * Input Parameters:
* info - A pointer to the caller allocated parameter passing/TIFF state instance. * info - A pointer to the caller allocated parameter passing/TIFF
* state instance.
* buffer - A buffer containing a single row of data. * buffer - A buffer containing a single row of data.
* *
* Returned Value: * Returned Value:
@ -172,7 +176,9 @@ int tiff_addstrip(FAR struct tiff_info_s *info, FAR const uint8_t *strip)
ret = tiff_convstrip(info, strip); ret = tiff_convstrip(info, strip);
} }
/* For other formats, it is a simple write using the number of bytes per strip */ /* For other formats, it is a simple write using the number of bytes per
* strip.
*/
else else
{ {
@ -191,6 +197,7 @@ int tiff_addstrip(FAR struct tiff_info_s *info, FAR const uint8_t *strip)
{ {
goto errout; goto errout;
} }
info->outsize += 4; info->outsize += 4;
ret = tiff_putint32(info->tmp1fd, info->tmp2size); ret = tiff_putint32(info->tmp1fd, info->tmp2size);
@ -198,6 +205,7 @@ int tiff_addstrip(FAR struct tiff_info_s *info, FAR const uint8_t *strip)
{ {
goto errout; goto errout;
} }
info->tmp1size += 4; info->tmp1size += 4;
/* Increment the size of tmp2file. */ /* Increment the size of tmp2file. */
@ -212,14 +220,17 @@ int tiff_addstrip(FAR struct tiff_info_s *info, FAR const uint8_t *strip)
ret = (int)newsize; ret = (int)newsize;
goto errout; goto errout;
} }
info->tmp2size = (size_t)newsize; info->tmp2size = (size_t)newsize;
/* Increment the number of strips in the TIFF file */ /* Increment the number of strips in the TIFF file */
info->nstrips++; info->nstrips++;
return OK; return OK;
errout: errout:
tiff_abort(info); tiff_abort(info);
return ret; return ret;
} }

180
graphics/tiff/tiff_initialize.c
View file

@ -41,6 +41,7 @@
/**************************************************************************** /****************************************************************************
* Pre-Processor Definitions * Pre-Processor Definitions
****************************************************************************/ ****************************************************************************/
/* Bi-level Images /* Bi-level Images
* *
* Offset Description Contents/Notes * Offset Description Contents/Notes
@ -50,13 +51,18 @@
* 8 [2 bytes padding] * 8 [2 bytes padding]
* IFD: 10 Number of Directory Entries 13 * IFD: 10 Number of Directory Entries 13
* 12 NewSubfileType * 12 NewSubfileType
* 24 ImageWidth Number of columns is a user parameter * 24 ImageWidth Number of columns is a user
* 36 ImageLength Number of rows is a user parameter * parameter
* 48 Compression Hard-coded no compression (for now) * 36 ImageLength Number of rows is a user
* parameter
* 48 Compression Hard-coded no compression
* (for now)
* 60 PhotometricInterpretation Value is a user parameter * 60 PhotometricInterpretation Value is a user parameter
* 72 StripOffsets Offset and count determined as strips added * 72 StripOffsets Offset and count determined
* as strips added
* 84 RowsPerStrip Value is a user parameter * 84 RowsPerStrip Value is a user parameter
* 96 StripByteCounts Offset and count determined as strips added * 96 StripByteCounts Offset and count determined
* as strips added
* 108 XResolution Value is a user parameter * 108 XResolution Value is a user parameter
* 120 YResolution Value is a user parameter * 120 YResolution Value is a user parameter
* 132 Resolution Unit Hard-coded to "inches" * 132 Resolution Unit Hard-coded to "inches"
@ -67,8 +73,10 @@
* Values: * Values:
* 172 XResolution Hard-coded to 300/1 * 172 XResolution Hard-coded to 300/1
* 180 YResolution Hard-coded to 300/1 * 180 YResolution Hard-coded to 300/1
* 188 "NuttX" Length = 6 (including NUL terminator) * 188 "NuttX" Length = 6 (including NUL
* 194 "YYYY:MM:DD HH:MM:SS" Length = 20 (including NUL terminator) * terminator)
* 194 "YYYY:MM:DD HH:MM:SS" Length = 20 (including NUL
* terminator)
* 214 [2 bytes padding] * 214 [2 bytes padding]
* 216 StripByteCounts Beginning of strip byte counts * 216 StripByteCounts Beginning of strip byte counts
* xxx StripOffsets Beginning of strip offsets * xxx StripOffsets Beginning of strip offsets
@ -76,7 +84,7 @@
* xxx Data for strips Beginning of strip data * xxx Data for strips Beginning of strip data
*/ */
#define TIFF_IFD_OFFSET (SIZEOF_TIFF_HEADER+2) #define TIFF_IFD_OFFSET (SIZEOF_TIFF_HEADER + 2)
#define TIFF_BILEV_NIFDENTRIES 13 #define TIFF_BILEV_NIFDENTRIES 13
#define TIFF_BILEV_STRIPIFDOFFS 72 #define TIFF_BILEV_STRIPIFDOFFS 72
@ -102,14 +110,19 @@
* 8 [2 bytes padding] * 8 [2 bytes padding]
* IFD: 10 Number of Directory Entries 14 * IFD: 10 Number of Directory Entries 14
* 12 NewSubfileType * 12 NewSubfileType
* 24 ImageWidth Number of columns is a user parameter * 24 ImageWidth Number of columns is a user
* 36 ImageLength Number of rows is a user parameter * parameter
* 36 ImageLength Number of rows is a user
* parameter
* 48 BitsPerSample * 48 BitsPerSample
* 60 Compression Hard-coded no compression (for now) * 60 Compression Hard-coded no compression
* (for now)
* 72 PhotometricInterpretation Value is a user parameter * 72 PhotometricInterpretation Value is a user parameter
* 84 StripOffsets Offset and count determined as strips added * 84 StripOffsets Offset and count determined
* as strips added
* 96 RowsPerStrip Value is a user parameter * 96 RowsPerStrip Value is a user parameter
* 108 StripByteCounts Offset and count determined as strips added * 108 StripByteCounts Offset and count determined
* as strips added
* 120 XResolution Value is a user parameter * 120 XResolution Value is a user parameter
* 132 YResolution Value is a user parameter * 132 YResolution Value is a user parameter
* 144 Resolution Unit Hard-coded to "inches" * 144 Resolution Unit Hard-coded to "inches"
@ -120,8 +133,10 @@
* Values: * Values:
* 184 XResolution Hard-coded to 300/1 * 184 XResolution Hard-coded to 300/1
* 192 YResolution Hard-coded to 300/1 * 192 YResolution Hard-coded to 300/1
* 200 "NuttX" Length = 6 (including NUL terminator) * 200 "NuttX" Length = 6 (including NUL
* 206 "YYYY:MM:DD HH:MM:SS" Length = 20 (including NUL terminator) * terminator)
* 206 "YYYY:MM:DD HH:MM:SS" Length = 20 (including NUL
* terminator)
* 226 [2 bytes padding] * 226 [2 bytes padding]
* 228 StripByteCounts Beginning of strip byte counts * 228 StripByteCounts Beginning of strip byte counts
* xxx StripOffsets Beginning of strip offsets * xxx StripOffsets Beginning of strip offsets
@ -148,15 +163,20 @@
* 8 [2 bytes padding] * 8 [2 bytes padding]
* IFD: 10 Number of Directory Entries 15 * IFD: 10 Number of Directory Entries 15
* 12 NewSubfileType * 12 NewSubfileType
* 24 ImageWidth Number of columns is a user parameter * 24 ImageWidth Number of columns is a user
* 36 ImageLength Number of rows is a user parameter * parameter
* 36 ImageLength Number of rows is a user
* parameter
* 48 BitsPerSample 8, 8, 8 * 48 BitsPerSample 8, 8, 8
* 60 Compression Hard-coded no compression (for now) * 60 Compression Hard-coded no compression
* (for now)
* 72 PhotometricInterpretation Value is a user parameter * 72 PhotometricInterpretation Value is a user parameter
* 84 StripOffsets Offset and count determined as strips added * 84 StripOffsets Offset and count determined
* as strips added
* 96 SamplesPerPixel Hard-coded to 3 * 96 SamplesPerPixel Hard-coded to 3
* 108 RowsPerStrip Value is a user parameter * 108 RowsPerStrip Value is a user parameter
* 120 StripByteCounts Offset and count determined as strips added * 120 StripByteCounts Offset and count determined
* as strips added
* 132 XResolution Value is a user parameter * 132 XResolution Value is a user parameter
* 144 YResolution Value is a user parameter * 144 YResolution Value is a user parameter
* 156 Resolution Unit Hard-coded to "inches" * 156 Resolution Unit Hard-coded to "inches"
@ -169,8 +189,10 @@
* 204 YResolution Hard-coded to 300/1 * 204 YResolution Hard-coded to 300/1
* 212 BitsPerSample 8, 8, 8 * 212 BitsPerSample 8, 8, 8
* 218 [2 bytes padding] * 218 [2 bytes padding]
* 220 "NuttX" Length = 6 (including NUL terminator) * 220 "NuttX" Length = 6 (including NUL
* 226 "YYYY:MM:DD HH:MM:SS" Length = 20 (including NUL terminator) * terminator)
* 226 "YYYY:MM:DD HH:MM:SS" Length = 20 (including NUL
* terminator)
* 246 [2 bytes padding] * 246 [2 bytes padding]
* 248 StripByteCounts Beginning of strip byte counts * 248 StripByteCounts Beginning of strip byte counts
* xxx StripOffsets Beginning of strip offsets * xxx StripOffsets Beginning of strip offsets
@ -189,8 +211,12 @@
#define TIFF_RGB_DATEOFFSET 226 #define TIFF_RGB_DATEOFFSET 226
#define TIFF_RGB_STRIPBCOFFSET 248 #define TIFF_RGB_STRIPBCOFFSET 248
/* Debug *******************************************************************/ /****************************************************************************
/* CONFIG_DEBUG_TIFFOFFSETS may be defined (along with CONFIG_DEBUG_FEATURES and * Debug
****************************************************************************/
/* CONFIG_DEBUG_TIFFOFFSETS may be defined (along with CONFIG_DEBUG_FEATURES
* and
* CONFIG_DEBUG_GRAPHICS) in order to verify the pre-determined TIFF file * CONFIG_DEBUG_GRAPHICS) in order to verify the pre-determined TIFF file
* offsets. * offsets.
*/ */
@ -200,11 +226,11 @@
#endif #endif
#ifdef CONFIG_DEBUG_TIFFOFFSETS #ifdef CONFIG_DEBUG_TIFFOFFSETS
# define tiff_offset(o,l) (o) += (l) # define tiff_offset(o, l) (o) += (l)
# define tiff_checkoffs(o,x) DEBUGASSERT((o) == (x)) # define tiff_checkoffs(o, x) DEBUGASSERT((o) == (x))
#else #else
# define tiff_offset(o,l) # define tiff_offset(o, l)
# define tiff_checkoffs(o,x) # define tiff_checkoffs(o, x)
#endif #endif
/**************************************************************************** /****************************************************************************
@ -408,7 +434,7 @@ static int tiff_datetime(FAR char *timbuf, unsigned int buflen)
/* Break the current time up into the format needed by strftime */ /* Break the current time up into the format needed by strftime */
gmtime_r((FAR const time_t*)&ts.tv_sec, &tm); gmtime_r((FAR const time_t *)&ts.tv_sec, &tm);
/* Convert the current time to TIFF format */ /* Convert the current time to TIFF format */
@ -427,7 +453,8 @@ static int tiff_datetime(FAR char *timbuf, unsigned int buflen)
* Setup to create a new TIFF file. * Setup to create a new TIFF file.
* *
* Input Parameters: * Input Parameters:
* info - A pointer to the caller allocated parameter passing/TIFF state instance. * info - A pointer to the caller allocated parameter passing/TIFF state
* instance.
* *
* Returned Value: * Returned Value:
* Zero (OK) on success. A negated errno value on failure. * Zero (OK) on success. A negated errno value on failure.
@ -447,7 +474,7 @@ int tiff_initialize(FAR struct tiff_info_s *info)
/* Open all output files */ /* Open all output files */
info->outfd = open(info->outfile, O_RDWR|O_CREAT|O_TRUNC, 0666); info->outfd = open(info->outfile, O_RDWR | O_CREAT | O_TRUNC, 0666);
if (info->outfd < 0) if (info->outfd < 0)
{ {
gerr("ERROR: Failed to open %s for reading/writing: %d\n", gerr("ERROR: Failed to open %s for reading/writing: %d\n",
@ -455,7 +482,7 @@ int tiff_initialize(FAR struct tiff_info_s *info)
goto errout; goto errout;
} }
info->tmp1fd = open(info->tmpfile1, O_RDWR|O_CREAT|O_TRUNC, 0666); info->tmp1fd = open(info->tmpfile1, O_RDWR | O_CREAT | O_TRUNC, 0666);
if (info->tmp1fd < 0) if (info->tmp1fd < 0)
{ {
gerr("ERROR: Failed to open %s for reading/writing: %d\n", gerr("ERROR: Failed to open %s for reading/writing: %d\n",
@ -463,7 +490,7 @@ int tiff_initialize(FAR struct tiff_info_s *info)
goto errout; goto errout;
} }
info->tmp2fd = open(info->tmpfile2, O_RDWR|O_CREAT|O_TRUNC, 0666); info->tmp2fd = open(info->tmpfile2, O_RDWR | O_CREAT | O_TRUNC, 0666);
if (info->tmp2fd < 0) if (info->tmp2fd < 0)
{ {
gerr("ERROR: Failed to open %s for reading/writing: %d\n", gerr("ERROR: Failed to open %s for reading/writing: %d\n",
@ -505,7 +532,7 @@ int tiff_initialize(FAR struct tiff_info_s *info)
case FB_FMT_RGB24: /* BPP=24 R=8, G=8, B=8 */ case FB_FMT_RGB24: /* BPP=24 R=8, G=8, B=8 */
info->filefmt = &g_rgbinfo; /* RGB file image file info */ info->filefmt = &g_rgbinfo; /* RGB file image file info */
info->imgflags = IMGFLAGS_FMT_RGB24; /* Bit encoded image characteristics */ info->imgflags = IMGFLAGS_FMT_RGB24; /* Bit encoded image characteristics */
info->bps = 3 *info->pps; /* Bytes per strip */ info->bps = 3 * info->pps; /* Bytes per strip */
break; break;
default: default:
@ -526,6 +553,7 @@ int tiff_initialize(FAR struct tiff_info_s *info)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, TIFF_IFD_OFFSET); tiff_offset(offset, TIFF_IFD_OFFSET);
/* Write the Number of directory entries /* Write the Number of directory entries
@ -538,6 +566,7 @@ int tiff_initialize(FAR struct tiff_info_s *info)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, 2); tiff_offset(offset, 2);
/* Write the NewSubfileType IFD entry /* Write the NewSubfileType IFD entry
@ -545,11 +574,13 @@ int tiff_initialize(FAR struct tiff_info_s *info)
* All formats: Offset 12 NewSubfileType * All formats: Offset 12 NewSubfileType
*/ */
ret = tiff_putifdentry16(info, IFD_TAG_NEWSUBFILETYPE, IFD_FIELD_LONG, 1, 0); ret = tiff_putifdentry16(info, IFD_TAG_NEWSUBFILETYPE,
IFD_FIELD_LONG, 1, 0);
if (ret < 0) if (ret < 0)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, SIZEOF_IFD_ENTRY); tiff_offset(offset, SIZEOF_IFD_ENTRY);
/* Write ImageWidth and ImageLength /* Write ImageWidth and ImageLength
@ -558,17 +589,20 @@ int tiff_initialize(FAR struct tiff_info_s *info)
* 36 ImageLength Number of rows is a user parameter * 36 ImageLength Number of rows is a user parameter
*/ */
ret = tiff_putifdentry16(info, IFD_TAG_IMAGEWIDTH, IFD_FIELD_SHORT, 1, info->imgwidth); ret = tiff_putifdentry16(info, IFD_TAG_IMAGEWIDTH,
IFD_FIELD_SHORT, 1, info->imgwidth);
if (ret == OK) if (ret == OK)
{ {
ret= tiff_putifdentry16(info, IFD_TAG_IMAGELENGTH, IFD_FIELD_SHORT, 1, info->imgheight); ret = tiff_putifdentry16(info, IFD_TAG_IMAGELENGTH,
IFD_FIELD_SHORT, 1, info->imgheight);
} }
if (ret < 0) if (ret < 0)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, 2*SIZEOF_IFD_ENTRY);
tiff_offset(offset, 2 * SIZEOF_IFD_ENTRY);
/* Write BitsPerSample /* Write BitsPerSample
* *
@ -589,20 +623,24 @@ int tiff_initialize(FAR struct tiff_info_s *info)
val16 = 4; val16 = 4;
} }
ret = tiff_putifdentry16(info, IFD_TAG_BITSPERSAMPLE, IFD_FIELD_SHORT, 1, val16); ret = tiff_putifdentry16(info, IFD_TAG_BITSPERSAMPLE,
IFD_FIELD_SHORT, 1, val16);
if (ret < 0) if (ret < 0)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, SIZEOF_IFD_ENTRY); tiff_offset(offset, SIZEOF_IFD_ENTRY);
} }
else if (IMGFLAGS_ISRGB(info->imgflags)) else if (IMGFLAGS_ISRGB(info->imgflags))
{ {
ret = tiff_putifdentry(info, IFD_TAG_BITSPERSAMPLE, IFD_FIELD_SHORT, 3, TIFF_RGB_BPSOFFSET); ret = tiff_putifdentry(info, IFD_TAG_BITSPERSAMPLE,
IFD_FIELD_SHORT, 3, TIFF_RGB_BPSOFFSET);
if (ret < 0) if (ret < 0)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, SIZEOF_IFD_ENTRY); tiff_offset(offset, SIZEOF_IFD_ENTRY);
} }
@ -613,11 +651,13 @@ int tiff_initialize(FAR struct tiff_info_s *info)
* RGB: Offset 60 " " " " "" " " " " " " * RGB: Offset 60 " " " " "" " " " " " "
*/ */
ret = tiff_putifdentry16(info, IFD_TAG_COMPRESSION, IFD_FIELD_SHORT, 1, TAG_COMP_NONE); ret = tiff_putifdentry16(info, IFD_TAG_COMPRESSION,
IFD_FIELD_SHORT, 1, TAG_COMP_NONE);
if (ret < 0) if (ret < 0)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, SIZEOF_IFD_ENTRY); tiff_offset(offset, SIZEOF_IFD_ENTRY);
/* Write PhotometricInterpretation: /* Write PhotometricInterpretation:
@ -641,6 +681,7 @@ int tiff_initialize(FAR struct tiff_info_s *info)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, SIZEOF_IFD_ENTRY); tiff_offset(offset, SIZEOF_IFD_ENTRY);
/* Write StripOffsets: /* Write StripOffsets:
@ -656,6 +697,7 @@ int tiff_initialize(FAR struct tiff_info_s *info)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, SIZEOF_IFD_ENTRY); tiff_offset(offset, SIZEOF_IFD_ENTRY);
/* Write SamplesPerPixel /* Write SamplesPerPixel
@ -667,11 +709,13 @@ int tiff_initialize(FAR struct tiff_info_s *info)
if (IMGFLAGS_ISRGB(info->imgflags)) if (IMGFLAGS_ISRGB(info->imgflags))
{ {
ret = tiff_putifdentry16(info, IFD_TAG_SAMPLESPERPIXEL, IFD_FIELD_SHORT, 1, 3); ret = tiff_putifdentry16(info, IFD_TAG_SAMPLESPERPIXEL,
IFD_FIELD_SHORT, 1, 3);
if (ret < 0) if (ret < 0)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, SIZEOF_IFD_ENTRY); tiff_offset(offset, SIZEOF_IFD_ENTRY);
} }
@ -682,26 +726,33 @@ int tiff_initialize(FAR struct tiff_info_s *info)
* RGB: Offset 108 Value is a user parameter * RGB: Offset 108 Value is a user parameter
*/ */
ret = tiff_putifdentry16(info, IFD_TAG_ROWSPERSTRIP, IFD_FIELD_SHORT, 1, info->rps); ret = tiff_putifdentry16(info, IFD_TAG_ROWSPERSTRIP,
IFD_FIELD_SHORT, 1, info->rps);
if (ret < 0) if (ret < 0)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, SIZEOF_IFD_ENTRY); tiff_offset(offset, SIZEOF_IFD_ENTRY);
/* Write StripByteCounts: /* Write StripByteCounts:
* *
* Bi-level Images: Offset 96 Count determined as strips added, Value offset = 216 * Bi-level Images: Offset 96 Count determined as strips added, Value
* Greyscale: Offset 108 Count determined as strips added, Value offset = 228 * offset = 216
* RGB: Offset 120 Count determined as strips added, Value offset = 248 * Greyscale: Offset 108 Count determined as strips added, Value
* offset = 228
* RGB: Offset 120 Count determined as strips added, Value
* offset = 248
*/ */
tiff_checkoffs(offset, info->filefmt->sbcifdoffset); tiff_checkoffs(offset, info->filefmt->sbcifdoffset);
ret = tiff_putifdentry(info, IFD_TAG_STRIPCOUNTS, IFD_FIELD_LONG, 0, info->filefmt->sbcoffset); ret = tiff_putifdentry(info, IFD_TAG_STRIPCOUNTS,
IFD_FIELD_LONG, 0, info->filefmt->sbcoffset);
if (ret < 0) if (ret < 0)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, SIZEOF_IFD_ENTRY); tiff_offset(offset, SIZEOF_IFD_ENTRY);
/* Write XResolution and YResolution: /* Write XResolution and YResolution:
@ -711,17 +762,22 @@ int tiff_initialize(FAR struct tiff_info_s *info)
* RGB: Offset 132 and 144, Values are a user parameters * RGB: Offset 132 and 144, Values are a user parameters
*/ */
ret = tiff_putifdentry(info, IFD_TAG_XRESOLUTION, IFD_FIELD_RATIONAL, 1, info->filefmt->xresoffset); ret = tiff_putifdentry(info, IFD_TAG_XRESOLUTION,
IFD_FIELD_RATIONAL, 1,
info->filefmt->xresoffset);
if (ret == OK) if (ret == OK)
{ {
ret = tiff_putifdentry(info, IFD_TAG_YRESOLUTION, IFD_FIELD_RATIONAL, 1, info->filefmt->yresoffset); ret = tiff_putifdentry(info, IFD_TAG_YRESOLUTION,
IFD_FIELD_RATIONAL, 1,
info->filefmt->yresoffset);
} }
if (ret < 0) if (ret < 0)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, 2*SIZEOF_IFD_ENTRY);
tiff_offset(offset, 2 * SIZEOF_IFD_ENTRY);
/* Write ResolutionUnit: /* Write ResolutionUnit:
* *
@ -730,11 +786,13 @@ int tiff_initialize(FAR struct tiff_info_s *info)
* RGB: Offset 156, Hard-coded to "inches" * RGB: Offset 156, Hard-coded to "inches"
*/ */
ret = tiff_putifdentry16(info, IFD_TAG_RESUNIT, IFD_FIELD_SHORT, 1, TAG_RESUNIT_INCH); ret = tiff_putifdentry16(info, IFD_TAG_RESUNIT,
IFD_FIELD_SHORT, 1, TAG_RESUNIT_INCH);
if (ret < 0) if (ret < 0)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, SIZEOF_IFD_ENTRY); tiff_offset(offset, SIZEOF_IFD_ENTRY);
/* Write Software: /* Write Software:
@ -744,11 +802,14 @@ int tiff_initialize(FAR struct tiff_info_s *info)
* RGB: Offset 168 Count, Hard-coded "NuttX" * RGB: Offset 168 Count, Hard-coded "NuttX"
*/ */
ret = tiff_putifdentry(info, IFD_TAG_SOFTWARE, IFD_FIELD_ASCII, TIFF_SOFTWARE_STRLEN, info->filefmt->swoffset); ret = tiff_putifdentry(info, IFD_TAG_SOFTWARE,
IFD_FIELD_ASCII, TIFF_SOFTWARE_STRLEN,
info->filefmt->swoffset);
if (ret < 0) if (ret < 0)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, SIZEOF_IFD_ENTRY); tiff_offset(offset, SIZEOF_IFD_ENTRY);
/* Write DateTime: /* Write DateTime:
@ -758,11 +819,14 @@ int tiff_initialize(FAR struct tiff_info_s *info)
* RGB: Offset 180 Count, Format "YYYY:MM:DD HH:MM:SS" * RGB: Offset 180 Count, Format "YYYY:MM:DD HH:MM:SS"
*/ */
ret = tiff_putifdentry(info, IFD_TAG_DATETIME, IFD_FIELD_ASCII, TIFF_DATETIME_STRLEN, info->filefmt->dateoffset); ret = tiff_putifdentry(info, IFD_TAG_DATETIME,
IFD_FIELD_ASCII, TIFF_DATETIME_STRLEN,
info->filefmt->dateoffset);
if (ret < 0) if (ret < 0)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, SIZEOF_IFD_ENTRY); tiff_offset(offset, SIZEOF_IFD_ENTRY);
/* Write Next IFD Offset and 2 bytes of padding: /* Write Next IFD Offset and 2 bytes of padding:
@ -780,6 +844,7 @@ int tiff_initialize(FAR struct tiff_info_s *info)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, 4); tiff_offset(offset, 4);
/* Now we begin the value section of the file */ /* Now we begin the value section of the file */
@ -807,6 +872,7 @@ int tiff_initialize(FAR struct tiff_info_s *info)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, 8); tiff_offset(offset, 8);
tiff_checkoffs(offset, info->filefmt->yresoffset); tiff_checkoffs(offset, info->filefmt->yresoffset);
@ -820,6 +886,7 @@ int tiff_initialize(FAR struct tiff_info_s *info)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, 8); tiff_offset(offset, 8);
/* Write RGB BitsPerSample Data: /* Write RGB BitsPerSample Data:
@ -837,6 +904,7 @@ int tiff_initialize(FAR struct tiff_info_s *info)
tiff_putint16(info->outfd, 8); tiff_putint16(info->outfd, 8);
tiff_putint16(info->outfd, 8); tiff_putint16(info->outfd, 8);
tiff_putint16(info->outfd, 0); tiff_putint16(info->outfd, 0);
tiff_offset(offset, 8); tiff_offset(offset, 8);
} }
@ -849,11 +917,13 @@ int tiff_initialize(FAR struct tiff_info_s *info)
*/ */
tiff_checkoffs(offset, info->filefmt->swoffset); tiff_checkoffs(offset, info->filefmt->swoffset);
ret = tiff_putstring(info->outfd, TIFF_SOFTWARE_STRING, TIFF_SOFTWARE_STRLEN); ret = tiff_putstring(info->outfd, TIFF_SOFTWARE_STRING,
TIFF_SOFTWARE_STRLEN);
if (ret < 0) if (ret < 0)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, TIFF_SOFTWARE_STRLEN); tiff_offset(offset, TIFF_SOFTWARE_STRLEN);
/* Write the DateTime string: /* Write the DateTime string:
@ -876,6 +946,7 @@ int tiff_initialize(FAR struct tiff_info_s *info)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, TIFF_DATETIME_STRLEN); tiff_offset(offset, TIFF_DATETIME_STRLEN);
/* Add two bytes of padding */ /* Add two bytes of padding */
@ -885,6 +956,7 @@ int tiff_initialize(FAR struct tiff_info_s *info)
{ {
goto errout; goto errout;
} }
tiff_offset(offset, 2); tiff_offset(offset, 2);
/* And that should do it! */ /* And that should do it! */

37
graphics/tiff/tiff_utils.c
View file

@ -93,10 +93,10 @@ void tiff_put32(FAR uint8_t *dest, uint32_t value)
{ {
#ifdef CONFIG_ENDIAN_BIG #ifdef CONFIG_ENDIAN_BIG
tiff_put16(dest, (uint16_t)(value >> 16)); tiff_put16(dest, (uint16_t)(value >> 16));
tiff_put16(dest+2, (uint16_t)(value & 0xffff)); tiff_put16(dest + 2, (uint16_t)(value & 0xffff));
#else #else
tiff_put16(dest, (uint16_t)(value & 0xffff)); tiff_put16(dest, (uint16_t)(value & 0xffff));
tiff_put16(dest+2, (uint16_t)(value >> 16)); tiff_put16(dest + 2, (uint16_t)(value >> 16));
#endif #endif
} }
@ -112,11 +112,10 @@ uint16_t tiff_get16(FAR uint8_t *src)
uint32_t tiff_get32(FAR uint8_t *src) uint32_t tiff_get32(FAR uint8_t *src)
{ {
#ifdef CONFIG_ENDIAN_BIG #ifdef CONFIG_ENDIAN_BIG
return (uint32_t)tiff_get16(src) << 16 | (uint32_t)tiff_get16(src+2); return (uint32_t)tiff_get16(src) << 16 | (uint32_t)tiff_get16(src + 2);
#else #else
return (uint32_t)tiff_get16(src+2) << 16 | (uint32_t)tiff_get16(src); return (uint32_t)tiff_get16(src + 2) << 16 | (uint32_t)tiff_get16(src);
#endif #endif
} }
/**************************************************************************** /****************************************************************************
@ -153,7 +152,7 @@ ssize_t tiff_read(int fd, FAR void *buffer, size_t count)
* (ntotal). * (ntotal).
*/ */
nbytes = read(fd, buffer, count-ntotal); nbytes = read(fd, buffer, count - ntotal);
/* Check for an error */ /* Check for an error */
@ -166,22 +165,26 @@ ssize_t tiff_read(int fd, FAR void *buffer, size_t count)
errval = errno; errval = errno;
if (errval != EINTR) if (errval != EINTR)
{ {
/* Other errors are bad news and we will break out with an error */ /* Other errors are bad news and we will break out with an
* error.
*/
return -errval; return -errval;
} }
} }
/* Zero is a special case and means that the end of file was encountered. */ /* Zero is a special case and means that the end of file was
* encountered.
*/
else if (nbytes == 0) else if (nbytes == 0)
{ {
break; break;
} }
/* What if read returns some number of bytes other than the requested number? /* What if read returns some number of bytes other than the requested
* This probably means that the end-of-file will be encountered the next time * number? This probably means that the end-of-file will be
* that we call read(). * encountered the next time that we call read().
*/ */
else else
@ -236,13 +239,17 @@ int tiff_write(int fd, FAR const void *buffer, size_t count)
errval = errno; errval = errno;
if (errval != EINTR) if (errval != EINTR)
{ {
/* Other errors are bad news and we will break out with an error */ /* Other errors are bad news and we will break out with an
* error.
*/
return -errval; return -errval;
} }
} }
/* What if write returns some number of bytes other than the requested number? */ /* What if write returns some number of bytes other than the requested
* number?
*/
else else
{ {
@ -326,7 +333,7 @@ int tiff_putstring(int fd, FAR const char *string, int len)
#ifdef CONFIG_DEBUG_GRAPHICS #ifdef CONFIG_DEBUG_GRAPHICS
int actual = strlen(string); int actual = strlen(string);
DEBUGASSERT(len = actual+1); DEBUGASSERT(len == actual + 1);
#endif #endif
return tiff_write(fd, string, len); return tiff_write(fd, string, len);
} }
@ -362,7 +369,9 @@ ssize_t tiff_wordalign(int fd, size_t size)
{ {
return (ssize_t)ret; return (ssize_t)ret;
} }
size += nbytes; size += nbytes;
} }
return size; return size;
} }

120
system/nxcamera/nxcamera.c
View file

@ -52,6 +52,10 @@
#ifdef CONFIG_LIBYUV #ifdef CONFIG_LIBYUV
# include <libyuv.h> # include <libyuv.h>
# define CONVERT_TO_ARGB ConvertToARGB
# define CONVERT_FROM_I420 ConvertFromI420
# define CONVERT_TO_I420 ConvertToI420
#endif #endif
/**************************************************************************** /****************************************************************************
@ -91,38 +95,38 @@ static int show_image(FAR struct nxcamera_s *pcam, FAR v4l2_buffer_t *buf)
#ifdef CONFIG_LIBYUV #ifdef CONFIG_LIBYUV
if (pcam->display_vinfo.fmt == FB_FMT_RGB32) if (pcam->display_vinfo.fmt == FB_FMT_RGB32)
{ {
return ConvertToARGB(pcam->bufs[buf->index], return CONVERT_TO_ARGB(pcam->bufs[buf->index],
pcam->buf_sizes[buf->index], pcam->buf_sizes[buf->index],
pcam->display_pinfo.fbmem, pcam->display_pinfo.fbmem,
pcam->display_pinfo.stride, pcam->display_pinfo.stride,
0, 0,
0, 0,
pcam->fmt.fmt.pix.width, pcam->fmt.fmt.pix.width,
pcam->fmt.fmt.pix.height, pcam->fmt.fmt.pix.height,
pcam->fmt.fmt.pix.width, pcam->fmt.fmt.pix.width,
pcam->fmt.fmt.pix.height, pcam->fmt.fmt.pix.height,
0, 0,
pcam->fmt.fmt.pix.pixelformat); pcam->fmt.fmt.pix.pixelformat);
} }
else if (pcam->display_vinfo.fmt == FB_FMT_RGB16_565) else if (pcam->display_vinfo.fmt == FB_FMT_RGB16_565)
{ {
if (pcam->fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_YUV420) if (pcam->fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_YUV420)
{ {
return ConvertFromI420(pcam->bufs[buf->index], return CONVERT_FROM_I420(pcam->bufs[buf->index],
pcam->fmt.fmt.pix.width, pcam->fmt.fmt.pix.width,
&pcam->bufs[buf->index][ &pcam->bufs[buf->index][
pcam->fmt.fmt.pix.width * pcam->fmt.fmt.pix.width *
pcam->fmt.fmt.pix.height], pcam->fmt.fmt.pix.height],
pcam->fmt.fmt.pix.width / 2, pcam->fmt.fmt.pix.width / 2,
&pcam->bufs[buf->index][ &pcam->bufs[buf->index][
pcam->fmt.fmt.pix.width * pcam->fmt.fmt.pix.width *
pcam->fmt.fmt.pix.height * 5 / 4], pcam->fmt.fmt.pix.height * 5 / 4],
pcam->fmt.fmt.pix.width / 2, pcam->fmt.fmt.pix.width / 2,
pcam->display_pinfo.fbmem, pcam->display_pinfo.fbmem,
pcam->display_pinfo.stride, pcam->display_pinfo.stride,
pcam->fmt.fmt.pix.width, pcam->fmt.fmt.pix.width,
pcam->fmt.fmt.pix.height, pcam->fmt.fmt.pix.height,
V4L2_PIX_FMT_RGB565); V4L2_PIX_FMT_RGB565);
} }
else else
{ {
@ -134,42 +138,42 @@ static int show_image(FAR struct nxcamera_s *pcam, FAR v4l2_buffer_t *buf)
return -ENOMEM; return -ENOMEM;
} }
ret = ConvertToI420(pcam->bufs[buf->index], ret = CONVERT_TO_I420(pcam->bufs[buf->index],
pcam->buf_sizes[buf->index], pcam->buf_sizes[buf->index],
dst, dst,
pcam->fmt.fmt.pix.width, pcam->fmt.fmt.pix.width,
&dst[pcam->fmt.fmt.pix.width * &dst[pcam->fmt.fmt.pix.width *
pcam->fmt.fmt.pix.height], pcam->fmt.fmt.pix.height],
pcam->fmt.fmt.pix.width / 2, pcam->fmt.fmt.pix.width / 2,
&dst[pcam->fmt.fmt.pix.width * &dst[pcam->fmt.fmt.pix.width *
pcam->fmt.fmt.pix.height * 5 / 4], pcam->fmt.fmt.pix.height * 5 / 4],
pcam->fmt.fmt.pix.width / 2, pcam->fmt.fmt.pix.width / 2,
0, 0,
0, 0,
pcam->fmt.fmt.pix.width, pcam->fmt.fmt.pix.width,
pcam->fmt.fmt.pix.height, pcam->fmt.fmt.pix.height,
pcam->fmt.fmt.pix.width, pcam->fmt.fmt.pix.width,
pcam->fmt.fmt.pix.height, pcam->fmt.fmt.pix.height,
0, 0,
pcam->fmt.fmt.pix.pixelformat); pcam->fmt.fmt.pix.pixelformat);
if (ret < 0) if (ret < 0)
{ {
goto err; goto err;
} }
ret = ConvertFromI420(dst, ret = CONVERT_FROM_I420(dst,
pcam->fmt.fmt.pix.width, pcam->fmt.fmt.pix.width,
&dst[pcam->fmt.fmt.pix.width * &dst[pcam->fmt.fmt.pix.width *
pcam->fmt.fmt.pix.height], pcam->fmt.fmt.pix.height],
pcam->fmt.fmt.pix.width / 2, pcam->fmt.fmt.pix.width / 2,
&dst[pcam->fmt.fmt.pix.width * &dst[pcam->fmt.fmt.pix.width *
pcam->fmt.fmt.pix.height * 5 / 4], pcam->fmt.fmt.pix.height * 5 / 4],
pcam->fmt.fmt.pix.width / 2, pcam->fmt.fmt.pix.width / 2,
pcam->display_pinfo.fbmem, pcam->display_pinfo.fbmem,
pcam->display_pinfo.stride, pcam->display_pinfo.stride,
pcam->fmt.fmt.pix.width, pcam->fmt.fmt.pix.width,
pcam->fmt.fmt.pix.height, pcam->fmt.fmt.pix.height,
V4L2_PIX_FMT_RGB565); V4L2_PIX_FMT_RGB565);
if (ret < 0) if (ret < 0)
{ {
goto err; goto err;