multiplex-mappers.cc

// -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
// Copyright (C) 2017 Henner Zeller <h.zeller@acm.org>
//
// This program 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 version 2.
//
// This program 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 this program.  If not, see <http://gnu.org/licenses/gpl-2.0.txt>

#include "multiplex-mappers-internal.h"

namespace rgb_matrix
{
  namespace internal
  {
    // A Pixel Mapper maps physical pixels locations to the internal logical
    // mapping in a panel or panel-assembly, which depends on the wiring.
    class MultiplexMapperBase : public MultiplexMapper
    {
    public:
      MultiplexMapperBase(const char *name, int stretch_factor)
          : name_(name), panel_stretch_factor_(stretch_factor) {}

      // This method is const, but we sneakily remember the original size
      // of the panels so that we can more easily quantize things.
      // So technically, we're stateful, but let's pretend we're not changing
      // state. In the context this is used, it is never accessed in multiple
      // threads.
      virtual void EditColsRows(int *cols, int *rows) const
      {
        panel_rows_ = *rows;
        panel_cols_ = *cols;

        *rows /= panel_stretch_factor_;
        *cols *= panel_stretch_factor_;
      }

      virtual bool GetSizeMapping(int matrix_width, int matrix_height,
                                  int *visible_width, int *visible_height) const
      {
        // Matrix width has been altered. Alter it back.
        *visible_width = matrix_width / panel_stretch_factor_;
        *visible_height = matrix_height * panel_stretch_factor_;
        return true;
      }

      virtual const char *GetName() const { return name_; }

      // The MapVisibleToMatrix() as required by PanelMatrix here breaks it
      // down to the individual panel, so that derived classes only need to
      // implement MapSinglePanel().
      virtual void MapVisibleToMatrix(int matrix_width, int matrix_height,
                                      int visible_x, int visible_y,
                                      int *matrix_x, int *matrix_y) const
      {
        const int chained_panel = visible_x / panel_cols_;
        const int parallel_panel = visible_y / panel_rows_;

        const int within_panel_x = visible_x % panel_cols_;
        const int within_panel_y = visible_y % panel_rows_;

        int new_x, new_y;
        MapSinglePanel(within_panel_x, within_panel_y, &new_x, &new_y);
        *matrix_x = chained_panel * panel_stretch_factor_ * panel_cols_ + new_x;
        *matrix_y = parallel_panel * panel_rows_ / panel_stretch_factor_ + new_y;
      }

      // Map the coordinates for a single panel. This is to be overridden in
      // derived classes.
      // Input parameter is the visible position on the matrix, and this method
      // should return the internal multiplexed position.
      virtual void MapSinglePanel(int visible_x, int visible_y,
                                  int *matrix_x, int *matrix_y) const = 0;

    protected:
      const char *const name_;
      const int panel_stretch_factor_;

      mutable int panel_cols_;
      mutable int panel_rows_;
    };

    /* ========================================================================
 * Multiplexer implementations.
 *
 * Extend MultiplexMapperBase and implement MapSinglePanel. You only have
 * to worry about the mapping within a single panel, the overall panel
 * construction with chains and parallel is already taken care of.
 *
 * Don't forget to register the new multiplexer sin CreateMultiplexMapperList()
 * below. After that, the new mapper is available in the --led-multiplexing
 * option.
 */
    class StripeMultiplexMapper : public MultiplexMapperBase
    {
    public:
      StripeMultiplexMapper() : MultiplexMapperBase("Stripe", 2) {}

      void MapSinglePanel(int x, int y, int *matrix_x, int *matrix_y) const
      {
        const bool is_top_stripe = (y % (panel_rows_ / 2)) < panel_rows_ / 4;
        *matrix_x = is_top_stripe ? x + panel_cols_ : x;
        *matrix_y = ((y / (panel_rows_ / 2)) * (panel_rows_ / 4) + y % (panel_rows_ / 4));
      }
    };

    class CheckeredMultiplexMapper : public MultiplexMapperBase
    {
    public:
      CheckeredMultiplexMapper() : MultiplexMapperBase("Checkered", 2) {}

      void MapSinglePanel(int x, int y, int *matrix_x, int *matrix_y) const
      {
        const bool is_top_check = (y % (panel_rows_ / 2)) < panel_rows_ / 4;
        const bool is_left_check = (x < panel_cols_ / 2);
        if (is_top_check)
        {
          *matrix_x = is_left_check ? x + panel_cols_ / 2 : x + panel_cols_;
        }
        else
        {
          *matrix_x = is_left_check ? x : x + panel_cols_ / 2;
        }
        *matrix_y = ((y / (panel_rows_ / 2)) * (panel_rows_ / 4) + y % (panel_rows_ / 4));
      }
    };

