Main Page | Namespace List | Class Hierarchy | Class List | Directories | File List | Namespace Members | Class Members | File Members

# KeosConvertPixel.inl

Go to the documentation of this file.

    00001 /*
    00002  * This source file is part of KEOS (Free 3D Engine)
    00003  * For the latest info, see http://www.keosengine.org/
    00004  * E-mails : thierry.vouriot@keosengine.org, yeri@keosengine.org
    00005  *
    00006  * This program is free software; you can redistribute it and/or modify it under
    00007  * the terms of the GNU Lesser General Public License as published by the Free Software
    00008  * Foundation; either version 2 of the License, or (at your option) any later
    00009  * version.
    00010  *
    00011  * This program is distributed in the hope that it will be useful, but WITHOUT
    00012  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    00013  * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
    00014  *
    00015  * You should have received a copy of the GNU Lesser General Public License along with
    00016  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
    00017  * Place - Suite 330, Boston, MA 02111-1307, USA, or go to
    00018  * http://www.gnu.org/copyleft/lesser.txt.
    00019  *
    00020  */
    00021
    00022 // @todo : prendre en compte l'endianess... (faire deux fichiers : ConvertPixelBigEndian.inl et ConvertPixelLittleEndian.inl)
    00023
    00024
    00025 // Specialization for conversions PXF_L8 -> ???
    00026 template <>
    00027 inline void ConvertPixel<PXF_L8, PXF_L8>(const uchar* pSrc, uchar* pDest)
    00028 {
    00029     *pDest = *pSrc;
    00030 }
    00031
    00032 template <>
    00033 inline void ConvertPixel<PXF_L8, PXF_A8L8>(const uchar* pSrc, uchar* pDest)
    00034 {
    00035     pDest[0] = *pSrc;
    00036     pDest[1] = 0xFF;
    00037 }
    00038
    00039 template <>
    00040 inline void ConvertPixel<PXF_L8, PXF_A1R5G5B5>(const uchar* pSrc, uchar* pDest)
    00041 {
    00042     *reinterpret_cast<ushort*>(pDest) = 0x8000 |
    00043                                                ((*pSrc >> 3) << 10) |
    00044                                                ((*pSrc >> 3) <<  5) |
    00045                                                ((*pSrc >> 3) <<  0);
    00046 }
    00047
    00048 template <>
    00049 inline void ConvertPixel<PXF_L8, PXF_A4R4G4B4>(const uchar* pSrc, uchar* pDest)
    00050 {
    00051     pDest[0] = (*pSrc & 0xF0) | (*pSrc >> 4);
    00052     pDest[1] = 0xF0 | (*pSrc >> 4);
    00053 }
    00054
    00055 template <>
    00056 inline void ConvertPixel<PXF_L8, PXF_R8G8B8>(const uchar* pSrc, uchar* pDest)
    00057 {
    00058     pDest[0] = *pSrc;
    00059     pDest[1] = *pSrc;
    00060     pDest[2] = *pSrc;
    00061 }
    00062
    00063 template <>
    00064 inline void ConvertPixel<PXF_L8, PXF_A8R8G8B8>(const uchar* pSrc, uchar* pDest)
    00065 {
    00066     pDest[0] = *pSrc;
    00067     pDest[1] = *pSrc;
    00068     pDest[2] = *pSrc;
    00069     pDest[3] = 0xFF;
    00070 }
    00071
    00072
    00073 // Specialization for conversions PXF_A8L8 -> ???
    00074 template <>
    00075 inline void ConvertPixel<PXF_A8L8, PXF_L8>(const uchar* pSrc, uchar* pDest)
    00076 {
    00077     *pDest = pSrc[0];
    00078 }
    00079
    00080 template <>
    00081 inline void ConvertPixel<PXF_A8L8, PXF_A8L8>(const uchar* pSrc, uchar* pDest)
    00082 {
    00083     pDest[0] = pSrc[0];
    00084     pDest[1] = pSrc[1];
    00085 }
    00086
    00087 template <>
    00088 inline void ConvertPixel<PXF_A8L8, PXF_A1R5G5B5>(const uchar* pSrc, uchar* pDest)
    00089 {
    00090     *reinterpret_cast<ushort*>(pDest) = ((pSrc[1] >> 7) << 15) |
    00091                                                ((pSrc[0] >> 3) << 10) |
    00092                                                ((pSrc[0] >> 3) <<  5) |
    00093                                                ((pSrc[0] >> 3) <<  0);
    00094 }
    00095
    00096 template <>
    00097 inline void ConvertPixel<PXF_A8L8, PXF_A4R4G4B4>(const uchar* pSrc, uchar* pDest)
    00098 {
    00099     pDest[0] = (pSrc[0] & 0xF0) | (pSrc[0] >> 4);
    00100     pDest[1] = (pSrc[1] & 0xF0) | (pSrc[0] >> 4);
    00101 }
    00102
    00103 template <>
    00104 inline void ConvertPixel<PXF_A8L8, PXF_R8G8B8>(const uchar* pSrc, uchar* pDest)
    00105 {
    00106     pDest[0] = pSrc[0];
    00107     pDest[1] = pSrc[0];
    00108     pDest[2] = pSrc[0];
    00109 }
    00110
    00111 template <>
    00112 inline void ConvertPixel<PXF_A8L8, PXF_A8R8G8B8>(const uchar* pSrc, uchar* pDest)
    00113 {
    00114     pDest[0] = pSrc[0];
    00115     pDest[1] = pSrc[0];
    00116     pDest[2] = pSrc[0];
    00117     pDest[3] = pSrc[1];
    00118 }
    00119
    00120
    00121 // Specialization for conversions PXF_A1R5G5B5 -> ???
    00122 template <>
    00123 inline void ConvertPixel<PXF_A1R5G5B5, PXF_L8>(const uchar* pSrc, uchar* pDest)
    00124 {
    00125     ushort Pix = *reinterpret_cast<const ushort*>(pSrc);
    00126     *pDest = static_cast<uchar>(((Pix & 0x7C00) >> 7) * 0.30 +
    00127                                        ((Pix & 0x03E0) >> 2) * 0.59 +
    00128                                        ((Pix & 0x001F) << 3) * 0.11);
    00129 }
    00130
    00131 template <>
    00132 inline void ConvertPixel<PXF_A1R5G5B5, PXF_A8L8>(const uchar* pSrc, uchar* pDest)
    00133 {
    00134     ushort Pix = *reinterpret_cast<const ushort*>(pSrc);
    00135     pDest[0] = static_cast<uchar>(((Pix & 0x7C00) >> 7) * 0.30 +
    00136                                          ((Pix & 0x03E0) >> 2) * 0.59 +
    00137                                          ((Pix & 0x001F) << 3) * 0.11);
    00138     pDest[1] = pSrc[1] & 0x8000 ? 0xFF : 0x00;
    00139 }
    00140
    00141 template <>
    00142 inline void ConvertPixel<PXF_A1R5G5B5, PXF_A1R5G5B5>(const uchar* pSrc, uchar* pDest)
    00143 {
    00144     pDest[0] = pSrc[0];
    00145     pDest[1] = pSrc[1];
    00146 }
    00147
    00148 template <>
    00149 inline void ConvertPixel<PXF_A1R5G5B5, PXF_A4R4G4B4>(const uchar* pSrc, uchar* pDest)
    00150 {
    00151     ushort Pix = *reinterpret_cast<const ushort*>(pSrc);
    00152     pDest[1] = (Pix & 0x8000 ? 0xF0 : 0x00) | ((Pix & 0x7C00) >> 11);
    00153     pDest[0] = ((Pix & 0x03C0) >> 2) | ((Pix & 0x001F) >> 1);
    00154 }
    00155
    00156 template <>
    00157 inline void ConvertPixel<PXF_A1R5G5B5, PXF_R8G8B8>(const uchar* pSrc, uchar* pDest)
    00158 {
    00159     ushort Pix = *reinterpret_cast<const ushort*>(pSrc);
    00160     pDest[2] = (Pix & 0x7C00) >> 7;
    00161     pDest[1] = (Pix & 0x03E0) >> 2;
    00162     pDest[0] = (Pix & 0x001F) << 3;
    00163 }
    00164
    00165 template <>
    00166 inline void ConvertPixel<PXF_A1R5G5B5, PXF_A8R8G8B8>(const uchar* pSrc, uchar* pDest)
    00167 {
    00168     ushort Pix = *reinterpret_cast<const ushort*>(pSrc);
    00169     pDest[3] = (Pix & 0x8000) >> 8;
    00170     pDest[2] = (Pix & 0x7C00) >> 7;
    00171     pDest[1] = (Pix & 0x03E0) >> 2;
    00172     pDest[0] = (Pix & 0x001F) << 3;
    00173 }
    00174
    00175 // Specialization for conversions PXF_A4R4G4B4 -> ???
    00176 template <>
    00177 inline void ConvertPixel<PXF_A4R4G4B4, PXF_L8>(const uchar* pSrc, uchar* pDest)
    00178 {
    00179     *pDest = static_cast<uchar>(((pSrc[1] & 0x0F) << 4) * 0.30 +
    00180                                        ((pSrc[0] & 0xF0) >> 0) * 0.59 +
    00181                                        ((pSrc[0] & 0x0F) << 4) * 0.11);
    00182 }
    00183
    00184 template <>
    00185 inline void ConvertPixel<PXF_A4R4G4B4, PXF_A8L8>(const uchar* pSrc, uchar* pDest)
    00186 {
    00187     pDest[0] = static_cast<uchar>(((pSrc[1] & 0x0F) << 4) * 0.30 +
    00188                                          ((pSrc[0] & 0xF0) >> 0) * 0.59 +
    00189                                          ((pSrc[0] & 0x0F) << 4) * 0.11);
    00190     pDest[1] = pSrc[1] & 0xF0;
    00191 }
    00192
    00193 template <>
    00194 inline void ConvertPixel<PXF_A4R4G4B4, PXF_A1R5G5B5>(const uchar* pSrc, uchar* pDest)
    00195 {
    00196     *reinterpret_cast<ushort*>(pDest) = ((pSrc[1] & 0x80) <<  8) |
    00197                                                ((pSrc[1] & 0x0F) << 11) |
    00198                                                ((pSrc[0] & 0xF0) <<  2) |
    00199                                                ((pSrc[0] & 0x0F) <<  1);
    00200 }
    00201
    00202 template <>
    00203 inline void ConvertPixel<PXF_A4R4G4B4, PXF_A4R4G4B4>(const uchar* pSrc, uchar* pDest)
    00204 {
    00205     pDest[0] = pSrc[0];
    00206     pDest[1] = pSrc[1];
    00207 }
    00208
    00209 template <>
    00210 inline void ConvertPixel<PXF_A4R4G4B4, PXF_R8G8B8>(const uchar* pSrc, uchar* pDest)
    00211 {
    00212     pDest[0] = (pSrc[0] & 0x0F) << 4;
    00213     pDest[1] = (pSrc[0] & 0xF0);
    00214     pDest[2] = (pSrc[1] & 0x0F) << 4;
    00215 }
    00216
    00217 template <>
    00218 inline void ConvertPixel<PXF_A4R4G4B4, PXF_A8R8G8B8>(const uchar* pSrc, uchar* pDest)
    00219 {
    00220     pDest[0] = (pSrc[0] & 0x0F) << 4;
    00221     pDest[1] = (pSrc[0] & 0xF0);
    00222     pDest[2] = (pSrc[1] & 0x0F) << 4;
    00223     pDest[3] = (pSrc[1] & 0xF0);
    00224 }
    00225
    00226
    00227 // Specialization for converdions PXF_R8G8B8 -> ???
    00228 template <>
    00229 inline void ConvertPixel<PXF_R8G8B8, PXF_L8>(const uchar* pSrc, uchar* pDest)
    00230 {
    00231     *pDest = static_cast<uchar>(pSrc[2] * 0.30 + pSrc[1] * 0.59 + pSrc[0] * 0.11);
    00232 }
    00233
    00234 template <>
    00235 inline void ConvertPixel<PXF_R8G8B8, PXF_A8L8>(const uchar* pSrc, uchar* pDest)
    00236 {
    00237     pDest[0] = static_cast<uchar>(pSrc[2] * 0.30 + pSrc[1] * 0.59 + pSrc[0] * 0.11);
    00238     pDest[1] = 0xFF;
    00239 }
    00240
    00241 template <>
    00242 inline void ConvertPixel<PXF_R8G8B8, PXF_A1R5G5B5>(const uchar* pSrc, uchar* pDest)
    00243 {
    00244     *reinterpret_cast<ushort*>(pDest) = 0x8000 |
    00245                                                ((pSrc[2] >> 3) << 10) |
    00246                                                ((pSrc[1] >> 3) <<  5) |
    00247                                                ((pSrc[0] >> 3) <<  0);
    00248 }
    00249
    00250 template <>
    00251 inline void ConvertPixel<PXF_R8G8B8, PXF_A4R4G4B4>(const uchar* pSrc, uchar* pDest)
    00252 {
    00253     pDest[0] = (pSrc[1] & 0xF0) | (pSrc[0] >> 4);
    00254     pDest[1] = 0xF0 | (pSrc[2] >> 4);
    00255 }
    00256
    00257 template <>
    00258 inline void ConvertPixel<PXF_R8G8B8, PXF_R8G8B8>(const uchar* pSrc, uchar* pDest)
    00259 {
    00260     pDest[0] = pSrc[0];
    00261     pDest[1] = pSrc[1];
    00262     pDest[2] = pSrc[2];
    00263 }
    00264
    00265 template <>
    00266 inline void ConvertPixel<PXF_R8G8B8, PXF_A8R8G8B8>(const uchar* pSrc, uchar* pDest)
    00267 {
    00268     pDest[0] = pSrc[0];
    00269     pDest[1] = pSrc[1];
    00270     pDest[2] = pSrc[2];
    00271     pDest[3] = 0xFF;
    00272 }
    00273
    00274
    00275 // Specialization for conversions PXF_A8R8G8B8 -> ???
    00276 template <>
    00277 inline void ConvertPixel<PXF_A8R8G8B8, PXF_L8>(const uchar* pSrc, uchar* pDest)
    00278 {
    00279     *pDest = static_cast<uchar>(pSrc[2] * 0.30 + pSrc[1] * 0.59 + pSrc[0] * 0.11);
    00280 }
    00281
    00282 template <>
    00283 inline void ConvertPixel<PXF_A8R8G8B8, PXF_A8L8>(const uchar* pSrc, uchar* pDest)
    00284 {
    00285     pDest[0] = static_cast<uchar>(pSrc[2] * 0.30 + pSrc[1] * 0.59 + pSrc[0] * 0.11);
    00286     pDest[1] = pSrc[3];
    00287 }
    00288
    00289 template <>
    00290 inline void ConvertPixel<PXF_A8R8G8B8, PXF_A1R5G5B5>(const uchar* pSrc, uchar* pDest)
    00291 {
    00292     *reinterpret_cast<ushort*>(pDest) = ((pSrc[3] >> 7) << 15) |
    00293                                                ((pSrc[2] >> 3) << 10) |
    00294                                                ((pSrc[1] >> 3) <<  5) |
    00295                                                ((pSrc[0] >> 3) <<  0);
    00296 }
    00297
    00298 template <>
    00299 inline void ConvertPixel<PXF_A8R8G8B8, PXF_A4R4G4B4>(const uchar* pSrc, uchar* pDest)
    00300 {
    00301     pDest[0] = (pSrc[1] & 0xF0) | (pSrc[0] >> 4);
    00302     pDest[1] = (pSrc[3] & 0xF0) | (pSrc[2] >> 4);
    00303 }
    00304
    00305 template <>
    00306 inline void ConvertPixel<PXF_A8R8G8B8, PXF_R8G8B8>(const uchar* pSrc, uchar* pDest)
    00307 {
    00308     pDest[0] = pSrc[0];
    00309     pDest[1] = pSrc[1];
    00310     pDest[2] = pSrc[2];
    00311 }
    00312
    00313 template <>
    00314 inline void ConvertPixel<PXF_A8R8G8B8, PXF_A8R8G8B8>(const uchar* pSrc, uchar* pDest)
    00315 {
    00316     pDest[0] = pSrc[0];
    00317     pDest[1] = pSrc[1];
    00318     pDest[2] = pSrc[2];
    00319     pDest[3] = pSrc[3];
    00320 }