1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "gfx.h"

     6

#include "bmp.h"

     7

#include "macros.h"

     8

#include "helpers.hpp"

     9

    10

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

    11

	buffer->pos      = -1;

    12

	buffer->file     = file;

    13

	buffer->read     = 0;

    14

	buffer->real_pos = ftell(file);

    15

}

    16

    17

static inline void AdvanceBuffer(BmpBuffer *buffer)

    18

{

    19

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

    20

	buffer->pos  = 0;

    21

}

    22

    23

static inline bool EndOfBuffer(BmpBuffer *buffer)

    24

{

    25

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

    26

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

    27

}

    28

    29

static inline byte ReadByte(BmpBuffer *buffer)

    30

{

    31

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

    32

	buffer->real_pos++;

    33

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

    34

}

    35

    36

static inline uint16 ReadWord(BmpBuffer *buffer)

    37

{

    38

	uint16 var = ReadByte(buffer);

    39

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

    40

}

    41

    42

static inline uint32 ReadDword(BmpBuffer *buffer)

    43

{

    44

	uint32 var = ReadWord(buffer);

    45

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

    46

}

    47

    48

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

    49

{

    50

	int i;

    51

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

    52

}

    53

    54

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

    55

{

    56

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

    57

	buffer->pos = -1;

    58

	buffer->real_pos = offset;

    59

	AdvanceBuffer(buffer);

    60

}

    61

    62

/**

    63

 * Reads a 1 bpp uncompressed bitmap

    64

 * The bitmap is converted to a 8 bpp bitmap

    65

 */

    66

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

    67

{

    68

	uint x, y, i;

    69

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

    70

	byte *pixel_row;

    71

	byte b;

    72

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

    73

		x = 0;

    74

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

    75

		while (x < info->width) {

    76

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

    77

			b = ReadByte(buffer);

    78

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

    79

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

    80

				x++;

    81

			}

    82

		}

    83

		/* Padding for 32 bit align */

    84

		SkipBytes(buffer, pad);

    85

	}

    86

	return true;

    87

}

    88

    89

/**

    90

 * Reads a 4 bpp uncompressed bitmap

    91

 * The bitmap is converted to a 8 bpp bitmap

    92

 */

    93

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

    94

{

    95

	uint x, y;

    96

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

    97

	byte *pixel_row;

    98

	byte b;

    99

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

   100

		x = 0;

   101

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

   102

		while (x < info->width) {

   103

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

   104

			b = ReadByte(buffer);

   105

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

   106

			x++;

   107

			if (x < info->width) {

   108

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

   109

				x++;

   110

			}

   111

		}

   112

		/* Padding for 32 bit align */

   113

		SkipBytes(buffer, pad);

   114

	}

   115

	return true;

   116

}

   117

   118

/**

   119

 * Reads a 4-bit RLE compressed bitmap

   120

 * The bitmap is converted to a 8 bpp bitmap

   121

 */

   122

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

   123

{

   124

	uint i;

   125

	uint x = 0;

   126

	uint y = info->height - 1;

   127

	byte n, c, b;

   128

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

   129

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

   130

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

   131

		n = ReadByte(buffer);

   132

		c = ReadByte(buffer);

   133

		if (n == 0) {

   134

			switch (c) {

   135

			case 0: // end of line

   136

				x = 0;

   137

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

   138

				break;

   139

			case 1: // end of bitmap

   140

				x = info->width;

   141

				y = 0;

   142

				pixel = NULL;

   143

				break;

   144

			case 2: // delta

   145

				x += ReadByte(buffer);

   146

				i = ReadByte(buffer);

   147

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

   148

				y -= i;

   149

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

   150

				break;

   151

			default: // uncompressed

   152

				i = 0;

   153

				while (i++ < c) {

   154

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

   155

					b = ReadByte(buffer);

   156

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

   157

					x++;

   158

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

   159

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

   160

						x++;

   161

					}

   162

				}

   163

				/* Padding for 16 bit align */

   164

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

   165

				break;

   166

			}

   167

		} else {

   168

			i = 0;

   169

			while (i++ < n) {

   170

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

   171

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

   172

				x++;

   173

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

   174

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

   175

					x++;

   176

				}

   177

			}

   178

		}

   179

	}

   180

	return true;

   181

}

   182

   183

