src/main/io/displayport_frsky_osd.c

   1 /*
   2  * This file is part of Cleanflight, Betaflight and INAV
   3  *
   4  * Cleanflight, Betaflight and INAV are free software. You can
   5  * redistribute this software and/or modify this software under
   6  * the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License,
   8  * or (at your option) any later version.
   9  *
  10  * Cleanflight, Betaflight and INAV are distributed in the hope that
  11  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  12  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  13  * PURPOSE. See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this software.
  17  *
  18  * If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <stdbool.h>
  22 #include <stdint.h>
  23
  24 #include "platform.h"
  25
  26 #if defined(USE_FRSKYOSD)
  27
  28 #include "common/utils.h"
  29
  30 #include "drivers/display.h"
  31 #include "drivers/display_canvas.h"
  32
  33 #include "io/displayport_frsky_osd.h"
  34 #include "io/frsky_osd.h"
  35
  36 static displayPort_t frskyOsdDisplayPort;
  37
  38 static int grab(displayPort_t *displayPort)
  39 {
  40     UNUSED(displayPort);
  41     return 0;
  42 }
  43
  44 static int release(displayPort_t *displayPort)
  45 {
  46     UNUSED(displayPort);
  47     return 0;
  48 }
  49
  50 static int clearScreen(displayPort_t *displayPort)
  51 {
  52     UNUSED(displayPort);
  53     frskyOsdClearScreen();
  54     return 0;
  55 }
  56
  57 static bool drawScreen(displayPort_t *displayPort)
  58 {
  59     UNUSED(displayPort);
  60     frskyOsdUpdate();
  61
  62     return 0;
  63 }
  64
  65 static int screenSize(const displayPort_t *displayPort)
  66 {
  67     UNUSED(displayPort);
  68     return frskyOsdGetGridRows() * frskyOsdGetGridCols();
  69 }
  70
  71 static int writeString(displayPort_t *displayPort, uint8_t x, uint8_t y, uint8_t attr, const char *s)
  72 {
  73     UNUSED(displayPort);
  74     UNUSED(attr);
  75
  76     frskyOsdDrawStringInGrid(x, y, s);
  77     return 0;
  78 }
  79
  80 static int writeChar(displayPort_t *displayPort, uint8_t x, uint8_t y, uint8_t attr, uint8_t c)
  81 {
  82     UNUSED(displayPort);
  83     UNUSED(attr);
  84
  85     frskyOsdDrawCharInGrid(x, y, c);
  86     return 0;
  87 }
  88
  89 static bool isTransferInProgress(const displayPort_t *displayPort)
  90 {
  91     UNUSED(displayPort);
  92     return false;
  93 }
  94
  95 static void updateGridSize(displayPort_t *displayPort)
  96 {
  97     displayPort->rows = frskyOsdGetGridRows();
  98     displayPort->cols = frskyOsdGetGridCols();
  99 }
 100
 101 static void redraw(displayPort_t *displayPort)
 102 {
 103     UNUSED(displayPort);
 104     // TODO(agh): Do we need to flush the screen here?
 105     // MAX7456's driver does a full redraw in redraw(),
 106     // so some callers might be expecting that.
 107     frskyOsdUpdate();
 108 }
 109
 110 static int heartbeat(displayPort_t *displayPort)
 111 {
 112     UNUSED(displayPort);
 113     return 0;
 114 }
 115
 116 static uint32_t txBytesFree(const displayPort_t *displayPort)
 117 {
 118     UNUSED(displayPort);
 119     return UINT32_MAX;
 120 }
 121
 122 static bool writeFontCharacter(displayPort_t *instance, uint16_t addr, const osdCharacter_t *chr)
 123 {
 124     UNUSED(instance);
 125
 126     return frskyOsdWriteFontCharacter(addr, chr);
 127 }
 128
 129 static bool checkReady(displayPort_t *instance, bool rescan)
 130 {
 131     UNUSED(rescan);
 132
 133     if (frskyOsdIsReady()) {
 134         updateGridSize(instance);
 135         return true;
 136     }
 137     return false;
 138 }
 139
 140 static void beginTransaction(displayPort_t *instance, displayTransactionOption_e opts)
 141 {
 142     UNUSED(instance);
 143
 144     frskyOsdTransactionOptions_e frskyOpts = 0;
 145     if (opts & DISPLAY_TRANSACTION_OPT_PROFILED) {
 146         frskyOpts |= FRSKY_OSD_TRANSACTION_OPT_PROFILED;
 147     }
 148     if (opts & DISPLAY_TRANSACTION_OPT_RESET_DRAWING) {
 149         frskyOpts |= FRSKY_OSD_TRANSACTION_OPT_RESET_DRAWING;
 150     }
 151
 152     frskyOsdBeginTransaction(frskyOpts);
 153 }
 154
 155 static void commitTransaction(displayPort_t *instance)
 156 {
 157     UNUSED(instance);
 158
 159     frskyOsdCommitTransaction();
 160 }
 161
 162 static frskyOsdColor_e frskyOsdGetColor(displayCanvasColor_e color)
 163 {
 164     switch (color)
 165     {
 166         case DISPLAY_CANVAS_COLOR_BLACK:
 167             return FRSKY_OSD_COLOR_BLACK;
 168         case DISPLAY_CANVAS_COLOR_TRANSPARENT:
 169             return FRSKY_OSD_COLOR_TRANSPARENT;
 170         case DISPLAY_CANVAS_COLOR_WHITE:
 171             return FRSKY_OSD_COLOR_WHITE;
 172         case DISPLAY_CANVAS_COLOR_GRAY:
 173             return FRSKY_OSD_COLOR_GRAY;
 174     }
 175     return FRSKY_OSD_COLOR_BLACK;
 176 }
 177
 178 static void setStrokeColor(displayCanvas_t *displayCanvas, displayCanvasColor_e color)
 179 {
 180     UNUSED(displayCanvas);
 181
 182     frskyOsdSetStrokeColor(frskyOsdGetColor(color));
 183 }
 184
 185 static void setFillColor(displayCanvas_t *displayCanvas, displayCanvasColor_e color)
 186 {
 187     UNUSED(displayCanvas);
 188
 189     frskyOsdSetFillColor(frskyOsdGetColor(color));
 190 }
 191
 192 static void setStrokeAndFillColor(displayCanvas_t *displayCanvas, displayCanvasColor_e color)
 193 {
 194     UNUSED(displayCanvas);
 195
 196     frskyOsdSetStrokeAndFillColor(frskyOsdGetColor(color));
 197 }
 198
 199 static void setColorInversion(displayCanvas_t *displayCanvas, bool inverted)
 200 {
 201     UNUSED(displayCanvas);
 202
 203     frskyOsdSetColorInversion(inverted);
 204 }
 205
 206 static void setPixel(displayCanvas_t *displayCanvas, int x, int y, displayCanvasColor_e color)
 207 {
 208     UNUSED(displayCanvas);
 209
 210     frskyOsdSetPixel(x, y, frskyOsdGetColor(color));
 211 }
 212
 213 static void setPixelToStrokeColor(displayCanvas_t *displayCanvas, int x, int y)
 214 {
 215     UNUSED(displayCanvas);
 216
 217     frskyOsdSetPixelToStrokeColor(x, y);
 218 }
 219
 220 static void setPixelToFillColor(displayCanvas_t *displayCanvas, int x, int y)
 221 {
 222     UNUSED(displayCanvas);
 223
 224     frskyOsdSetPixelToFillColor(x, y);
 225 }
 226
 227 static void setStrokeWidth(displayCanvas_t *displayCanvas, unsigned w)
 228 {
 229     UNUSED(displayCanvas);
 230
 231     frskyOsdSetStrokeWidth(w);
 232 }
 233
 234 static void setLineOutlineType(displayCanvas_t *displayCanvas, displayCanvasOutlineType_e outlineType)
 235 {
 236     UNUSED(displayCanvas);
 237
 238     frskyOsdSetLineOutlineType((frskyOsdLineOutlineType_e)outlineType);
 239 }
 240
 241 static void setLineOutlineColor(displayCanvas_t *displayCanvas, displayCanvasColor_e outlineColor)
 242 {
 243     UNUSED(displayCanvas);
 244
 245     frskyOsdSetLineOutlineColor((frskyOsdColor_e)outlineColor);
 246 }
 247
 248 static void clipToRect(displayCanvas_t *displayCanvas, int x, int y, int w, int h)
 249 {
 250     UNUSED(displayCanvas);
 251
 252     frskyOsdClipToRect(x, y, w, h);
 253 }
 254
 255 static void clearRect(displayCanvas_t *displayCanvas, int x, int y, int w, int h)
 256 {
 257     UNUSED(displayCanvas);
 258
 259     frskyOsdClearRect(x, y, w, h);
 260 }
 261
 262 static void resetDrawingState(displayCanvas_t *displayCanvas)
 263 {
 264     UNUSED(displayCanvas);
 265
 266     frskyOsdResetDrawingState();
 267 }
 268
 269 static void drawCharacter(displayCanvas_t *displayCanvas, int x, int y, uint16_t chr, displayCanvasBitmapOption_t opts)
 270 {
 271     UNUSED(displayCanvas);
 272
 273     frskyOsdDrawCharacter(x, y, chr, opts);
 274 }
 275
 276 static void drawCharacterMask(displayCanvas_t *displayCanvas, int x, int y, uint16_t chr, displayCanvasColor_e color, displayCanvasBitmapOption_t opts)
 277 {
 278     UNUSED(displayCanvas);
 279
 280     frskyOsdDrawCharacterMask(x, y, chr, frskyOsdGetColor(color), opts);
 281 }
 282
 283 static void drawString(displayCanvas_t *displayCanvas, int x, int y, const char *s, displayCanvasBitmapOption_t opts)
 284 {
 285     UNUSED(displayCanvas);
 286
 287     frskyOsdDrawString(x, y, s, opts);
 288 }
 289
 290 static void drawStringMask(displayCanvas_t *displayCanvas, int x, int y, const char *s, displayCanvasColor_e color, displayCanvasBitmapOption_t opts)
 291 {
 292     UNUSED(displayCanvas);
 293
 294     frskyOsdDrawStringMask(x, y, s, frskyOsdGetColor(color), opts);
 295 }
 296
 297 static void moveToPoint(displayCanvas_t *displayCanvas, int x, int y)
 298 {
 299     UNUSED(displayCanvas);
 300
 301     frskyOsdMoveToPoint(x, y);
 302 }
 303
 304 static void strokeLineToPoint(displayCanvas_t *displayCanvas, int x, int y)
 305 {
 306     UNUSED(displayCanvas);
 307
 308     frskyOsdStrokeLineToPoint(x, y);
 309 }
 310
 311 static void strokeTriangle(displayCanvas_t *displayCanvas, int x1, int y1, int x2, int y2, int x3, int y3)
 312 {
 313     UNUSED(displayCanvas);
 314
 315     frskyOsdStrokeTriangle(x1, y1, x2, y2, x3, y3);
 316 }
 317
 318 static void fillTriangle(displayCanvas_t *displayCanvas, int x1, int y1, int x2, int y2, int x3, int y3)
 319 {
 320     UNUSED(displayCanvas);
 321
 322     frskyOsdFillTriangle(x1, y1, x2, y2, x3, y3);
 323 }
 324
 325 static void fillStrokeTriangle(displayCanvas_t *displayCanvas, int x1, int y1, int x2, int y2, int x3, int y3)
 326 {
 327     UNUSED(displayCanvas);
 328
 329     frskyOsdFillStrokeTriangle(x1, y1, x2, y2, x3, y3);
 330 }
 331
 332 static void strokeRect(displayCanvas_t *displayCanvas, int x, int y, int w, int h)
 333 {
 334     UNUSED(displayCanvas);
 335
 336     frskyOsdStrokeRect(x, y, w, h);
 337 }
 338
 339 static void fillRect(displayCanvas_t *displayCanvas, int x, int y, int w, int h)
 340 {
 341     UNUSED(displayCanvas);
 342
 343     frskyOsdFillRect(x, y, w, h);
 344 }
 345
 346 static void fillStrokeRect(displayCanvas_t *displayCanvas, int x, int y, int w, int h)
 347 {
 348     UNUSED(displayCanvas);
 349
 350     frskyOsdFillStrokeRect(x, y, w, h);
 351 }
 352
 353 static void strokeEllipseInRect(displayCanvas_t *displayCanvas, int x, int y, int w, int h)
 354 {
 355     UNUSED(displayCanvas);
 356
 357     frskyOsdStrokeEllipseInRect(x, y, w, h);
 358 }
 359
 360 static void fillEllipseInRect(displayCanvas_t *displayCanvas, int x, int y, int w, int h)
 361 {
 362     UNUSED(displayCanvas);
 363
 364     frskyOsdFillEllipseInRect(x, y, w, h);
 365 }
 366
 367 static void fillStrokeEllipseInRect(displayCanvas_t *displayCanvas, int x, int y, int w, int h)
 368 {
 369     UNUSED(displayCanvas);
 370
 371     frskyOsdFillStrokeEllipseInRect(x, y, w, h);
 372 }
 373
 374 static void ctmReset(displayCanvas_t *displayCanvas)
 375 {
 376     UNUSED(displayCanvas);
 377
 378     frskyOsdCtmReset();
 379 }
 380
 381 static void ctmSet(displayCanvas_t *displayCanvas, float m11, float m12, float m21, float m22, float m31, float m32)
 382 {
 383     UNUSED(displayCanvas);
 384
 385     frskyOsdCtmSet(m11, m12, m21, m22, m31, m32);
 386 }
 387
 388 static void ctmTranslate(displayCanvas_t *displayCanvas, float tx, float ty)
 389 {
 390     UNUSED(displayCanvas);
 391
 392     frskyOsdCtmTranslate(tx, ty);
 393 }
 394
 395 static void ctmScale(displayCanvas_t *displayCanvas, float sx, float sy)
 396 {
 397     UNUSED(displayCanvas);
 398
 399     frskyOsdCtmScale(sx, sy);
 400 }
 401
 402 static void ctmRotate(displayCanvas_t *displayCanvas, float r)
 403 {
 404     UNUSED(displayCanvas);
 405
 406     frskyOsdCtmRotate(r);
 407 }
 408
 409 static void contextPush(displayCanvas_t *displayCanvas)
 410 {
 411     UNUSED(displayCanvas);
 412
 413     frskyOsdContextPush();
 414 }
 415
 416 static void contextPop(displayCanvas_t *displayCanvas)
 417 {
 418     UNUSED(displayCanvas);
 419
 420     frskyOsdContextPop();
 421 }
 422
 423
 424 static const displayCanvasVTable_t frskyOsdCanvasVTable = {
 425     .setStrokeColor = setStrokeColor,
 426     .setFillColor = setFillColor,
 427     .setStrokeAndFillColor = setStrokeAndFillColor,
 428     .setColorInversion = setColorInversion,
 429     .setPixel = setPixel,
 430     .setPixelToStrokeColor = setPixelToStrokeColor,
 431     .setPixelToFillColor = setPixelToFillColor,
 432     .setStrokeWidth = setStrokeWidth,
 433     .setLineOutlineType = setLineOutlineType,
 434     .setLineOutlineColor = setLineOutlineColor,
 435
 436     .clipToRect = clipToRect,
 437     .clearRect = clearRect,
 438     .resetDrawingState = resetDrawingState,
 439     .drawCharacter = drawCharacter,
 440     .drawCharacterMask = drawCharacterMask,
 441     .drawString = drawString,
 442     .drawStringMask = drawStringMask,
 443     .moveToPoint = moveToPoint,
 444     .strokeLineToPoint = strokeLineToPoint,
 445     .strokeTriangle = strokeTriangle,
 446     .fillTriangle = fillTriangle,
 447     .fillStrokeTriangle = fillStrokeTriangle,
 448     .strokeRect = strokeRect,
 449     .fillRect = fillRect,
 450     .fillStrokeRect = fillStrokeRect,
 451     .strokeEllipseInRect = strokeEllipseInRect,
 452     .fillEllipseInRect = fillEllipseInRect,
 453     .fillStrokeEllipseInRect = fillStrokeEllipseInRect,
 454
 455     .ctmReset = ctmReset,
 456     .ctmSet = ctmSet,
 457     .ctmTranslate = ctmTranslate,
 458     .ctmScale = ctmScale,
 459     .ctmRotate = ctmRotate,
 460
 461     .contextPush = contextPush,
 462     .contextPop = contextPop,
 463 };
 464
 465 static bool getCanvas(displayCanvas_t *canvas, const displayPort_t *instance)
 466 {
 467     UNUSED(instance);
 468
 469     canvas->vTable = &frskyOsdCanvasVTable;
 470     canvas->width = frskyOsdGetPixelWidth();
 471     canvas->height = frskyOsdGetPixelHeight();
 472     return true;
 473 }
 474
 475 static const displayPortVTable_t frskyOsdVTable = {
 476     .grab = grab,
 477     .release = release,
 478     .clearScreen = clearScreen,
 479     .drawScreen = drawScreen,
 480     .screenSize = screenSize,
 481     .writeString = writeString,
 482     .writeChar = writeChar,
 483     .isTransferInProgress = isTransferInProgress,
 484     .heartbeat = heartbeat,
 485     .redraw = redraw,
 486     .txBytesFree = txBytesFree,
 487     .writeFontCharacter = writeFontCharacter,
 488     .checkReady = checkReady,
 489     .beginTransaction = beginTransaction,
 490     .commitTransaction = commitTransaction,
 491     .getCanvas = getCanvas,
 492 };
 493
 494 displayPort_t *frskyOsdDisplayPortInit(const videoSystem_e videoSystem)
 495 {
 496     if (frskyOsdInit(videoSystem)) {
 497         displayInit(&frskyOsdDisplayPort, &frskyOsdVTable, DISPLAYPORT_DEVICE_TYPE_FRSKYOSD);
 498         redraw(&frskyOsdDisplayPort);
 499         return &frskyOsdDisplayPort;
 500     }
 501     return NULL;
 502 }
 503
 504 #endif // USE_FRSKYOSD