← Back to branch summary

~cosme/ubuntu/precise/freeimage/freeimage-3.15.1

« back to all changes in this revision

Viewing changes to Source/FreeImage/Conversion16_565.cpp

  • Committer: Stefano Rivera
  • Date: 2010-07-24 15:35:51 UTC
  • mto: This revision was merged to the branch mainline in revision 5.
  • Revision ID: stefanor@ubuntu.com-20100724153551-6s3fth1653huk31a
Tags: upstream-3.13.1
Import upstream version 3.31.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/FreeImage/Conversion16_565.cpp
25
25
#include "Utilities.h"
26
26
 
27
27
// ----------------------------------------------------------
28
 
 
29
 
#define RGB565(b, g, r) ((((b) >> 3) << FI16_565_BLUE_SHIFT) | (((g) >> 2) << FI16_565_GREEN_SHIFT) | (((r) >> 3) << FI16_565_RED_SHIFT))
30
 
 
31
 
// ----------------------------------------------------------
32
28
//  internal conversions X to 16 bits (565)
33
29
// ----------------------------------------------------------
34
30
 
115
111
 
116
112
FIBITMAP * DLL_CALLCONV
117
113
FreeImage_ConvertTo16Bits565(FIBITMAP *dib) {
118
 
        if(!dib) return NULL;
119
 
 
120
 
        int width = FreeImage_GetWidth(dib);
121
 
        int height = FreeImage_GetHeight(dib);
122
 
 
123
 
        switch (FreeImage_GetBPP(dib)) {
124
 
                case 1 :
125
 
                {
 
114
        if(!dib || (FreeImage_GetImageType(dib) != FIT_BITMAP)) return NULL;
 
115
 
 
116
        const int width = FreeImage_GetWidth(dib);
 
117
        const int height = FreeImage_GetHeight(dib);
 
118
        const int bpp = FreeImage_GetBPP(dib);
 
119
 
 
120
        if(bpp == 16) {
 
121
                if ((FreeImage_GetRedMask(dib) == FI16_555_RED_MASK) && (FreeImage_GetGreenMask(dib) == FI16_555_GREEN_MASK) && (FreeImage_GetBlueMask(dib) == FI16_555_BLUE_MASK)) {
 
122
                        // RGB 555
126
123
                        FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, FI16_565_RED_MASK, FI16_565_GREEN_MASK, FI16_565_BLUE_MASK);
127
 
 
128
 
                        if (new_dib) {
129
 
                                for (int rows = 0; rows < height; rows++)
 
124
                        if(new_dib == NULL) {
 
125
                                return NULL;
 
126
                        }
 
127
                        for (int rows = 0; rows < height; rows++) {
 
128
                                FreeImage_ConvertLine16_555_To16_565(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
 
129
                        }
 
130
 
 
131
                        // copy metadata from src to dst
 
132
                        FreeImage_CloneMetadata(new_dib, dib);
 
133
 
 
134
                        return new_dib;
 
135
                } else {
 
136
                        // RGB 565
 
137
                        return FreeImage_Clone(dib);
 
138
                }
 
139
        }
 
140
        else {
 
141
                // other bpp cases => convert to RGB 565
 
142
                FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, FI16_565_RED_MASK, FI16_565_GREEN_MASK, FI16_565_BLUE_MASK);
 
143
                if(new_dib == NULL) {
 
144
                        return NULL;
 
145
                }
 
146
 
 
147
                // copy metadata from src to dst
 
148
                FreeImage_CloneMetadata(new_dib, dib);
 
149
 
 
150
                switch (bpp) {
 
151
                        case 1 :
 
152
                        {
 
153
                                for (int rows = 0; rows < height; rows++) {
130
154
                                        FreeImage_ConvertLine1To16_565(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width, FreeImage_GetPalette(dib));
131
 
                                                                        
 
155
                                }
 
156
 
132
157
                                return new_dib;
133
158
                        }
134
159
 
135
 
                        break;
136
 
                }
137
 
 
138
 
                case 4 :
139
 
                {
140
 
                        FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, FI16_565_RED_MASK, FI16_565_GREEN_MASK, FI16_565_BLUE_MASK);
141
 
 
142
 
                        if (new_dib) {
143
 
                                for (int rows = 0; rows < height; rows++)
 
160
                        case 4 :
 
161
                        {
 
162
                                for (int rows = 0; rows < height; rows++) {
144
163
                                        FreeImage_ConvertLine4To16_565(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width, FreeImage_GetPalette(dib));
145
 
                                
 
164
                                }
 
165
 
146
166
                                return new_dib;
147
167
                        }
148
168
 
149
 
                        break;
150
 
                }
151
 
 
152
 
                case 8 :
153
 
                {
154
 
                        FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, FI16_565_RED_MASK, FI16_565_GREEN_MASK, FI16_565_BLUE_MASK);
155
 
 
156
 
                        if (new_dib) {
157
 
                                for (int rows = 0; rows < height; rows++)
 
169
                        case 8 :
 
170
                        {
 
171
                                for (int rows = 0; rows < height; rows++) {
158
172
                                        FreeImage_ConvertLine8To16_565(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width, FreeImage_GetPalette(dib));
159
 
                                
160
 
                                return new_dib;
161
 
                        }
162
 
 
163
 
                        break;
164
 
                }
165
 
 
166
 
                case 16 :
167
 
                {
168
 
                        if ((FreeImage_GetRedMask(dib) == FI16_565_RED_MASK) && (FreeImage_GetGreenMask(dib) == FI16_565_GREEN_MASK) && (FreeImage_GetBlueMask(dib) == FI16_565_BLUE_MASK)) {
169
 
                                break; //jump down to the clone line
170
 
                        }
171
 
 
172
 
                        FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, FI16_565_RED_MASK, FI16_565_GREEN_MASK, FI16_565_BLUE_MASK);
173
 
 
174
 
                        if (new_dib) {
175
 
                                for (int rows = 0; rows < height; rows++)
176
 
                                        FreeImage_ConvertLine16_555_To16_565(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
177
 
                                
178
 
                                return new_dib;
179
 
                        }
180
 
 
181
 
                        break;
182
 
                }
183
 
 
184
 
                case 24 :
185
 
                {
186
 
                        FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, FI16_565_RED_MASK, FI16_565_GREEN_MASK, FI16_565_BLUE_MASK);
187
 
 
188
 
                        if (new_dib) {
189
 
                                for (int rows = 0; rows < height; rows++)
 
173
                                }
 
174
 
 
175
                                return new_dib;
 
176
                        }
 
177
 
 
178
                        case 24 :
 
179
                        {
 
180
                                for (int rows = 0; rows < height; rows++) {
190
181
                                        FreeImage_ConvertLine24To16_565(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
191
 
                                
 
182
                                }
 
183
 
192
184
                                return new_dib;
193
185
                        }
194
186
 
195
 
                        break;
196
 
                }
197
 
 
198
 
                case 32 :
199
 
                {
200
 
                        FIBITMAP *new_dib = FreeImage_Allocate(width, height, 16, FI16_565_RED_MASK, FI16_565_GREEN_MASK, FI16_565_BLUE_MASK);
201
 
 
202
 
                        if (new_dib) {
203
 
                                for (int rows = 0; rows < height; rows++)
 
187
                        case 32 :
 
188
                        {
 
189
                                for (int rows = 0; rows < height; rows++) {
204
190
                                        FreeImage_ConvertLine32To16_565(FreeImage_GetScanLine(new_dib, rows), FreeImage_GetScanLine(dib, rows), width);
205
 
                                
 
191
                                }
 
192
 
206
193
                                return new_dib;
207
194
                        }
208
195
 
209
 
                        break;
 
196
                        default :
 
197
                                // unreachable code ...
 
198
                                FreeImage_Unload(new_dib);
 
199
                                break;
210
200
                }
211
201
        }
212
202
 
213
 
        return FreeImage_Clone(dib);
 
203
        return NULL;
214
204
}