1

/* $Id$ */

     2

     3

/** @file bmp.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "gfx.h"

     8

#include "bmp.h"

     9

#include "macros.h"

    10

#include "helpers.hpp"

    11

    12

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

    13

	buffer->pos      = -1;

    14

	buffer->file     = file;

    15

	buffer->read     = 0;

    16

	buffer->real_pos = ftell(file);

    17

}

    18

    19

static inline void AdvanceBuffer(BmpBuffer *buffer)

    20

{

    21

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

    22

	buffer->pos  = 0;

    23

}

    24

    25

static inline bool EndOfBuffer(BmpBuffer *buffer)

    26

{

    27

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

    28

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

    29

}

    30

    31

static inline byte ReadByte(BmpBuffer *buffer)

    32

{

    33

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

    34

	buffer->real_pos++;

    35

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

    36

}

    37

    38

static inline uint16 ReadWord(BmpBuffer *buffer)

    39

{

    40

	uint16 var = ReadByte(buffer);

    41

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

    42

}

    43

    44

static inline uint32 ReadDword(BmpBuffer *buffer)

    45

{

    46

	uint32 var = ReadWord(buffer);

    47

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

    48

}

    49

    50

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

    51

{

    52

	int i;

    53

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

    54

}

    55

    56

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

    57

{

    58

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

    59

	buffer->pos = -1;

    60

	buffer->real_pos = offset;

    61

	AdvanceBuffer(buffer);

    62

}

    63

    64

/**

    65

 * Reads a 1 bpp uncompressed bitmap

    66

 * The bitmap is converted to a 8 bpp bitmap

    67

 */

    68

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

    69

{

    70

	uint x, y, i;

    71

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

    72

	byte *pixel_row;

    73

	byte b;

    74

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

    75

		x = 0;

    76

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

    77

		while (x < info->width) {

    78

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

    79

			b = ReadByte(buffer);

    80

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

    81

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

    82

				x++;

    83

			}

    84

		}

    85

		/* Padding for 32 bit align */

    86

		SkipBytes(buffer, pad);

    87

	}

    88

	return true;

    89

}

    90

    91

/**

    92

 * Reads a 4 bpp uncompressed bitmap

    93

 * The bitmap is converted to a 8 bpp bitmap

    94

 */

    95

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

    96

{

    97

	uint x, y;

    98

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

    99

	byte *pixel_row;

   100

	byte b;

   101

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

   102

		x = 0;

   103

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

   104

		while (x < info->width) {

   105

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

   106

			b = ReadByte(buffer);

   107

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

   108

			x++;

   109

			if (x < info->width) {

   110

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

   111

				x++;

   112

			}

   113

		}

   114

		/* Padding for 32 bit align */

   115

		SkipBytes(buffer, pad);

   116

	}

   117

	return true;

   118

}

   119

   120

/**

   121

 * Reads a 4-bit RLE compressed bitmap

   122

 * The bitmap is converted to a 8 bpp bitmap

   123

 */

   124

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

   125

{

   126

	uint i;

   127

	uint x = 0;

   128

	uint y = info->height - 1;

   129

	byte n, c, b;

   130

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

   131

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

   132

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

   133

		n = ReadByte(buffer);

   134

		c = ReadByte(buffer);

   135

		if (n == 0) {

   136

			switch (c) {

   137

			case 0: // end of line

   138

				x = 0;

   139

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

   140

				break;

   141

			case 1: // end of bitmap

   142

				x = info->width;

   143

				y = 0;

   144

				pixel = NULL;

   145

				break;

   146

			case 2: // delta

   147

				x += ReadByte(buffer);

   148

				i = ReadByte(buffer);

   149

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

   150

				y -= i;

   151

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

   152

				break;

   153

			default: // uncompressed

   154

				i = 0;

   155

				while (i++ < c) {

   156

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

   157

					b = ReadByte(buffer);

   158

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

   159

					x++;

   160

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

   161

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

   162

						x++;

   163

					}

   164

				}

   165

				/* Padding for 16 bit align */

   166

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

   167

				break;

   168

			}

   169

		} else {

   170

			i = 0;

   171

			while (i++ < n) {

   172

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

   173

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

   174

				x++;

   175

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

   176

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

   177

					x++;

   178

				}

   179

			}

   180

		}

   181

	}

   182

	return true;

   183

}

   184

   185

