vga16controller.h

Go to the documentation of this file.

/*
  Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  Copyright (c) 2019-2020 Fabrizio Di Vittorio.
  All rights reserved.

  This file is part of FabGL Library.

  FabGL is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  FabGL is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 */


#pragma once



#include <stdint.h>
#include <stddef.h>
#include <atomic>

#include "rom/lldesc.h"
#include "driver/gpio.h"

#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"

#include "fabglconf.h"
#include "fabutils.h"
#include "devdrivers/swgenerator.h"
#include "displaycontroller.h"
#include "dispdrivers/vgacontroller.h"



#define VGA16_LinesCount 4

//#define VGATextController_PERFORMANCE_CHECK


namespace fabgl {



class VGA16Controller : public GenericBitmappedDisplayController {

public:

  VGA16Controller();

  // unwanted methods
  VGA16Controller(VGA16Controller const&)   = delete;
  void operator=(VGA16Controller const&)  = delete;


  static VGA16Controller * instance() { return s_instance; }


  void begin(gpio_num_t redGPIO, gpio_num_t greenGPIO, gpio_num_t blueGPIO, gpio_num_t HSyncGPIO, gpio_num_t VSyncGPIO);

  void begin(gpio_num_t red1GPIO, gpio_num_t red0GPIO, gpio_num_t green1GPIO, gpio_num_t green0GPIO, gpio_num_t blue1GPIO, gpio_num_t blue0GPIO, gpio_num_t HSyncGPIO, gpio_num_t VSyncGPIO);

  void begin();

  void end();

  // abstract method of BitmappedDisplayController
  void suspendBackgroundPrimitiveExecution();

  // abstract method of BitmappedDisplayController
  void resumeBackgroundPrimitiveExecution();

  uint8_t getBitsPerChannel() { return m_bitsPerChannel; }

  // abstract method of BitmappedDisplayController
  NativePixelFormat nativePixelFormat() { return NativePixelFormat::PALETTE16; }

  void setResolution(char const * modeline, int viewPortWidth = -1, int viewPortHeight = -1, bool doubleBuffered = false);

  void setResolution(VGATimings const& timings, int viewPortWidth = -1, int viewPortHeight = -1, bool doubleBuffered = false);

  VGATimings * getResolutionTimings() { return &m_timings; }

  // abstract method of BitmappedDisplayController
  int getScreenWidth()    { return m_timings.HVisibleArea; }

  // abstract method of BitmappedDisplayController
  int getScreenHeight()   { return m_timings.VVisibleArea; }

  int getViewPortCol()    { return m_viewPortCol; }

  int getViewPortRow()    { return m_viewPortRow; }

  // abstract method of BitmappedDisplayController
  int getViewPortWidth()  { return m_viewPortWidth; }

  // abstract method of BitmappedDisplayController
  int getViewPortHeight() { return m_viewPortHeight; }

  void moveScreen(int offsetX, int offsetY);

  void shrinkScreen(int shrinkX, int shrinkY);

  static uint8_t * getScanline(int y)                { return (uint8_t*) s_viewPort[y]; }

  void readScreen(Rect const & rect, RGB888 * destBuf);

  void setPaletteItem(int index, RGB888 const & color);

  void setProcessPrimitivesOnBlank(bool value)          { m_processPrimitivesOnBlank = value; }

private:



  void init(gpio_num_t VSyncGPIO);

  uint8_t packHVSync(bool HSync, bool VSync);
  uint8_t preparePixel(RGB222 rgb) { return m_HVSync | (rgb.B << VGA_BLUE_BIT) | (rgb.G << VGA_GREEN_BIT) | (rgb.R << VGA_RED_BIT); }
  uint8_t preparePixelWithSync(RGB222 rgb, bool HSync, bool VSync);

  uint8_t RGB888toPaletteIndex(RGB888 const & rgb);
  uint8_t RGB2222toPaletteIndex(uint8_t value);
  uint8_t RGB8888toPaletteIndex(RGBA8888 value);


  void freeBuffers();
  void fillHorizBuffers(int offsetX);
  void fillVertBuffers(int offsetY);
  int fill(uint8_t volatile * buffer, int startPos, int length, uint8_t red, uint8_t green, uint8_t blue, bool hsync, bool vsync);
  void allocateViewPort();
  void freeViewPort();
  int calcRequiredDMABuffersCount(int viewPortHeight);

  // abstract method of BitmappedDisplayController
  void setPixelAt(PixelDesc const & pixelDesc, Rect & updateRect);

  // abstract method of BitmappedDisplayController
  void drawEllipse(Size const & size, Rect & updateRect);

  // abstract method of BitmappedDisplayController
  void clear(Rect & updateRect);

  // abstract method of BitmappedDisplayController
  void VScroll(int scroll, Rect & updateRect);

  // abstract method of BitmappedDisplayController
  void HScroll(int scroll, Rect & updateRect);

