1

/* $Id$ */

     2

     3

/** @file bmp.cpp */

     4

     5

#include "stdafx.h"

     6

#include "bmp.h"

     9

    10

void BmpInitializeBuffer(BmpBuffer *buffer, FILE *file)

    11

{

    12

	buffer->pos      = -1;

    13

	buffer->file     = file;

    14

	buffer->read     = 0;

    15

	buffer->real_pos = ftell(file);

    16

}

    17

    18

static inline void AdvanceBuffer(BmpBuffer *buffer)

    19

{

    20

	buffer->read = (int)fread(buffer->data, 1, BMP_BUFFER_SIZE, buffer->file);

    21

	buffer->pos  = 0;

    22

}

    23

    24

static inline bool EndOfBuffer(BmpBuffer *buffer)

    25

{

    26

	if (buffer->pos == buffer->read || buffer->pos < 0) AdvanceBuffer(buffer);

    27

	return buffer->pos == buffer->read;

    28

}

    29

    30

static inline byte ReadByte(BmpBuffer *buffer)

    31

{

    32

	if (buffer->pos == buffer->read || buffer->pos < 0) AdvanceBuffer(buffer);

    33

	buffer->real_pos++;

    34

	return buffer->data[buffer->pos++];

    35

}

    36

    37

static inline uint16 ReadWord(BmpBuffer *buffer)

    38

{

    39

	uint16 var = ReadByte(buffer);

    40

	return var | (ReadByte(buffer) << 8);

    41

}

    42

    43

static inline uint32 ReadDword(BmpBuffer *buffer)

    44

{

    45

	uint32 var = ReadWord(buffer);

    46

	return var | (ReadWord(buffer) << 16);

    47

}

    48

    49

static inline void SkipBytes(BmpBuffer *buffer, int bytes)

    50

{

    51

	int i;

    52

	for (i = 0; i < bytes; i++) ReadByte(buffer);

    53

}

    54

    55

static inline void SetStreamOffset(BmpBuffer *buffer, int offset)

    56

{

    57

	fseek(buffer->file, offset, SEEK_SET);

    58

	buffer->pos = -1;

    59

	buffer->real_pos = offset;

    60

	AdvanceBuffer(buffer);

    61

}

    62

    63

/**

    64

 * Reads a 1 bpp uncompressed bitmap

    65

 * The bitmap is converted to a 8 bpp bitmap

    66

 */

    67

static inline bool BmpRead1(BmpBuffer *buffer, BmpInfo *info, BmpData *data)

    68

{

    69

	uint x, y, i;

    70

	byte pad = GB(4 - info->width / 8, 0, 2);

    71

	byte *pixel_row;

    72

	byte b;

    73

	for (y = info->height; y > 0; y--) {

    74

		x = 0;

    75

		pixel_row = &data->bitmap[(y - 1) * info->width];

    76

		while (x < info->width) {

    77

			if (EndOfBuffer(buffer)) return false; // the file is shorter than expected

    78

			b = ReadByte(buffer);

    79

			for (i = 8; i > 0; i--) {

    80

				if (x < info->width) *pixel_row++ = GB(b, i - 1, 1);

    81

				x++;

    82

			}

    83

		}

    84

		/* Padding for 32 bit align */

    85

		SkipBytes(buffer, pad);

    86

	}

    87

	return true;

    88

}

    89

    90

/**

    91

 * Reads a 4 bpp uncompressed bitmap

    92

 * The bitmap is converted to a 8 bpp bitmap

    93

 */

    94

static inline bool BmpRead4(BmpBuffer *buffer, BmpInfo *info, BmpData *data)

    95

{

    96

	uint x, y;

    97

	byte pad = GB(4 - info->width / 2, 0, 2);

    98

	byte *pixel_row;

    99

	byte b;

   100

	for (y = info->height; y > 0; y--) {

   101

		x = 0;

   102

		pixel_row = &data->bitmap[(y - 1) * info->width];

   103

		while (x < info->width) {

   104

			if (EndOfBuffer(buffer)) return false;  // the file is shorter than expected

   105

			b = ReadByte(buffer);

   106

			*pixel_row++ = GB(b, 4, 4);

   107

			x++;

   108

			if (x < info->width) {

   109

				*pixel_row++ = GB(b, 0, 4);

   110

				x++;

   111

			}

   112

		}

   113

		/* Padding for 32 bit align */

   114

		SkipBytes(buffer, pad);

   115

	}

   116

	return true;

   117

}

   118

   119

/**

   120

 * Reads a 4-bit RLE compressed bitmap

   121

 * The bitmap is converted to a 8 bpp bitmap

   122

 */

   123

static inline bool BmpRead4Rle(BmpBuffer *buffer, BmpInfo *info, BmpData *data)

   124