/**

   184

 * Reads a 8 bpp bitmap

   185

 */

   186

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

   187

{

   188

	uint i;

   189

	uint y;

   190

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

   191

	byte *pixel;

   192

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

   193

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

   194

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

   195

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

   196

		/* Padding for 32 bit align */

   197

		SkipBytes(buffer, pad);

   198

	}

   199

	return true;

   200

}

   201

   202

/**

   203

 * Reads a 8-bit RLE compressed bpp bitmap

   204

 */

   205

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

   206

{

   207

	uint i;

   208

	uint x = 0;

   209

	uint y = info->height - 1;

   210

	byte n, c;

   211

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

   212

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

   213

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

   214

		n = ReadByte(buffer);

   215

		c = ReadByte(buffer);

   216

		if (n == 0) {

   217

			switch (c) {

   218

			case 0: // end of line

   219

				x = 0;

   220

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

   221

				break;

   222

			case 1: // end of bitmap

   223

				x = info->width;

   224

				y = 0;

   225

				pixel = NULL;

   226

				break;

   227

			case 2: // delta

   228

				x += ReadByte(buffer);

   229

				i = ReadByte(buffer);

   230

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

   231

				y -= i;

   232

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

   233

				break;

   234

			default: // uncompressed

   235

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

   236

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

   237

				/* Padding for 16 bit align */

   238

				SkipBytes(buffer, c % 2);

   239

				break;

   240

			}

   241

		} else {

   242

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

   243

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

   244

				*pixel++ = c;

   245

				x++;

   246

			}

   247

		}

   248

	}

   249

	return true;

   250

}

   251

   252

/**

   253

 * Reads a 24 bpp uncompressed bitmap

   254

 */

   255

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

   256

{

   257

	uint x, y;

   258

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

   259

	byte *pixel_row;

   260

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

   261

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

   262

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

   263

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

   264

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

   265

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

   266

			*pixel_row       = ReadByte(buffer); // red

   267

			pixel_row += 3;

   268

		}

   269

		/* Padding for 32 bit align */

   270

		SkipBytes(buffer, pad);

   271

	}

   272

	return true;

   273

}

   274

   275

/*

   276

 * Reads bitmap headers, and palette (if any)

   277

 */

   278

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

   279

{

   280

	uint32 header_size;

   281

	assert(info != NULL);

   282

   283

	/* Reading BMP header */

   284

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

   285

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

   286

	info->offset = ReadDword(buffer);

   287

   288

	/* Reading info header */

   289

	header_size = ReadDword(buffer);

   290

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

   291

   292

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

   293

   294

	if (info->os2_bmp) {

   295

		info->width = ReadWord(buffer);

   296

		info->height = ReadWord(buffer);

   297

		header_size -= 8;

   298

	} else {

   299

		info->width = ReadDword(buffer);

   300

		info->height = ReadDword(buffer);

   301

		header_size -= 12;

   302

	}

   303

   304

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

   305

   306

	info->bpp = ReadWord(buffer);

   307

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

   308

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

   309

		return false;

   310

	}

   311

   312

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

   313

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

   314

		info->compression = ReadDword(buffer);

   315

		header_size -= 4;

   316

	}

   317

   318

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

   319

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

   320

   321

	if (info->bpp <= 8) {

   322

		uint i;

   323

   324

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

   325

		if (header_size >= 16) {

   326

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

   327

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

   328

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

   329

		}

   330

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

   331

   332

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

   333

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

   334

   335

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

   336

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

   337

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

   338

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

   339

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

   340

		}

   341

	}

   342

   343

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

   344

}

   345

   346

/*

   347

 * Reads the bitmap

   348

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

   349

 */

   350

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

   351

{

   352

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

   353

   354

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

   355

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

   356

   357

	/* Load image */

   358

	SetStreamOffset(buffer, info->offset);

   359

	switch (info->compression) {

   360

	case 0: // no compression

   361

		switch (info->bpp) {

   362

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

   363

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

   364

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

   365

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

   366

		default: NOT_REACHED(); return false;

   367

		}

   368

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

   369

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

   370

	default: NOT_REACHED(); return false;

   371

	}

   372

}

   373

   374

void BmpDestroyData(BmpData *data)

   375

{

   376

	assert(data != NULL);

   377

	free(data->palette);

   378

	free(data->bitmap);

   379

}