vcs.maemo.org Git - opencv/blob - otherlibs/cvcam/src/unix/convert.cpp

   1 /*M///////////////////////////////////////////////////////////////////////////////////////
   2 //
   3 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
   4 //
   5 //  By downloading, copying, installing or using the software you agree to this license.
   6 //  If you do not agree to this license, do not download, install,
   7 //  copy or use the software.
   8 //
   9 //
  10 //                        Intel License Agreement
  11 //                For Open Source Computer Vision Library
  12 //
  13 // Copyright (C) 2000, Intel Corporation, all rights reserved.
  14 // Third party copyrights are property of their respective owners.
  15 //
  16 // Redistribution and use in source and binary forms, with or without modification,
  17 // are permitted provided that the following conditions are met:
  18 //
  19 //   * Redistribution's of source code must retain the above copyright notice,
  20 //     this list of conditions and the following disclaimer.
  21 //
  22 //   * Redistribution's in binary form must reproduce the above copyright notice,
  23 //     this list of conditions and the following disclaimer in the documentation
  24 //     and/or other materials provided with the distribution.
  25 //
  26 //   * The name of Intel Corporation may not be used to endorse or promote products
  27 //     derived from this software without specific prior written permission.
  28 //
  29 // This software is provided by the copyright holders and contributors "as is" and
  30 // any express or implied warranties, including, but not limited to, the implied
  31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
  32 // In no event shall the Intel Corporation or contributors be liable for any direct,
  33 // indirect, incidental, special, exemplary, or consequential damages
  34 // (including, but not limited to, procurement of substitute goods or services;
  35 // loss of use, data, or profits; or business interruption) however caused
  36 // and on any theory of liability, whether in contract, strict liability,
  37 // or tort (including negligence or otherwise) arising in any way out of
  38 // the use of this software, even if advised of the possibility of such damage.
  39 //
  40 //M*/
  41 #include "convert.h"
  42 #include <assert.h>
  43 #include <string.h>
  44
  45 #define Assert assert
  46
  47 /* converting image from depths 8, 24, 32 to 8, 16, 24, 32 */
  48
  49 void icvvConvert( int w, int h, int src_s, int src_d, char* src,
  50                          int dst_s, int dst_d, char* dst )
  51 {
  52     int x;
  53     int y;
  54     int x3;
  55     unsigned short val;
  56     unsigned short v1;
  57     unsigned short v2;
  58     unsigned short v3;
  59
  60     Assert( w > 0 );
  61     Assert( h > 0 );
  62     Assert( src_s >= w * src_d / 8 );
  63     Assert( dst_s >= w * dst_d / 8 );
  64     Assert( src );
  65     Assert( dst );
  66
  67     switch(src_d)
  68     {
  69         case 8:
  70             switch(dst_d)
  71             {
  72                 case 8:
  73                     for( y = 0; y < h; y++, src += src_s, dst+= dst_s )
  74                         memcpy( dst, src, w );
  75                     break;
  76                 case 16:
  77                     for( y = 0; y < h; y++, src += src_s, dst += dst_s )
  78                         for( x = 0; x < w; x++ )
  79                         {
  80                             val = (unsigned char)src[x];
  81                             *(unsigned short*)(dst + x * 2) = ((val & ~3) << 3) +
  82                                                                (val >> 3) +
  83                                                                ((val & ~7) << 8);
  84                         }
  85                     break;
  86                 case 24:
  87                     for( y = 0; y < h; y++, src += src_s, dst += dst_s )
  88                         for( x = 0, x3 = 0; x < w; x++, x3 += 3 )
  89                             dst[x3] = dst[x3 + 1] = dst[x3 + 2] = src[x];
  90                     break;
  91                 case 32:
  92                     for( y = 0; y < h; y++, src += src_s, dst += dst_s )
  93                         for( x = 0; x < w; x++ )
  94                         {
  95                             dst[x * 4] = dst[x * 4 + 1] = dst[x * 4 + 2] = src[x];
  96                             dst[x * 4 + 3] = 0;
  97                         }
  98                     break;
  99             }
 100             break;
 101
 102         case 24:
 103             switch(dst_d)
 104             {
 105                 case 8:
 106                     for( y = 0; y < h; y++, src += src_s, dst+= dst_s )
 107                         for(  x = 0, x3 = 0; x < w; x++, x3 += 3 )
 108                             dst[x] = (src[x3] + src[x3 + 1] + src[x3 + 2]) / 3;
 109                     break;
 110                 case 16:
 111                     for( y = 0; y < h; y++, src += src_s, dst += dst_s )
 112                         for( x = 0, x3 = 0; x < w; x++, x3 += 3 )
 113                         {
 114                             v1 = (unsigned char)src[x3];
 115                             v2 = (unsigned char)src[x3 + 1];
 116                             v3 = (unsigned char)src[x3 + 2];
 117                             ((unsigned short*)(dst))[x] = (v1 >> 3) +
 118                                                          ((v2 & ~3) << 3) +
 119                                                          ((v3 & ~7) << 8);
 120                         }
 121                     break;
 122                 case 24:
 123                     for( y = 0; y < h; y++, src += src_s, dst+= dst_s )
 124                         memcpy( dst, src, w * 3 );
 125                     break;
 126                 case 32:
 127                     for( y = 0; y < h; y++, src += src_s, dst += dst_s )
 128                         for( x = 0, x3 = 0; x < w; x++, x3 += 3 )
 129                         {
 130                             dst[x * 4] = src[x3];
 131                             dst[x * 4 + 1] = src[x3 + 1];
 132                             dst[x * 4 + 2] = src[x3 + 2];
 133                             dst[x * 4 + 3] = 0;
 134                         }
 135                     break;
 136             }
 137             break;
 138
 139         case 32:
 140             switch(dst_d)
 141             {
 142                 case 8:
 143                     for( y = 0; y < h; y++, src += src_s, dst+= dst_s )
 144                         for( x = 0; x < w; x++ )
 145                             dst[x] = (src[x * 4] + src[x * 4 + 1] + src[x * 4 + 2]) / 3;
 146                     break;
 147                 case 16:
 148                     for( y = 0; y < h; y++, src += src_s, dst += dst_s )
 149                         for( x = 0; x < w; x++ )
 150                         {
 151                             v1 = (unsigned char)src[x * 4];
 152                             v2 = (unsigned char)src[x * 4 + 1];
 153                             v3 = (unsigned char)src[x * 4 + 2];
 154                             ((unsigned short*)(dst))[x] = (v1 >> 3) + ((v2 & ~3) << 3) + ((v3 & ~7) << 8);
 155                         }
 156                     break;
 157                 case 24:
 158                     for( y = 0; y < h; y++, src += src_s, dst += dst_s )
 159                         for( x = 0, x3 = 0; x < w; x++, x3 += 3 )
 160                         {
 161                             dst[x3]     = src[x * 4];
 162                             dst[x3 + 1] = src[x * 4 + 1];
 163                             dst[x3 + 2] = src[x * 4 + 2];
 164                         }
 165                     break;
 166                 case 32:
 167                     for( y = 0; y < h; y++, src += src_s, dst+= dst_s )
 168                         memcpy( dst, src, w * 4 );
 169                     break;
 170             }
 171             break;
 172
 173         default:
 174             return;
 175     }
 176 }
 177