qrinput.c

二维码QR的linux平台下的编码源代码

	unsigned int val, h;

	entry->bstream = BitStream_new();

	val = 0x8;
	BitStream_appendNum(entry->bstream, 4, val);
	
	val = entry->size / 2;
	BitStream_appendNum(entry->bstream, QRspec_lengthIndicator(QR_MODE_KANJI, version), val);

	for(i=0; i<entry->size; i+=2) {
		val = ((unsigned int)entry->data[i] << 8) | entry->data[i+1];
		if(val <= 0x9ffc) {
			val -= 0x8140;
		} else {
			val -= 0xc140;
		}
		h = (val >> 8) * 0xc0;
		val = (val & 0xff) + h;

		BitStream_appendNum(entry->bstream, 13, val);
	}
}

/******************************************************************************
 * Validation
 *****************************************************************************/

/**
 * Validate the input data
 * @param mode
 * @param size
 * @param data
 * @return result
 */
int QRinput_check(QRencodeMode mode, int size, const unsigned char *data)
{
	switch(mode) {
		case QR_MODE_NUM:
			return QRinput_checkModeNum(size, (const char *)data);
			break;
		case QR_MODE_AN:
			return QRinput_checkModeAn(size, (const char *)data);
			break;
		case QR_MODE_KANJI:
			return QRinput_checkModeKanji(size, data);
			break;
		default:
			break;
	}

	return 0;
}

QRencodeMode QRinput_identifyMode(const char *string)
{
	unsigned char c, d;
	unsigned int word;

	c = string[0];

	if((unsigned char)((signed char)c - '0') < 10) {
		return QR_MODE_NUM;
	} else if((QRinput_lookAnTable(c)) >= 0) {
		return QR_MODE_AN;
	} else {
		d = string[1];
		if(d != '\0') {
			word = ((unsigned int)c << 8) | d;
			if((word >= 0x8140 && word <= 0x9ffc) || (word >= 0xe040 && word <= 0xebbf)) {
				return QR_MODE_KANJI;
			}
		}
	}

	return QR_MODE_8;
}

/******************************************************************************
 * Estimation of the bit length
 *****************************************************************************/

/**
 * Estimates the length of the encoded bit stream on the current version.
 * @param entry
 * @param version version of the symbol
 * @return number of bits
 */
static int QRinput_estimateBitStreamSizeOfEntry(QRinput_List *entry, int version)
{
	int bits = 0;
	int l, m;
	int num;

	switch(entry->mode) {
		case QR_MODE_NUM:
			bits = QRinput_estimateBitsModeNum(entry->size);
			break;
		case QR_MODE_AN:
			bits = QRinput_estimateBitsModeAn(entry->size);
			break;
		case QR_MODE_8:
			bits = QRinput_estimateBitsMode8(entry->size);
			break;
		case QR_MODE_KANJI:
			bits = QRinput_estimateBitsModeKanji(entry->size);
			break;
	}

	l = QRspec_lengthIndicator(entry->mode, version);
	m = 1 << l;
	num = (bits + m - 1) / m;

	bits += num * (4 + l); // mode indicator (4bits) + length indicator

	return bits;
}

/**
 * Estimates the length of the encoded bit stream of the data.
 * @param input input data
 * @param version version of the symbol
 * @return number of bits
 */
int QRinput_estimateBitStreamSize(QRinput *input, int version)
{
	QRinput_List *list;
	int bits = 0;

	list = input->head;
	while(list != NULL) {
		bits += QRinput_estimateBitStreamSizeOfEntry(list, version);
		list = list->next;
	}

	return bits;
}

/**
 * Estimates the required version number of the symbol.
 * @param input input data
 * @return required version number
 */
static int QRinput_estimateVersion(QRinput *input)
{
	int bits;
	int new, prev;

	new = 0;
	do {
		prev = new;
		bits = QRinput_estimateBitStreamSize(input, prev);
		new = QRspec_getMinimumVersion((bits + 7) / 8, input->level);
		if (new == -1) {
			return -1;
		}
	} while (new > prev);

	return new;
}

/******************************************************************************
 * Data conversion
 *****************************************************************************/

/**
 * Convert the input data in the data chunk to a bit stream.
 * @param entry
 * @return number of bits
 */