{

   125

	uint i;

   126

	uint x = 0;

   127

	uint y = info->height - 1;

   128

	byte n, c, b;

   129

	byte *pixel = &data->bitmap[y * info->width];

   130

	while (y != 0 || x < info->width) {

   131

		if (EndOfBuffer(buffer)) return false; // the file is shorter than expected

   132

		n = ReadByte(buffer);

   133

		c = ReadByte(buffer);

   134

		if (n == 0) {

   135

			switch (c) {

   136

			case 0: // end of line

   137

				x = 0;

   138

				pixel = &data->bitmap[--y * info->width];

   139

				break;

   140

			case 1: // end of bitmap

   141

				x = info->width;

   142

				y = 0;

   143

				pixel = NULL;

   144

				break;

   145

			case 2: // delta

   146

				x += ReadByte(buffer);

   147

				i = ReadByte(buffer);

   148

				if (x >= info->width || (y == 0 && i > 0)) return false;

   149

				y -= i;

   150

				pixel = &data->bitmap[y * info->width + x];

   151

				break;

   152

			default: // uncompressed

   153

				i = 0;

   154

				while (i++ < c) {

   155

					if (EndOfBuffer(buffer) || x >= info->width) return false;

   156

					b = ReadByte(buffer);

   157

					*pixel++ = GB(b, 4, 4);

   158

					x++;

   159

					if (x < info->width && i++ < c) {

   160

						*pixel++ = GB(b, 0, 4);

   161

						x++;

   162

					}

   163

				}

   164

				/* Padding for 16 bit align */

   165

				SkipBytes(buffer, ((c + 1) / 2) % 2);

   166

				break;

   167

			}

   168

		} else {

   169

			i = 0;

   170

			while (i++ < n) {

   171

				if (EndOfBuffer(buffer) || x >= info->width) return false;

   172

				*pixel++ = GB(c, 4, 4);

   173

				x++;

   174

				if (x < info->width && i++ < n) {

   175

					*pixel++ = GB(c, 0, 4);

   176

					x++;

   177

				}

   178

			}

   179

		}

   180

	}

   181

	return true;

   182

}

   183

   184

/**

   185

 * Reads a 8 bpp bitmap

   186

 */

   187

static inline bool BmpRead8(BmpBuffer *buffer, BmpInfo *info, BmpData *data)

   188

{

   189

	uint i;

   190

	uint y;

   191

	byte pad = GB(4 - info->width, 0, 2);

   192

	byte *pixel;

   193

	for (y = info->height; y > 0; y--) {

   194

		if (EndOfBuffer(buffer)) return false; // the file is shorter than expected

   195

		pixel = &data->bitmap[(y - 1) * info->width];

   196

		for (i = 0; i < info->width; i++) *pixel++ = ReadByte(buffer);

   197

		/* Padding for 32 bit align */

   198

		SkipBytes(buffer, pad);

   199

	}

   200

	return true;

   201

}

   202

   203

/**

   204

 * Reads a 8-bit RLE compressed bpp bitmap

   205

 */

   206

static inline bool BmpRead8Rle(BmpBuffer *buffer, BmpInfo *info, BmpData *data)

   207

{

   208

	uint i;

   209

	uint x = 0;

   210

	uint y = info->height - 1;

   211

	byte n, c;

   212

	byte *pixel = &data->bitmap[y * info->width];

   213

	while (y != 0 || x < info->width) {

   214

		if (EndOfBuffer(buffer)) return false; // the file is shorter than expected

   215

		n = ReadByte(buffer);

   216

		c = ReadByte(buffer);

   217

		if (n == 0) {

   218

			switch (c) {

   219

			case 0: // end of line

   220

				x = 0;

   221

				pixel = &data->bitmap[--y * info->width];

   222

				break;

   223

			case 1: // end of bitmap

   224

				x = info->width;

   225

				y = 0;

   226

				pixel = NULL;

   227

				break;

   228

			case 2: // delta

   229

				x += ReadByte(buffer);

   230

				i = ReadByte(buffer);

   231

				if (x >= info->width || (y == 0 && i > 0)) return false;

   232

				y -= i;

   233

				pixel = &data->bitmap[y * info->width + x];

   234

				break;

   235

			default: // uncompressed

   236

				if ((x += c) > info->width) return false;

   237

				for (i = 0; i < c; i++) *pixel++ = ReadByte(buffer);

   238

				/* Padding for 16 bit align */

   239

				SkipBytes(buffer, c % 2);

   240

				break;

   241

			}

   242

		} else {

   243

			for (i = 0; i < n; i++) {

   244

				if (x >= info->width) return false;

   245

				*pixel++ = c;

   246

				x++;

   247

			}

   248

		}

   249

	}

   250

	return true;

   251

}

   252

   253

/**

   254

 * Reads a 24 bpp uncompressed bitmap

   255

 */

   256

static inline bool BmpRead24(BmpBuffer *buffer, BmpInfo *info, BmpData *data)

   257

