1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "gfx.h"

     6

#include "bmp.h"

     7

#include "macros.h"

     8

     9

void BmpInitializeBuffer(BmpBuffer *buffer, FILE *file) {

    10

	buffer->pos      = -1;

    11

	buffer->file     = file;

    12

	buffer->read     = 0;

    13

	buffer->real_pos = ftell(file);

    14

}

    15

    16

static inline void AdvanceBuffer(BmpBuffer *buffer)

    17

{

    18

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

    19

	buffer->pos  = 0;

    20

}

    21

    22

static inline bool EndOfBuffer(BmpBuffer *buffer)

    23

{

    24

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

    25

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

    26

}

    27

    28

static inline byte ReadByte(BmpBuffer *buffer)

    29

{

    30

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

    31

	buffer->real_pos++;

    32

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

    33

}

    34

    35

static inline uint16 ReadWord(BmpBuffer *buffer)

    36

{

    37

	uint16 var = ReadByte(buffer);

    38

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

    39

}

    40

    41

static inline uint32 ReadDword(BmpBuffer *buffer)

    42

{

    43

	uint32 var = ReadWord(buffer);

    44

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

    45

}

    46

    47

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

    48

{

    49

	int i;

    50

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

    51

}

    52

    53

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

    54

{

    55

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

    56

	buffer->pos = -1;

    57

	buffer->real_pos = offset;

    58

	AdvanceBuffer(buffer);

    59

}

    60

    61

/**

    62

 * Reads a 1 bpp uncompressed bitmap

    63

 * The bitmap is converted to a 8 bpp bitmap

    64

 */

    65

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

    66

{

    67

	uint x, y, i;

    68

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

    69

	byte *pixel_row;

    70

	byte b;

    71

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

    72

		x = 0;

    73

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

    74

		while (x < info->width) {

    75

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

    76

			b = ReadByte(buffer);

    77

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

    78

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

    79

				x++;

    80

			}

    81

		}

    82

		/* Padding for 32 bit align */

    83

		SkipBytes(buffer, pad);

    84

	}

    85

	return true;

    86

}

    87

    88

/**

    89

 * Reads a 4 bpp uncompressed bitmap

    90

 * The bitmap is converted to a 8 bpp bitmap

    91

 */

    92

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

    93

{

    94

	uint x, y;

    95

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

    96

	byte *pixel_row;

    97

	byte b;

    98

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

    99

		x = 0;

   100

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

   101

		while (x < info->width) {

   102

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

   103

			b = ReadByte(buffer);

   104

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

   105

			x++;

   106

			if (x < info->width) {

   107

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

   108

				x++;

   109

			}

   110

		}

   111

		/* Padding for 32 bit align */

   112

		SkipBytes(buffer, pad);

   113

	}

   114

	return true;

   115

}

   116

   117

/**

   118

 * Reads a 4-bit RLE compressed bitmap

   119

 * The bitmap is converted to a 8 bpp bitmap

   120

 */

   121

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

   122

{

   123

	uint i;

   124

	uint x = 0;

   125

	uint y = info->height - 1;

   126

	byte n, c, b;

   127

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

   128

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

   129

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

   130

		n = ReadByte(buffer);

   131

		c = ReadByte(buffer);

   132

		if (n == 0) {

   133

			switch (c) {

   134

			case 0: // end of line

   135

				x = 0;

   136

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

   137

				break;

   138

			case 1: // end of bitmap

   139

				x = info->width;

   140

				y = 0;

   141

				pixel = NULL;

   142

				break;

   143

			case 2: // delta

   144

				x += ReadByte(buffer);

   145

				i = ReadByte(buffer);

   146

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

   147

				y -= i;

   148

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

   149

				break;

   150

			default: // uncompressed

   151

				i = 0;

   152

				while (i++ < c) {

   153

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

   154

					b = ReadByte(buffer);

   155

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

   156

					x++;

   157

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

   158

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

   159

						x++;

   160

					}

   161

				}

   162

				/* Padding for 16 bit align */

   163

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

   164

				break;

   165

			}

   166

		} else {

   167

			i = 0;

   168

			while (i++ < n) {

   169

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

   170

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

   171

				x++;

   172

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

   173

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

   174

					x++;

   175

				}

   176

			}

   177

		}

   178

	}

   179

	return true;

   180

}

   181

   182

/**

   183

 * Reads a 8 bpp bitmap

   184

 */

   185

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

   186

