/[projet1]/public/pc/tools/osdk/main/pictconv/sources/oric_converter.h
Defence Force logotype

Diff of /public/pc/tools/osdk/main/pictconv/sources/oric_converter.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1259 by dbug, Sat Feb 1 14:47:09 2014 UTC revision 1260 by dbug, Sat Feb 14 20:26:49 2015 UTC
# Line 3  Line 3 
3    
4  #include "hires.h"  #include "hires.h"
5    
6    // This utility macro is used to define the set of all binary operations on an enum.
7    // This makes it possible to do type-safe boolean operations without having to duplicate
8    // the ugly syntax everywhere.
9    //-->> BINARYENUM
10    #ifndef BINARYENUM
11    #define BINARYENUM(T)                                                           \
12      inline T& operator++(T& e1)                 {e1 = (T)((int)(e1)+1);return e1;} \
13      inline T operator++(T& e1,int)              {T old(e1);e1 = (T)((int)(e1)+1);return old;} \
14      inline T operator~(const T e1)              {return (T)(~(int)e1);}           \
15      inline T operator|(const T e1,const T e2)   {return (T)((int)e1|(int)e2);}    \
16      inline T operator&( const T e1, const T e2 ){return (T)((int)e1&(int)e2);}    \
17      inline T operator^( const T e1, const T e2 ){return (T)((int)e1^(int)e2);}    \
18      inline T operator-( const T e1, const T e2 ){return (T)((int)e1-(int)e2);}    \
19      inline T operator+( const T e1, const T e2 ){return (T)((int)e1+(int)e2);}    \
20      inline T& operator |= (T& lhs,T rhs)        {lhs=lhs|rhs;return lhs;}         \
21      inline T& operator &= (T& lhs,T rhs)        {lhs=lhs&rhs;return lhs;}         \
22      inline T& operator ^= (T& lhs,T rhs)        {lhs=lhs^rhs;return lhs;}          
23    #endif
24    // <<-- BINARYENUM
25    
26    
27  enum ORIC_COLOR  enum ORIC_COLOR
28  {                                               // BGR  {                       // BGR
29    ORIC_COLOR_BLACK,     // 000    ORIC_COLOR_BLACK,     // 000
30    ORIC_COLOR_RED,               // 001    ORIC_COLOR_RED,       // 001
31    ORIC_COLOR_GREEN,     // 010    ORIC_COLOR_GREEN,     // 010
32    ORIC_COLOR_YELLOW,    // 011    ORIC_COLOR_YELLOW,    // 011
33    ORIC_COLOR_BLUE,      // 100    ORIC_COLOR_BLUE,      // 100
34    ORIC_COLOR_MAGENTA,   // 101    ORIC_COLOR_MAGENTA,   // 101
35    ORIC_COLOR_CYAN,      // 110    ORIC_COLOR_CYAN,      // 110
36    ORIC_COLOR_WHITE,     // 111    ORIC_COLOR_WHITE,     // 111
37    _ORIC_COLOR_LAST_    _ORIC_COLOR_LAST_,
38      ORIC_COLOR_OPAQUE     =0,
39      ORIC_COLOR_TRANSPARENT=8
40  };  };
41    
42    BINARYENUM(ORIC_COLOR)
43    
44    
45    class BlocOf6
46    {
47    public:
48      BlocOf6()
49      {
50        Clear();
51      }
52    
53      void Clear()
54      {
55        color_count=0;
56        colors[0]=ORIC_COLOR_BLACK;
57        colors[1]=ORIC_COLOR_BLACK;
58        value=0;
59      }
60    
61      bool AddColor(ORIC_COLOR color)
62      {
63        bool error_in_bloc=false;
64    
65        value<<=1;
66    
67        // Check if it's already present in the color map
68        switch (color_count)
69        {
70        case 0:
71          color_count++;
72          colors[0]=color;
73          colors[1]=color;  // To avoid later tests
74          break;
75    
76        case 1:
77          if (colors[0]!=color)
78          {
79            // one more color
80            color_count++;
81            colors[1]=color;
82            value|=1;
83          }
84          break;
85    
86        case 2:
87          if (colors[0]!=color)
88          {
89            if (colors[1]==color)
90            {
91              // second color
92              value|=1;
93            }
94            else
95            {
96              // color overflow !!!
97              color_count++;
98    
99              error_in_bloc=true;
100            }
101          }
102          break;
103        }
104        return error_in_bloc;
105      }
106    
107      bool UsePalette(ORIC_COLOR paperColor,ORIC_COLOR inkColor)
108      {
109        switch (color_count)
110        {
111        case 1: // Only one color is used in this block      
112          if (colors[0]==paperColor)
113          {
114            // We already have the right paper color, nothing to do
115            return true;
116          }
117          if (colors[0]==inkColor)
118          {
119            // This block uses the ink color, need to invert the bit mask
120            value^=1+2+4+8+16+32;
121            return true;
122          }
123          if (colors[0]==(paperColor^7))
124          {
125            // This block uses the inverted paper color, need to invert video it
126            value|=128;
127            return true;
128          }
129          if (colors[0]==(inkColor^7))
130          {
131            // This block uses the ink color, need to invert both the bit mask and the invert video bit
132            value^=1+2+4+8+16+32;
133            value|=128;
134            return true;
135          }
136          break;
137    
138        case 2: // Two colors are used in this block
139          if ( (colors[0]==paperColor) && (colors[1]==inkColor) )
140          {
141            // We already have the right paper and ink colors, nothing to do
142            return true;
143          }
144          if ( (colors[0]==inkColor) && (colors[1]==paperColor) )
145          {
146            // The paper and ink values are inverted, we need to invert the bit mask
147            value^=1+2+4+8+16+32;
148            return true;
149          }
150          if ( (colors[0]==(paperColor^7)) && (colors[1]==(inkColor^7)) )
151          {
152            // This block uses the inverted paper color, need to invert video it
153            value|=128;
154            return true;
155          }
156          if ( (colors[0]==(inkColor^7)) && (colors[1]==(paperColor^7)) )
157          {
158            // This block uses the ink color, need to invert both the bit mask and the invert video bit
159            value^=1+2+4+8+16+32;
160            value|=128;
161            return true;
162          }
163          break;
164    
165        default:
166          // Not the right number of colors, can't do anything about it
167          return false;
168        }
169    
170        return true;
171      }
172    
173    public:
174      unsigned char color_count;    ///< Number of colors in the block (1, 2 or invalid)
175      ORIC_COLOR    colors[2];      ///< The two first color found by order of appearance
176      unsigned char value;          ///< The bitmap that associate each color to each bit, and possibly the inverse video flag if enabled
177    };
178    
179    
180    
181  class GeneratedBuffer  class GeneratedBuffer
182  {  {
183  public:  public:
# Line 100  public: Line 262  public:
262      FORMAT_RB,              // -f4      FORMAT_RB,              // -f4
263      FORMAT_CHARMAP,         // -f5      FORMAT_CHARMAP,         // -f5
264      FORMAT_SAM_HOCEVAR,     // -f6      FORMAT_SAM_HOCEVAR,     // -f6
265        FORMAT_AIC,             // -f7
266      _FORMAT_MAX_      _FORMAT_MAX_
267    };    };
268    
# Line 110  public: Line 273  public:
273    virtual int GetPaletteMode() const            { return 0; }    virtual int GetPaletteMode() const            { return 0; }
274    virtual bool SetPaletteMode(int paletteMode)  { return paletteMode==0; }    virtual bool SetPaletteMode(int paletteMode)  { return paletteMode==0; }
275    
276      virtual int GetTransparencyMode() const                         { return m_transparency; }
277      virtual bool SetTransparencyMode(int transparencyMode)          { m_transparency=(TRANSPARENCY)transparencyMode;return m_transparency<_TRANSPARENCY_MAX_; }
278    
279    virtual bool Convert(const ImageContainer& sourcePicture);    virtual bool Convert(const ImageContainer& sourcePicture);
280    virtual bool TakeSnapShot(ImageContainer& sourcePicture);    virtual bool TakeSnapShot(ImageContainer& sourcePicture);
281    
# Line 125  public: Line 291  public:
291    void convert_twilighte_mask(const ImageContainer& sourcePicture);    void convert_twilighte_mask(const ImageContainer& sourcePicture);
292    void convert_charmap(const ImageContainer& sourcePicture);    void convert_charmap(const ImageContainer& sourcePicture);
293    void convert_sam_hocevar(const ImageContainer& sourcePicture);    void convert_sam_hocevar(const ImageContainer& sourcePicture);
294      void convert_aic(const ImageContainer& sourcePicture);
295        
296    ORIC_COLOR convert_pixel_monochrom(const ImageContainer& sourcePicture,unsigned int x,unsigned int y);    ORIC_COLOR convert_pixel_monochrom(const ImageContainer& sourcePicture,unsigned int x,unsigned int y);
297    ORIC_COLOR convert_pixel_rgb(const ImageContainer& sourcePicture,unsigned int x,unsigned int y);    ORIC_COLOR convert_pixel_rgb(const ImageContainer& sourcePicture,unsigned int x,unsigned int y);
# Line 150  private: Line 317  private:
317    GeneratedBuffer m_SecondaryBuffer;    GeneratedBuffer m_SecondaryBuffer;
318    
319    FORMAT          m_format;    FORMAT          m_format;
320      ORIC_COLOR      m_PaletteAIC[2][2];         ///< [even/odd scanline[paper/ink color]
321    
322    bool            m_flag_setbit6;    bool            m_flag_setbit6;
323  };  };

Legend:
Removed from v.1259  
changed lines
  Added in v.1260

  ViewVC Help
Powered by ViewVC 1.1.26