/**

   186

 * Reads a 8 bpp bitmap

   187

 */

   188

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

   189

{

   190

	uint i;

   191

	uint y;

   192

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

   193

	byte *pixel;

   194

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

   195

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

   196

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

   197

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

   198

		/* Padding for 32 bit align */

   199

		SkipBytes(buffer, pad);

   200

	}

   201

	return true;

   202

}

   203

   204

/**

   205

 * Reads a 8-bit RLE compressed bpp bitmap

   206

 */

   207

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

   208

{

   209

	uint i;

   210

	uint x = 0;

   211

	uint y = info->height - 1;

   212

	byte n, c;

   213

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

   214

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

   215

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

   216

		n = ReadByte(buffer);

   217

		c = ReadByte(buffer);

   218

		if (n == 0) {

   219

			switch (c) {

   220

			case 0: // end of line

   221

				x = 0;

   222

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

   223

				break;

   224

			case 1: // end of bitmap

   225

				x = info->width;

   226

				y = 0;

   227

				pixel = NULL;

   228

				break;

   229

			case 2: // delta

   230

				x += ReadByte(buffer);

   231

				i = ReadByte(buffer);

   232

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

   233

				y -= i;

   234

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

   235

				break;

   236

			default: // uncompressed

   237

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

   238

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

   239

				/* Padding for 16 bit align */

   240

				SkipBytes(buffer, c % 2);

   241

				break;

   242

			}

   243

		} else {

   244

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

   245

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

   246

				*pixel++ = c;

   247

				x++;

   248

			}

   249

		}

   250

	}

   251

	return true;

   252

}

   253

   254

/**

   255

 * Reads a 24 bpp uncompressed bitmap

   256

 */

   257

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

   258

{

   259

	uint x, y;

   260

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

   261

	byte *pixel_row;

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

			*pixel_row       = ReadByte(buffer); // red

   269

			pixel_row += 3;

   270

		}

   271

		/* Padding for 32 bit align */

   272

		SkipBytes(buffer, pad);

   273

	}

   274

	return true;

   275

}

   276

   277

/*

   278

 * Reads bitmap headers, and palette (if any)

   279

 */

   280

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

   281

{

   282

	uint32 header_size;

   283

	assert(info != NULL);

   284

   285

	/* Reading BMP header */

   286

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

   287

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

   288

	info->offset = ReadDword(buffer);

   289

   290

	/* Reading info header */

   291

	header_size = ReadDword(buffer);

   292

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

   293

   294

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

   295

   296

	if (info->os2_bmp) {

   297

		info->width = ReadWord(buffer);

   298

		info->height = ReadWord(buffer);

   299

		header_size -= 8;

   300

	} else {

   301

		info->width = ReadDword(buffer);

   302

		info->height = ReadDword(buffer);

   303

		header_size -= 12;

   304

	}

   305

   306

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

   307

   308

	info->bpp = ReadWord(buffer);

   309

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

   310

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

   311

		return false;

   312

	}

   313

   314

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

   315

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

   316

		info->compression = ReadDword(buffer);

   317

		header_size -= 4;

   318

	}

   319

   320

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

   321

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

   322

   323

	if (info->bpp <= 8) {

   324

		uint i;

   325

   326

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

   327

		if (header_size >= 16) {

   328

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

   329

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

   330

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

   331

		}

   332

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

   333

   334

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

   335

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

   336

   337

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

   338

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

   339

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

   340

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

   341

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

   342

		}

   343

	}

   344

   345

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

   346

}

   347

   348

/*

   349

 * Reads the bitmap

   350

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

   351

 */

   352

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

   353

{

   354

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

   355

   356

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

   357

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

   358

   359

	/* Load image */

   360

	SetStreamOffset(buffer, info->offset);

   361

	switch (info->compression) {

   362

	case 0: // no compression

   363

		switch (info->bpp) {

   364

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

   365

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

   366

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

   367

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

   368

		default: NOT_REACHED(); return false;

   369

		}

   370

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

   371

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

   372

	default: NOT_REACHED(); return false;

   373

	}

   374

}

   375

   376

void BmpDestroyData(BmpData *data)

   377

{

   378

	assert(data != NULL);

   379

	free(data->palette);

   380

	free(data->bitmap);

   381

}