{

   258

	uint x, y;

   259

	byte pad = GB(4 - info->width * 3, 0, 2);

   260

	byte *pixel_row;

   261

	for (y = info->height; y > 0; y--) {

   262

		pixel_row = &data->bitmap[(y - 1) * info->width * 3];

   263

		for (x = 0; x < info->width; x++) {

   264

			if (EndOfBuffer(buffer)) return false; // the file is shorter than expected

   265

			*(pixel_row + 2) = ReadByte(buffer); // green

   266

			*(pixel_row + 1) = ReadByte(buffer); // blue

   267

			*pixel_row       = ReadByte(buffer); // red

   268

			pixel_row += 3;

   269

		}

   270

		/* Padding for 32 bit align */

   271

		SkipBytes(buffer, pad);

   272

	}

   273

	return true;

   274

}

   275

   276

/*

   277

 * Reads bitmap headers, and palette (if any)

   278

 */

   279

bool BmpReadHeader(BmpBuffer *buffer, BmpInfo *info, BmpData *data)

   280

{

   281

	uint32 header_size;

   282

	assert(info != NULL);

   283

   284

	/* Reading BMP header */

   285

	if (ReadWord(buffer) != 0x4D42) return false; // signature should be 'BM'

   286

	SkipBytes(buffer, 8); // skip file size and reserved

   287

	info->offset = ReadDword(buffer);

   288

   289

	/* Reading info header */

   290

	header_size = ReadDword(buffer);

   291

	if (header_size < 12) return false; // info header should be at least 12 bytes long

   292

   293

	info->os2_bmp = (header_size == 12); // OS/2 1.x or windows 2.x info header is 12 bytes long

   294

   295

	if (info->os2_bmp) {

   296

		info->width = ReadWord(buffer);

   297

		info->height = ReadWord(buffer);

   298

		header_size -= 8;

   299

	} else {

   300

		info->width = ReadDword(buffer);

   301

		info->height = ReadDword(buffer);

   302

		header_size -= 12;

   303

	}

   304

   305

	if (ReadWord(buffer) != 1) return false; // BMP can have only 1 plane

   306

   307

	info->bpp = ReadWord(buffer);

   308

	if (info->bpp != 1 && info->bpp != 4 && info->bpp != 8 && info->bpp != 24) {

   309

		/* Only 1 bpp, 4 bpp, 8bpp and 24 bpp bitmaps are supported */

   310

		return false;

   311

	}

   312

   313

	/* Reads compression method if available in info header*/

   314

	if ((header_size -= 4) >= 4) {

   315

		info->compression = ReadDword(buffer);

   316

		header_size -= 4;

   317

	}

   318

   319

	/* Only 4-bit and 8-bit rle compression is supported */

   320

	if (info->compression > 2 || (info->compression > 0 && !(info->bpp == 4 || info->bpp == 8))) return false;

   321

   322

	if (info->bpp <= 8) {

   323

		uint i;

   324

   325

		/* Reads number of colors if available in info header */

   326

		if (header_size >= 16) {

   327

			SkipBytes(buffer, 12);                  // skip image size and resolution

   328

			info->palette_size = ReadDword(buffer); // number of colors in palette

   329

			SkipBytes(buffer, header_size - 16);    // skip the end of info header

   330

		}

   331

		if (info->palette_size == 0) info->palette_size = 1 << info->bpp;

   332

   333

		data->palette = CallocT<Colour>(info->palette_size);

   334

		if (data->palette == NULL) return false;

   335

   336

		for (i = 0; i < info->palette_size; i++) {

   337

			data->palette[i].b = ReadByte(buffer);

   338

			data->palette[i].g = ReadByte(buffer);

   339

			data->palette[i].r = ReadByte(buffer);

   340

			if (!info->os2_bmp) SkipBytes(buffer, 1); // unused

   341

		}

   342

	}

   343

   344

	return buffer->real_pos <= info->offset;

   345

}

   346

   347

/*

   348

 * Reads the bitmap

   349

 * 1 bpp and 4 bpp bitmaps are converted to 8 bpp bitmaps

   350

 */

   351

bool BmpReadBitmap(BmpBuffer *buffer, BmpInfo *info, BmpData *data)

   352

{

   353

	assert(info != NULL && data != NULL);

   354

   356

	if (data->bitmap == NULL) return false;

   357

   358

	/* Load image */

   359

	SetStreamOffset(buffer, info->offset);

   360

	switch (info->compression) {

   361

	case 0: // no compression

   362

		switch (info->bpp) {

   363

		case 1:  return BmpRead1(buffer, info, data);

   364

		case 4:  return BmpRead4(buffer, info, data);

   365

		case 8:  return BmpRead8(buffer, info, data);

   366

		case 24: return BmpRead24(buffer, info, data);

   367

		default: NOT_REACHED(); return false;

   368

		}

   369

	case 1:  return BmpRead8Rle(buffer, info, data); // 8-bit RLE compression

   370

	case 2:  return BmpRead4Rle(buffer, info, data); // 4-bit RLE compression

   371

	default: NOT_REACHED(); return false;

   372

	}

   373

}

   374

   375

void BmpDestroyData(BmpData *data)

   376

{

   377

	assert(data != NULL);

   378

	free(data->palette);

   379

	free(data->bitmap);

   380

}