src/main/io/rcdevice_osd.c

   1 /*
   2  * This file is part of Cleanflight and Betaflight.
   3  *
   4  * Cleanflight and Betaflight are free software. You can redistribute
   5  * this software and/or modify this software under the terms of the
   6  * GNU General Public License as published by the Free Software
   7  * Foundation, either version 3 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * Cleanflight and Betaflight are distributed in the hope that they
  11  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  12  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * 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 #ifdef USE_RCDEVICE
  27
  28 #include "io/rcdevice.h"
  29
  30 #include "pg/vcd.h"
  31
  32 #include "rcdevice_osd.h"
  33
  34 #define VIDEO_BUFFER_CHARS_PAL 480
  35
  36 static uint8_t columnCount = 30;
  37
  38 static runcamDevice_t runcamOSDDevice;
  39 runcamDevice_t *osdDevice = &runcamOSDDevice;
  40
  41 static uint8_t video_system;
  42 static uint16_t maxScreenSize = VIDEO_BUFFER_CHARS_PAL;
  43
  44 #ifdef USE_PARTICLE_DRAW
  45 #define MAX_CHARS2UPDATE 20
  46 static uint8_t screenBuffer[VIDEO_BUFFER_CHARS_PAL + 40]; // For faster writes
  47                                                           // we use memcpy so we
  48                                                           // need some space to
  49                                                           // don't overwrite
  50                                                           // buffer
  51 static uint8_t shadowBuffer[VIDEO_BUFFER_CHARS_PAL];
  52 static bool rcdeviceOSDLock = false;
  53 #endif
  54
  55 bool rcdeviceOSDInit(const vcdProfile_t *vcdProfile)
  56 {
  57     if (!runcamDeviceInit(osdDevice)) {
  58         return false;
  59     }
  60
  61     if ((osdDevice->info.features & RCDEVICE_PROTOCOL_FEATURE_DISPLAYP_PORT) == 0) {
  62         return false;
  63     }
  64
  65     // get screen column count
  66     runcamDeviceSettingDetail_t settingDetail;
  67     if (!runcamDeviceGetSettingDetail(osdDevice, RCDEVICE_PROTOCOL_SETTINGID_DISP_COLUMNS, &settingDetail)) {
  68         return false;
  69     }
  70
  71     columnCount = settingDetail.value;
  72
  73     video_system = vcdProfile->video_system;
  74     if (video_system == VIDEO_SYSTEM_AUTO) {
  75         // fetch current video mode from device
  76         runcamDeviceSettingDetail_t settingDetail;
  77         if (!runcamDeviceGetSettingDetail(osdDevice, RCDEVICE_PROTOCOL_SETTINGID_DISP_TV_MODE, &settingDetail)) {
  78             return false;
  79         }
  80         video_system = settingDetail.value;
  81     } else {
  82         // set video system
  83         runcamDeviceWriteSettingResponse_t response;
  84         uint8_t tvMode = 0;
  85         if (video_system == VIDEO_SYSTEM_NTSC) {
  86             tvMode = 0;
  87         } else if (video_system == VIDEO_SYSTEM_PAL) {
  88             tvMode = 1;
  89         }
  90
  91         if (!runcamDeviceWriteSetting(osdDevice, RCDEVICE_PROTOCOL_SETTINGID_DISP_TV_MODE, &tvMode, sizeof(uint8_t), &response)) {
  92             return false;
  93         }
  94
  95         if (response.resultCode) {
  96             return false;
  97         }
  98     }
  99
 100     // user bf charset
 101     uint8_t charsetID = 0;
 102     runcamDeviceWriteSettingResponse_t updateCharsetResp;
 103     if (!runcamDeviceWriteSetting(osdDevice, RCDEVICE_PROTOCOL_SETTINGID_DISP_CHARSET, &charsetID, sizeof(uint8_t), &updateCharsetResp) || updateCharsetResp.resultCode != 0) {
 104         return false;
 105     }
 106
 107 #ifdef USE_PARTICLE_DRAW
 108     memset(shadowBuffer, 2, VIDEO_BUFFER_CHARS_PAL);
 109 #endif
 110
 111     // fill screen with ' '
 112     rcdeviceOSDClearScreen(NULL);
 113     return true;
 114 }
 115
 116 int rcdeviceOSDGrab(displayPort_t *displayPort)
 117 {
 118     UNUSED(displayPort);
 119     // osdResetAlarms();
 120     // resumeRefreshAt = 0;
 121     return 0;
 122 }
 123
 124 int rcdeviceOSDRelease(displayPort_t *displayPort)
 125 {
 126     UNUSED(displayPort);
 127     return 0;
 128 }
 129
 130 int rcdeviceOSDDrawScreen(displayPort_t *displayPort)
 131 {
 132     UNUSED(displayPort);
 133
 134 #ifdef USE_PARTICLE_DRAW
 135     static uint16_t pos = 0;
 136     int k = 0;
 137
 138     if (!rcdeviceOSDLock) {
 139         rcdeviceOSDLock = true;
 140
 141         uint8_t data[60];
 142         uint8_t dataLen = 0;
 143         for (k = 0; k < MAX_CHARS2UPDATE; k++) {
 144             if (screenBuffer[pos] != shadowBuffer[pos]) {
 145                 shadowBuffer[pos] = screenBuffer[pos];
 146                 uint8_t x = pos % columnCount;
 147                 uint8_t y = pos / columnCount;
 148                 data[dataLen++] = x;
 149                 data[dataLen++] = y;
 150                 data[dataLen++] = screenBuffer[pos];
 151             }
 152
 153             if (++pos >= maxScreenSize) {
 154                 pos = 0;
 155                 break;
 156             }
 157         }
 158         runcamDeviceDispWriteChars(osdDevice, data, dataLen);
 159
 160         rcdeviceOSDLock = false;
 161     }
 162 #endif
 163     return 0;
 164 }
 165
 166 int rcdeviceOSDWriteString(displayPort_t *displayPort, uint8_t x, uint8_t y, const char *buff)
 167 {
 168     UNUSED(displayPort);
 169 #if !defined(USE_PARTICLE_DRAW)
 170     runcamDeviceDispWriteHorizontalString(osdDevice, x, y, buff);
 171 #else
 172     for (int xpos = x; *buff && xpos < columnCount; xpos++) {
 173         screenBuffer[y * columnCount + xpos] = *buff++;
 174     }
 175 #endif
 176     return 0;
 177 }
 178
 179 int rcdeviceOSDWriteChar(displayPort_t *displayPort, uint8_t x, uint8_t y, uint8_t c)
 180 {
 181     UNUSED(displayPort);
 182 #if !defined(USE_PARTICLE_DRAW)
 183     runcamDeviceDispWriteChar(osdDevice, x, y, c);
 184 #else
 185     screenBuffer[y * columnCount + x] = c;
 186 #endif
 187
 188     return 0;
 189 }
 190
 191 int rcdeviceOSDClearScreen(displayPort_t *displayPort)
 192 {
 193     UNUSED(displayPort);
 194
 195 #if defined(USE_PARTICLE_DRAW)
 196     memset(screenBuffer, 0x20, sizeof(screenBuffer));
 197 #else
 198     runcamDeviceDispFillRegion(osdDevice, 0, 0, 255, 255, ' ');
 199 #endif
 200
 201     return 0;
 202 }
 203
 204 bool rcdeviceOSDIsTransferInProgress(const displayPort_t *displayPort)
 205 {
 206     UNUSED(displayPort);
 207     return false;
 208 }
 209
 210 bool rcdeviceOSDIsSynced(const displayPort_t *displayPort)
 211 {
 212     UNUSED(displayPort);
 213     return true;
 214 }
 215
 216 int rcdeviceOSDHeartbeat(displayPort_t *displayPort)
 217 {
 218     UNUSED(displayPort);
 219     return 0;
 220 }
 221
 222 void rcdeviceOSDResync(displayPort_t *displayPort)
 223 {
 224     UNUSED(displayPort);
 225
 226     if (video_system == VIDEO_SYSTEM_PAL) {
 227         displayPort->rows = RCDEVICE_PROTOCOL_OSD_VIDEO_LINES_PAL;
 228     } else {
 229         displayPort->rows = RCDEVICE_PROTOCOL_OSD_VIDEO_LINES_NTSC;
 230     }
 231
 232     displayPort->cols = columnCount;
 233     maxScreenSize = displayPort->rows * displayPort->cols;
 234 }
 235
 236 uint32_t rcdeviceOSDTxBytesFree(const displayPort_t *displayPort)
 237 {
 238     UNUSED(displayPort);
 239     return INT32_MAX;
 240 }
 241
 242 int rcdeviceScreenSize(const displayPort_t *displayPort)
 243 {
 244     return displayPort->rows * displayPort->cols;
 245 }
 246
 247 #endif