{

   187

	uint i;

   188

	uint y;

   189

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

   190

	byte *pixel;

   191

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

   192

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

   193

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

   194

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

   195

		/* Padding for 32 bit align */

   196

		SkipBytes(buffer, pad);

   197

	}

   198

	return true;

   199

}

   200

   201

/**

   202

 * Reads a 8-bit RLE compressed bpp bitmap

   203

 */

   204

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

   205

{

   206

	uint i;

   207

	uint x = 0;

   208

	uint y = info->height - 1;

   209

	byte n, c;

   210

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

   211

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

   212

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

   213

		n = ReadByte(buffer);

   214

		c = ReadByte(buffer);

   215

		if (n == 0) {

   216

			switch (c) {

   217

			case 0: // end of line

   218

				x = 0;

   219

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

   220

				break;

   221

			case 1: // end of bitmap

   222

				x = info->width;

   223

				y = 0;

   224

				pixel = NULL;

   225

				break;

   226

			case 2: // delta

   227

				x += ReadByte(buffer);

   228

				i = ReadByte(buffer);

   229

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

   230

				y -= i;

   231

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

   232

				break;

   233

			default: // uncompressed

   234

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

   235

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

   236

				/* Padding for 16 bit align */

   237

				SkipBytes(buffer, c % 2);

   238

				break;

   239

			}

   240

		} else {

   241

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

   242

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

   243

				*pixel++ = c;

   244

				x++;

   245

			}

   246

		}

   247

	}

   248

	return true;

   249

}

   250

   251

/**

   252

 * Reads a 24 bpp uncompressed bitmap

   253

 */

   254

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

   255

{

   256

	uint x, y;

   257

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

   258

	byte *pixel_row;

   259

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

   260

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

   261

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

   262

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

   263

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

   264

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

   265

			*pixel_row       = ReadByte(buffer); // red

   266

			pixel_row += 3;

   267

		}

   268

		/* Padding for 32 bit align */

   269

		SkipBytes(buffer, pad);

   270

	}

   271

	return true;

   272

}

   273

   274

/*

   275

 * Reads bitmap headers, and palette (if any)

   276

 */

   277

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

   278

{

   279

	uint32 header_size;

   280

	assert(info != NULL);

   281

   282

	/* Reading BMP header */

   283

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

   284

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

   285

	info->offset = ReadDword(buffer);

   286

   287

	/* Reading info header */

   288

	header_size = ReadDword(buffer);

   289

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

   290

   291

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

   292

   293

	if (info->os2_bmp) {

   294

		info->width = ReadWord(buffer);

   295

		info->height = ReadWord(buffer);

   296

		header_size -= 8;

   297

	} else {

   298

		info->width = ReadDword(buffer);

   299

		info->height = ReadDword(buffer);

   300

		header_size -= 12;

   301

	}

   302

   303

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

   304

   305

	info->bpp = ReadWord(buffer);

   306

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

   307

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

   308

		return false;

   309

	}

   310

   311

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

   312

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

   313

		info->compression = ReadDword(buffer);

   314

		header_size -= 4;

   315

	}

   316

   317

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

   318

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

   319

   320

	if (info->bpp <= 8) {

   321

		uint i;

   322

   323

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

   324

		if (header_size >= 16) {

   325

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

   326

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

   327

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

   328

		}

   329

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

   330

   331

		data->palette = calloc(info->palette_size, sizeof(*(data->palette)));

   332

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

   333

   334

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

   335

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

   336

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

   337

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

   338

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

   339

		}

   340

	}

   341

   342

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

   343

}

   344

   345

/*

   346

 * Reads the bitmap

   347

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

   348

 */

   349

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

   350

{

   351

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

   352

   353

	data->bitmap = calloc(info->width * info->height, ((info->bpp == 24) ? 3 : 1) * sizeof(byte));

   354

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

   355

   356

	/* Load image */

   357

	SetStreamOffset(buffer, info->offset);

   358

	switch (info->compression) {

   359

	case 0: // no compression

   360

		switch (info->bpp) {

   361

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

   362

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

   363

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

   364

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

   365

		default: NOT_REACHED(); return false;

   366

		}

   367

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

   368

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

   369

	default: NOT_REACHED(); return false;

   370

	}

   371

}

   372

   373

void BmpDestroyData(BmpData *data)

   374

{

   375

	assert(data != NULL);

   376

	free(data->palette);

   377

	free(data->bitmap);

   378

}