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