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

{

    14

	buffer->pos      = -1;

    15

	buffer->file     = file;

    16

	buffer->read     = 0;

    17

	buffer->real_pos = ftell(file);

    18

}

    19

    20

static inline void AdvanceBuffer(BmpBuffer *buffer)

    21

{

    22

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

    23

	buffer->pos  = 0;

    24

}

    25

    26

static inline bool EndOfBuffer(BmpBuffer *buffer)

    27

{

    28

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

    29

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

    30

}

    31

    32

static inline byte ReadByte(BmpBuffer *buffer)

    33

{

    34

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

    35

	buffer->real_pos++;

    36

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

    37

}

    38

    39

static inline uint16 ReadWord(BmpBuffer *buffer)

    40

{

    41

	uint16 var = ReadByte(buffer);

    42

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

    43

}

    44

    45

static inline uint32 ReadDword(BmpBuffer *buffer)

    46

{

    47

	uint32 var = ReadWord(buffer);

    48

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

    49

}

    50

    51

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

    52

{

    53

	int i;

    54

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

    55

}

    56

    57

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

    58

{

    59

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

    60

	buffer->pos = -1;

    61

	buffer->real_pos = offset;

    62

	AdvanceBuffer(buffer);

    63

}

    64

    65

/**

    66

 * Reads a 1 bpp uncompressed bitmap

    67

 * The bitmap is converted to a 8 bpp bitmap

    68

 */

    69

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

    70

{

    71

	uint x, y, i;

    72

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

    73

	byte *pixel_row;

    74

	byte b;

    75

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

    76

		x = 0;

    77

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

    78

		while (x < info->width) {

    79

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

    80

			b = ReadByte(buffer);

    81

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

    82

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

    83

				x++;

    84

			}

    85

		}

    86

		/* Padding for 32 bit align */

    87

		SkipBytes(buffer, pad);

    88

	}

    89

	return true;

    90

}

    91

    92

/**

    93

 * Reads a 4 bpp uncompressed bitmap

    94

 * The bitmap is converted to a 8 bpp bitmap

    95

 */

    96

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

    97

{

    98

	uint x, y;

    99

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

   100

	byte *pixel_row;

   101

	byte b;

   102

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

   103

		x = 0;

   104

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

   105

		while (x < info->width) {

   106

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

   107

			b = ReadByte(buffer);

   108

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

   109

			x++;

   110

			if (x < info->width) {

   111

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

   112

				x++;

   113

			}

   114

		}

   115

		/* Padding for 32 bit align */

   116

		SkipBytes(buffer, pad);

   117

	}

   118

	return true;

   119

}

   120

   121

/**

   122

 * Reads a 4-bit RLE compressed bitmap

   123

 * The bitmap is converted to a 8 bpp bitmap

   124

 */

   125

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

   126

{

   127

	uint i;

   128

	uint x = 0;

   129

	uint y = info->height - 1;

   130

	byte n, c, b;

   131

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

   132

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

   133

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

   134

		n = ReadByte(buffer);

   135

		c = ReadByte(buffer);

   136

		if (n == 0) {

   137

			switch (c) {

   138

			case 0: // end of line

   139

				x = 0;

   140

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

   141

				break;

   142

			case 1: // end of bitmap

   143

				x = info->width;

   144

				y = 0;

   145

				pixel = NULL;

   146

				break;

   147

			case 2: // delta

   148

				x += ReadByte(buffer);

   149

				i = ReadByte(buffer);

   150

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

   151

				y -= i;

   152

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

   153

				break;

   154

			default: // uncompressed

   155

				i = 0;

   156

				while (i++ < c) {

   157

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

   158

					b = ReadByte(buffer);

   159

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

   160

					x++;

   161

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

   162

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

   163

						x++;

   164

					}

   165

				}

   166

				/* Padding for 16 bit align */

   167

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

   168

				break;

   169

			}

   170

		} else {

   171

			i = 0;

   172

			while (i++ < n) {

   173

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

   174

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

   175

				x++;

   176

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

   177

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

   178

					x++;

   179

				}

   180

			}

   181

		}

   182

	}

   183

	return true;

   184

}

   185

   186

/**

   187

 * Reads a 8 bpp bitmap

   188

 */

   189

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

   190

