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