  // abstract method of BitmappedDisplayController
  void drawGlyph(Glyph const & glyph, GlyphOptions glyphOptions, RGB888 penColor, RGB888 brushColor, Rect & updateRect);

  // abstract method of BitmappedDisplayController
  void invertRect(Rect const & rect, Rect & updateRect);

  // abstract method of BitmappedDisplayController
  void copyRect(Rect const & source, Rect & updateRect);

  // abstract method of BitmappedDisplayController
  void swapFGBG(Rect const & rect, Rect & updateRect);

  // abstract method of BitmappedDisplayController
  void swapBuffers();

  // abstract method of BitmappedDisplayController
  void rawDrawBitmap_Native(int destX, int destY, Bitmap const * bitmap, int X1, int Y1, int XCount, int YCount);

  // abstract method of BitmappedDisplayController
  void rawDrawBitmap_Mask(int destX, int destY, Bitmap const * bitmap, void * saveBackground, int X1, int Y1, int XCount, int YCount);

  // abstract method of BitmappedDisplayController
  void rawDrawBitmap_RGBA2222(int destX, int destY, Bitmap const * bitmap, void * saveBackground, int X1, int Y1, int XCount, int YCount);

  // abstract method of BitmappedDisplayController
  void rawDrawBitmap_RGBA8888(int destX, int destY, Bitmap const * bitmap, void * saveBackground, int X1, int Y1, int XCount, int YCount);

  // abstract method of BitmappedDisplayController
  void rawFillRow(int y, int x1, int x2, RGB888 color);

  void rawFillRow(int y, int x1, int x2, uint8_t colorIndex);

  void rawInvertRow(int y, int x1, int x2);

  void rawCopyRow(int x1, int x2, int srcY, int dstY);

  void swapRows(int yA, int yB, int x1, int x2);

  // abstract method of BitmappedDisplayController
  void absDrawLine(int X1, int Y1, int X2, int Y2, RGB888 color);

  // abstract method of BitmappedDisplayController
  int getBitmapSavePixelSize() { return 1; }

  static void I2SInterrupt(void * arg);

  static void primitiveExecTask(void * arg);

  void calculateAvailableCyclesForDrawings();

  static void setupGPIO(gpio_num_t gpio, int bit, gpio_mode_t mode);

  void setupDefaultPalette();
  void updateRGB2PaletteLUT();

  // DMA related methods
  bool setDMABuffersCount(int buffersCount);
  void setDMABufferBlank(int index, void volatile * address, int length);
  void setDMABufferView(int index, int row, int scan);
  void volatile * getDMABuffer(int index, int * length);


  static VGA16Controller *   s_instance;
  static volatile int        s_scanLine;
  static lldesc_t volatile * s_frameResetDesc;

  intr_handle_t          m_isr_handle;

  TaskHandle_t           m_primitiveExecTask;

  volatile int           m_primitiveProcessingSuspended;             // 0 = enabled, >0 suspended

  GPIOStream             m_GPIOStream;

  int                    m_bitsPerChannel;  // 1 = 8 colors, 2 = 64 colors, set by begin()
  VGATimings             m_timings;
  int16_t                m_rawFrameHeight;

  volatile uint32_t      m_primitiveExecTimeoutCycles; // Maximum time (in CPU cycles) available for primitives drawing

  // true = allowed time to process primitives is limited to the vertical blank. Slow, but avoid flickering
  // false = allowed time is the half of an entire frame. Fast, but may flick
  bool                   m_processPrimitivesOnBlank;

  // These buffers contains a full line, with FrontPorch, Sync, BackPorch and blank visible area, in the
  // order specified by timings.HStartingBlock
  volatile uint8_t *     m_HBlankLine_withVSync;
  volatile uint8_t *     m_HBlankLine;
  int16_t                m_HLineSize;

  // contains H and V signals for visible line
  volatile uint8_t       m_HVSync;

  volatile int16_t       m_viewPortCol;
  volatile int16_t       m_viewPortRow;
  volatile int16_t       m_viewPortWidth;
  volatile int16_t       m_viewPortHeight;

  // when double buffer is enabled the "drawing" view port is always m_viewPort, while the "visible" view port is always m_viewPortVisible
  // when double buffer is not enabled then m_viewPort = m_viewPortVisible
  static volatile uint8_t * * s_viewPort;
  static volatile uint8_t * * s_viewPortVisible;

  volatile uint8_t *     m_lines[VGA16_LinesCount];

  uint8_t *              m_viewPortMemoryPool[FABGLIB_VIEWPORT_MEMORY_POOL_COUNT + 1];  // last allocated pool is nullptr

  lldesc_t volatile *    m_DMABuffers;

  int                    m_DMABuffersCount;

  gpio_num_t             m_VSyncGPIO;

  RGB222                 m_palette[16];
  uint8_t                m_packedRGB222_to_PaletteIndex[64];
  volatile uint16_t      m_packedPaletteIndexPair_to_signals[256];

  volatile bool          m_taskProcessingPrimitives;

};



} // end of namespace