    class SpiralMultiplexMapper : public MultiplexMapperBase
    {
    public:
      SpiralMultiplexMapper() : MultiplexMapperBase("Spiral", 2) {}

      void MapSinglePanel(int x, int y, int *matrix_x, int *matrix_y) const
      {
        const bool is_top_stripe = (y % (panel_rows_ / 2)) < panel_rows_ / 4;
        const int panel_quarter = panel_cols_ / 4;
        const int quarter = x / panel_quarter;
        const int offset = x % panel_quarter;
        *matrix_x = ((2 * quarter * panel_quarter) + (is_top_stripe
                                                          ? panel_quarter - 1 - offset
                                                          : panel_quarter + offset));
        *matrix_y = ((y / (panel_rows_ / 2)) * (panel_rows_ / 4) + y % (panel_rows_ / 4));
      }
    };

    class ZStripeMultiplexMapper : public MultiplexMapperBase
    {
    public:
      ZStripeMultiplexMapper(const char *name, int even_vblock_offset, int odd_vblock_offset)
          : MultiplexMapperBase(name, 2),
            even_vblock_offset_(even_vblock_offset),
            odd_vblock_offset_(odd_vblock_offset) {}

      void MapSinglePanel(int x, int y, int *matrix_x, int *matrix_y) const
      {
        static const int tile_width = 8;
        static const int tile_height = 4;

        const int vert_block_is_odd = ((y / tile_height) % 2);

        const int even_vblock_shift = (1 - vert_block_is_odd) * even_vblock_offset_;
        const int odd_vblock_shitf = vert_block_is_odd * odd_vblock_offset_;

        *matrix_x = x + ((x + even_vblock_shift) / tile_width) * tile_width + odd_vblock_shitf;
        *matrix_y = (y % tile_height) + tile_height * (y / (tile_height * 2));
      }

    private:
      const int even_vblock_offset_;
      const int odd_vblock_offset_;
    };

    class CoremanMapper : public MultiplexMapperBase
    {
    public:
      CoremanMapper() : MultiplexMapperBase("coreman", 2) {}

      void MapSinglePanel(int x, int y, int *matrix_x, int *matrix_y) const
      {
        const bool is_left_check = (x < panel_cols_ / 2);

        if ((y <= 7) || ((y >= 16) && (y <= 23)))
        {
          *matrix_x = ((x / (panel_cols_ / 2)) * panel_cols_) + (x % (panel_cols_ / 2));
          if ((y & (panel_rows_ / 4)) == 0)
          {
            *matrix_y = (y / (panel_rows_ / 2)) * (panel_rows_ / 4) + (y % (panel_rows_ / 4));
          }
        }
        else
        {
          *matrix_x = is_left_check ? x + panel_cols_ / 2 : x + panel_cols_;
          *matrix_y = (y / (panel_rows_ / 2)) * (panel_rows_ / 4) + y % (panel_rows_ / 4);
        }
      }
    };

    class Kaler2ScanMapper : public MultiplexMapperBase
    {
    public:
      Kaler2ScanMapper() : MultiplexMapperBase("Kaler2Scan", 4) {}

      void MapSinglePanel(int x, int y, int *matrix_x, int *matrix_y) const
      {
        // Now we have a 128x4 matrix
        int offset = ((y % 4) / 2) == 0 ? -1 : 1; // Add o substract
        int deltaOffset = offset < 0 ? 7 : 8;
        int deltaColumn = ((y % 8) / 4) == 0 ? 64 : 0;

        *matrix_y = (y % 2 + (y / 8) * 2);
        *matrix_x = deltaColumn + (16 * (x / 8)) + deltaOffset + ((x % 8) * offset);
      }
    };

    class P10MapperZ : public MultiplexMapperBase
    {
    public:
      P10MapperZ() : MultiplexMapperBase("P10-128x4-Z", 4) {}
      // supports this panel: https://www.aliexpress.com/item/2017-Special-Offer-P10-Outdoor-Smd-Full-Color-Led-Display-Module-320x160mm-1-2-Scan-Outdoor/32809267439.html?spm=a2g0s.9042311.0.0.Ob0jEw
      // with --led-row-addr-type=2 flag
      void MapSinglePanel(int x, int y, int *matrix_x, int *matrix_y) const
      {
        int yComp = 0;
        if (y == 0 || y == 1 || y == 8 || y == 9)
        {
          yComp = 127;
        }
        else if (y == 2 || y == 3 || y == 10 || y == 11)
        {
          yComp = 112;
        }
        else if (y == 4 || y == 5 || y == 12 || y == 13)
        {
          yComp = 111;
        }
        else if (y == 6 || y == 7 || y == 14 || y == 15)
        {
          yComp = 96;
        }

        if (y == 0 || y == 1 || y == 4 || y == 5 ||
            y == 8 || y == 9 || y == 12 || y == 13)
        {
          *matrix_x = yComp - x;
          *matrix_x -= (24 * ((int)(x / 8)));
        }
        else
        {
          *matrix_x = yComp + x;
          *matrix_x -= (40 * ((int)(x / 8)));
        }

        if (y == 0 || y == 2 || y == 4 || y == 6)
        {
          *matrix_y = 3;
        }
        else if (y == 1 || y == 3 || y == 5 || y == 7)
        {
          *matrix_y = 2;
        }
        else if (y == 8 || y == 10 || y == 12 || y == 14)
        {
          *matrix_y = 1;
        }
        else if (y == 9 || y == 11 || y == 13 || y == 15)
        {
          *matrix_y = 0;
        }
      }
    };