static int QRinput_encodeBitStream(QRinput_List *entry, int version)
{
	int words;
	QRinput_List *st1, *st2;

	if(entry->bstream != NULL) {
		BitStream_free(entry->bstream);
		entry->bstream = NULL;
	}

	words = QRspec_maximumWords(entry->mode, version);
	if(entry->size > words) {
		st1 = QRinput_newEntry(entry->mode, words, entry->data);
		st2 = QRinput_newEntry(entry->mode, entry->size - words, &entry->data[words]);
		QRinput_encodeBitStream(st1, version);
		QRinput_encodeBitStream(st2, version);
		entry->bstream = BitStream_new();
		BitStream_append(entry->bstream, st1->bstream);
		BitStream_append(entry->bstream, st2->bstream);
		QRinput_freeEntry(st1);
		QRinput_freeEntry(st2);
	} else {
		switch(entry->mode) {
			case QR_MODE_NUM:
				QRinput_encodeModeNum(entry, version);
				break;
			case QR_MODE_AN:
				QRinput_encodeModeAn(entry, version);
				break;
			case QR_MODE_8:
				QRinput_encodeMode8(entry, version);
				break;
			case QR_MODE_KANJI:
				QRinput_encodeModeKanji(entry, version);
				break;
			default:
				break;
		}
	}

	return BitStream_size(entry->bstream);
}

/**
 * Convert the input data to a bit stream.
 * @param input input data.
 * @return length of the bit stream.
 */
static int QRinput_createBitStream(QRinput *input)
{
	QRinput_List *list;
	int bits = 0;

	list = input->head;
	while(list != NULL) {
		bits += QRinput_encodeBitStream(list, input->version);
		list = list->next;
	}

	return bits;
}

/**
 * Convert the input data to a bit stream.
 * When the version number is given and that is not sufficient, it is increased
 * automatically.
 * @param input input data.
 * @return -1 if the input data was too large. Otherwise 0.
 */
static int QRinput_convertData(QRinput *input)
{
	int bits;
	int ver;

	ver = QRinput_estimateVersion(input);
	if(ver > QRinput_getVersion(input)) {
		QRinput_setVersion(input, ver);
	}

	for(;;) {
		bits = QRinput_createBitStream(input);
		ver = QRspec_getMinimumVersion((bits + 7) / 8, input->level);
		if(ver < 0) {
			return -1;
		} else if(ver > QRinput_getVersion(input)) {
			QRinput_setVersion(input, ver);
		} else {
			break;
		}
	}

	return 0;
}

/**
 * Create padding bits for the input data.
 * @param input input data.
 * @return padding bit stream.
 */
static BitStream *QRinput_createPaddingBit(QRinput *input)
{
	int bits, maxbits, words, maxwords, i;
	QRinput_List *list;
	BitStream *bstream;

	if(input->version <= 0)
		return NULL;

	maxwords = QRspec_getDataLength(input->version, input->level);
	maxbits = maxwords * 8;

	list = input->head;
	bits = 0;
	while(list != NULL) {
		bits += BitStream_size(list->bstream);
		list = list->next;
	}

	words = (bits + 7) / 8;

	if(maxbits - bits < 5) {
		if(maxbits == bits) {
			return NULL;
		} else {
			bstream = BitStream_new();
			BitStream_appendNum(bstream, maxbits - bits, 0);
			return bstream;
		}
	}

	bits += 4;
	words = (bits + 7) / 8;

	bstream = BitStream_new();
	BitStream_appendNum(bstream, words * 8 - bits + 4, 0);

	/* FIXME: It would be able to add padding bits by more efficient way. */
	for(i=0; i<maxwords - words; i++) {
		if(i & 1) {
			BitStream_appendNum(bstream, 8, 0x11);
		} else {
			BitStream_appendNum(bstream, 8, 0xec);
		}
	}

	return bstream;
}

/**
 * Merge all bit streams in the input data.
 * @param input input data.
 * @return merged bit stream
 */

BitStream *QRinput_mergeBitStream(QRinput *input)
{
	BitStream *bstream;
	QRinput_List *list;

	if(QRinput_convertData(input) < 0) {
		return NULL;
	}

	bstream = BitStream_new();
	list = input->head;
	while(list != NULL) {
		BitStream_append(bstream, list->bstream);
		list = list->next;
	}

	return bstream;
}

/**
 * Merge all bit streams in the input data and append padding bits
 * @param input input data.
 * @return padded merged bit stream
 */

BitStream *QRinput_getBitStream(QRinput *input)
{
	BitStream *bstream;
	BitStream *padding;

	bstream = QRinput_mergeBitStream(input);
	if(bstream == NULL) {
		return NULL;
	}
	padding = QRinput_createPaddingBit(input);
	if(padding != NULL) {
		BitStream_append(bstream, padding);
		BitStream_free(padding);
	}

	return bstream;
}

/**
 * Pack all bit streams padding bits into a byte array.
 * @param input input data.
 * @return padded merged byte stream
 */

unsigned char *QRinput_getByteStream(QRinput *input)
{
	BitStream *bstream;
	unsigned char *array;

	bstream = QRinput_getBitStream(input);
	if(bstream == NULL) {
		return NULL;
	}
	array = BitStream_toByte(bstream);
	BitStream_free(bstream);

	return array;
}