{

   191

	uint i;

   192

	uint y;

   193

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

   194

	byte *pixel;

   195

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

   196

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

   197

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

   198

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

   199

		/* Padding for 32 bit align */

   200

		SkipBytes(buffer, pad);

   201

	}

   202

	return true;

   203

}

   204

   205

/**

   206

 * Reads a 8-bit RLE compressed bpp bitmap

   207

 */

   208

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

   209

{

   210

	uint i;

   211

	uint x = 0;

   212

	uint y = info->height - 1;

   213

	byte n, c;

   214

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

   215

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

   216

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

   217

		n = ReadByte(buffer);

   218

		c = ReadByte(buffer);

   219

		if (n == 0) {

   220

			switch (c) {

   221

			case 0: // end of line

   222

				x = 0;

   223

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

   224

				break;

   225

			case 1: // end of bitmap

   226

				x = info->width;

   227

				y = 0;

   228

				pixel = NULL;

   229

				break;

   230

			case 2: // delta

   231

				x += ReadByte(buffer);

   232

				i = ReadByte(buffer);

   233

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

   234

				y -= i;

   235

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

   236

				break;

   237

			default: // uncompressed

   238

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

   239

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

   240

				/* Padding for 16 bit align */

   241

				SkipBytes(buffer, c % 2);

   242

				break;

   243

			}

   244

		} else {

   245

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

   246

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

   247

				*pixel++ = c;

   248

				x++;

   249

			}

   250

		}

   251

	}

   252

	return true;

   253

}

   254

   255

/**

   256

 * Reads a 24 bpp uncompressed bitmap

   257

 */

   258

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

   259

{

   260

	uint x, y;

   261

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

   262

	byte *pixel_row;

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

			*pixel_row       = ReadByte(buffer); // red

   270

			pixel_row += 3;

   271

		}

   272

		/* Padding for 32 bit align */

   273

		SkipBytes(buffer, pad);

   274

	}

   275

	return true;

   276

}

   277

   278

/*

   279

 * Reads bitmap headers, and palette (if any)

   280

 */

   281

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

   282

{

   283

	uint32 header_size;

   284

	assert(info != NULL);

   285

   286

	/* Reading BMP header */

   287

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

   288

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

   289

	info->offset = ReadDword(buffer);

   290

   291

	/* Reading info header */

   292

	header_size = ReadDword(buffer);

   293

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

   294

   295

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

   296

   297

	if (info->os2_bmp) {

   298

		info->width = ReadWord(buffer);

   299

		info->height = ReadWord(buffer);

   300

		header_size -= 8;

   301

	} else {

   302

		info->width = ReadDword(buffer);

   303

		info->height = ReadDword(buffer);

   304

		header_size -= 12;

   305

	}

   306

   307

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

   308

   309

	info->bpp = ReadWord(buffer);

   310

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

   311

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

   312

		return false;

   313

	}

   314

   315

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

   316

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

   317

		info->compression = ReadDword(buffer);

   318

		header_size -= 4;

   319

	}

   320

   321

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

   322

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

   323

   324

	if (info->bpp <= 8) {

   325

		uint i;

   326

   327

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

   328

		if (header_size >= 16) {

   329

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

   330

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

   331

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

   332

		}

   333

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

   334

   335

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

   336

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

   337

   338

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

   339

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

   340

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

   341

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

   342

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

   343

		}

   344

	}

   345

   346

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

   347

}

   348

   349

/*

   350

 * Reads the bitmap

   351

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

   352

 */

   353

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

   354

{

   355

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

   356

   357

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

   358

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

   359

   360

	/* Load image */

   361

	SetStreamOffset(buffer, info->offset);

   362

	switch (info->compression) {

   363

	case 0: // no compression

   364

		switch (info->bpp) {

   365

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

   366

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

   367

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

   368

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

   369

		default: NOT_REACHED(); return false;

   370

		}

   371

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

   372

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

   373

	default: NOT_REACHED(); return false;

   374

	}

   375

}

   376

   377

void BmpDestroyData(BmpData *data)

   378

{

   379

	assert(data != NULL);

   380

	free(data->palette);

   381

	free(data->bitmap);

   382

}