    class QiangLiQ8 : public MultiplexMapperBase
    {
    public:
      QiangLiQ8() : MultiplexMapperBase("QiangLiQ8", 2) {}

      void MapSinglePanel(int x, int y, int *matrix_x, int *matrix_y) const
      {
        const int column = x + (4 + 4 * (x / 4));
        *matrix_x = column;
        if ((y >= 15 && y <= 19) || (y >= 5 && y <= 9))
        {
          const int reverseColumn = x + (4 * (x / 4));
          *matrix_x = reverseColumn;
        }
        *matrix_y = y % 5 + (y / 10) * 5;
      }
    };

    class InversedZStripe : public MultiplexMapperBase
    {
    public:
      InversedZStripe() : MultiplexMapperBase("InversedZStripe", 2) {}

      void MapSinglePanel(int x, int y, int *matrix_x, int *matrix_y) const
      {
        static const int tile_width = 8;
        static const int tile_height = 4;

        const int vert_block_is_odd = ((y / tile_height) % 2);
        const int evenOffset[8] = {7, 5, 3, 1, -1, -3, -5, -7};

        if (vert_block_is_odd)
        {
          *matrix_x = x + (x / tile_width) * tile_width;
        }
        else
        {
          *matrix_x = x + (x / tile_width) * tile_width + 8 + evenOffset[x % 8];
        }
        *matrix_y = (y % tile_height) + tile_height * (y / (tile_height * 2));
      }
    };

    /*
 * Vairous P10 1R1G1B Outdoor implementations for 16x16 modules with separate
 * RGB LEDs, e.g.:
 * https://www.ledcontrollercard.com/english/p10-outdoor-rgb-led-module-160x160mm-dip.html
 *
 */
    class P10Outdoor1R1G1BMultiplexBase : public MultiplexMapperBase
    {
    public:
      P10Outdoor1R1G1BMultiplexBase(const char *name)
          : MultiplexMapperBase(name, 2) {}

      void MapSinglePanel(int x, int y, int *matrix_x, int *matrix_y) const
      {
        const int vblock_is_odd = (y / tile_height_) % 2;
        const int vblock_is_even = 1 - vblock_is_odd;
        const int even_vblock_shift = vblock_is_even * even_vblock_offset_;
        const int odd_vblock_shift = vblock_is_odd * odd_vblock_offset_;

        MapPanel(x, y, matrix_x, matrix_y,
                 vblock_is_even, vblock_is_odd,
                 even_vblock_shift, odd_vblock_shift);
      }

    protected:
      virtual void MapPanel(int x, int y, int *matrix_x, int *matrix_y,
                            int vblock_is_even, int vblock_is_odd,
                            int even_vblock_shift, int odd_vblock_shift) const = 0;

      static const int tile_width_ = 8;
      static const int tile_height_ = 4;
      static const int even_vblock_offset_ = 0;
      static const int odd_vblock_offset_ = 8;
    };

    class P10Outdoor1R1G1BMultiplexMapper1 : public P10Outdoor1R1G1BMultiplexBase
    {
    public:
      P10Outdoor1R1G1BMultiplexMapper1()
          : P10Outdoor1R1G1BMultiplexBase("P10Outdoor1R1G1-1") {}

    protected:
      void MapPanel(int x, int y, int *matrix_x, int *matrix_y,
                    const int vblock_is_even, const int vblock_is_odd,
                    const int even_vblock_shift, const int odd_vblock_shift) const
      {
        *matrix_x = tile_width_ * (1 + vblock_is_even + 2 * (x / tile_width_)) - (x % tile_width_) - 1;
        *matrix_y = (y % tile_height_) + tile_height_ * (y / (tile_height_ * 2));
      }
    };

    class P10Outdoor1R1G1BMultiplexMapper2 : public P10Outdoor1R1G1BMultiplexBase
    {
    public:
      P10Outdoor1R1G1BMultiplexMapper2()
          : P10Outdoor1R1G1BMultiplexBase("P10Outdoor1R1G1-2") {}

    protected:
      void MapPanel(int x, int y, int *matrix_x, int *matrix_y,
                    const int vblock_is_even, const int vblock_is_odd,
                    const int even_vblock_shift, const int odd_vblock_shift) const
      {
        *matrix_x = vblock_is_even
                        ? tile_width_ * (1 + 2 * (x / tile_width_)) - (x % tile_width_) - 1
                        : x + ((x + even_vblock_shift) / tile_width_) * tile_width_ + odd_vblock_shift;
        *matrix_y = (y % tile_height_) + tile_height_ * (y / (tile_height_ * 2));
      }
    };

    class P10Outdoor1R1G1BMultiplexMapper3 : public P10Outdoor1R1G1BMultiplexBase
    {
    public:
      P10Outdoor1R1G1BMultiplexMapper3()
          : P10Outdoor1R1G1BMultiplexBase("P10Outdoor1R1G1-3") {}

    protected:
      void MapPanel(int x, int y, int *matrix_x, int *matrix_y,
                    const int vblock_is_even, const int vblock_is_odd,
                    const int even_vblock_shift, const int odd_vblock_shift) const
      {
        *matrix_x = vblock_is_odd
                        ? tile_width_ * (2 + 2 * (x / tile_width_)) - (x % tile_width_) - 1
                        : x + ((x + even_vblock_shift) / tile_width_) * tile_width_ + odd_vblock_shift;
        *matrix_y = (y % tile_height_) + tile_height_ * (y / (tile_height_ * 2));
      }
    };

    class P10CoremanMapper : public MultiplexMapperBase
    {
    public:
      P10CoremanMapper() : MultiplexMapperBase("P10CoremanMapper", 4) {}

      void MapSinglePanel(int x, int y, int *matrix_x, int *matrix_y) const
      {
        //Row offset 8,8,8,8,0,0,0,0,8,8,8,8,0,0,0,0
        int mulY = (y & 4) > 0 ? 0 : 8;

        //Row offset 9,9,8,8,1,1,0,0,9,9,8,8,1,1,0,0
        mulY += (y & 2) > 0 ? 0 : 1;
        mulY += (x >> 2) & ~1; //Drop lsb

        *matrix_x = (mulY << 3) + x % 8;
        *matrix_y = (y & 1) + ((y >> 2) & ~1);
      }
    };

    class P8KryQMapper : public MultiplexMapperBase
    {
    public:
      P8KryQMapper() : MultiplexMapperBase("P8KryQMapper", 2) {}

      void MapSinglePanel(int x, int y, int *matrix_x, int *matrix_y) const
      {
        static const int tile_width = 8;
        static const int tile_height = 5;

        const int vert_block_is_odd = ((y / tile_height) % 2);
        const int evenOffset[8] = {7, 5, 3, 1, -1, -3, -5, -7};

        if (!vert_block_is_odd)
        {
          x = x + (x / tile_width) * tile_width;
        }
        else
        {
          x = x + (x / tile_width) * tile_width + 8 + evenOffset[x % 8];
        }

        *matrix_x = ((x / tile_width) + 1) * tile_width - (x % tile_width) - 1;
        *matrix_y = (y % tile_height) + tile_height * (y / (tile_height * 2));
      }
    };

    /*
 * Here is where the registration happens.
 * If you add an instance of the mapper here, it will automatically be
 * made available in the --led-multiplexing commandline option.
 */
    static MuxMapperList *CreateMultiplexMapperList()
    {
      MuxMapperList *result = new MuxMapperList();

      // Here, register all multiplex mappers from above.
      result->push_back(new StripeMultiplexMapper());
      result->push_back(new CheckeredMultiplexMapper());
      result->push_back(new SpiralMultiplexMapper());
      result->push_back(new ZStripeMultiplexMapper("ZStripe", 0, 8));
      result->push_back(new ZStripeMultiplexMapper("ZnMirrorZStripe", 4, 4));
      result->push_back(new CoremanMapper());
      result->push_back(new Kaler2ScanMapper());
      result->push_back(new ZStripeMultiplexMapper("ZStripeUneven", 8, 0));
      result->push_back(new P10MapperZ());
      result->push_back(new QiangLiQ8());
      result->push_back(new InversedZStripe());
      result->push_back(new P10Outdoor1R1G1BMultiplexMapper1());
      result->push_back(new P10Outdoor1R1G1BMultiplexMapper2());
      result->push_back(new P10Outdoor1R1G1BMultiplexMapper3());
      result->push_back(new P10CoremanMapper());
      result->push_back(new P8KryQMapper());
      return result;
    }

    const MuxMapperList &GetRegisteredMultiplexMappers()
    {
      static const MuxMapperList *all_mappers = CreateMultiplexMapperList();
      return *all_mappers;
    }
  } // namespace internal
} // namespace rgb_matrix