C++ (Cpp) SWAP_16 Examples

Example #1

0

Show file

File: ctf.c Project: DataIX/src

/*
 * Depending on the size of the type being described, either a ctf_stype_t (for
 * types with size < CTF_LSTRUCT_THRESH) or a ctf_type_t (all others) will be
 * written.  We isolate the determination here so the rest of the writer code
 * doesn't need to care.
 */
static void
write_sized_type_rec(ctf_buf_t *b, ctf_type_t *ctt, size_t size)
{
	if (size > CTF_MAX_SIZE) {
		ctt->ctt_size = CTF_LSIZE_SENT;
		ctt->ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI(size);
		ctt->ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO(size);
		if (target_requires_swap) {
			SWAP_32(ctt->ctt_name);
			SWAP_16(ctt->ctt_info);
			SWAP_16(ctt->ctt_size);
			SWAP_32(ctt->ctt_lsizehi);
			SWAP_32(ctt->ctt_lsizelo);
		}
		ctf_buf_write(b, ctt, sizeof (*ctt));
	} else {
		ctf_stype_t *cts = (ctf_stype_t *)ctt;

		cts->ctt_size = (ushort_t)size;

		if (target_requires_swap) {
			SWAP_32(cts->ctt_name);
			SWAP_16(cts->ctt_info);
			SWAP_16(cts->ctt_size);
		}

		ctf_buf_write(b, cts, sizeof (*cts));
	}
}

Example #2

0

Show file

File: swap.c Project: TronicLabs/sdcc

static void testSwap_16(void)
{
    volatile unsigned long t=TEST_VECT_32;
    unsigned long tt;
    LONG x;

    tt = t;
    tt = SWAP_16(tt);
    ASSERT( tt == SWAP_16(TEST_VECT_32));

    /* swapping union with little register pressure */
    {
        unsigned char c;
        x.l = t;

        c = x.c[0];
        x.c[0]=x.c[2];
        x.c[2]=c;
        c = x.c[1];
        x.c[1]=x.c[3];
        x.c[3]=c;

        ASSERT( x.l == SWAP_16(TEST_VECT_32));
    }
}

Example #3

0

Show file

File: pcmDecoder.cpp Project: ihavespoons/snapcast

SampleFormat PcmDecoder::setHeader(msg::CodecHeader* chunk)
{
	if (chunk->payloadSize < 44)
		throw SnapException("PCM header too small");

    struct riff_wave_header riff_wave_header;
	struct chunk_header chunk_header;
	struct chunk_fmt chunk_fmt;
	chunk_fmt.sample_rate = SWAP_32(0);
	chunk_fmt.bits_per_sample = SWAP_16(0);
	chunk_fmt.num_channels = SWAP_16(0);

	size_t pos(0);
	memcpy(&riff_wave_header, chunk->payload + pos, sizeof(riff_wave_header));
	pos += sizeof(riff_wave_header);
	if ((SWAP_32(riff_wave_header.riff_id) != ID_RIFF) || (SWAP_32(riff_wave_header.wave_id) != ID_WAVE))
		throw SnapException("Not a riff/wave header");

	bool moreChunks(true);
	do
	{
		if (pos + sizeof(chunk_header) > chunk->payloadSize)
			throw SnapException("riff/wave header incomplete");
		memcpy(&chunk_header, chunk->payload + pos, sizeof(chunk_header));
		pos += sizeof(chunk_header);
		switch (SWAP_32(chunk_header.id))
		{
		case ID_FMT:
			if (pos + sizeof(chunk_fmt) > chunk->payloadSize)
				throw SnapException("riff/wave header incomplete");
			memcpy(&chunk_fmt, chunk->payload + pos, sizeof(chunk_fmt));
			pos += sizeof(chunk_fmt);
			/// If the format header is larger, skip the rest
			if (SWAP_32(chunk_header.sz) > sizeof(chunk_fmt))
				pos += (SWAP_32(chunk_header.sz) - sizeof(chunk_fmt));
			break;
		case ID_DATA:
			/// Stop looking for chunks
			moreChunks = false;
			break;
		default:
			/// Unknown chunk, skip bytes
			pos += SWAP_32(chunk_header.sz);
		}
	}
	while (moreChunks);


	if (SWAP_32(chunk_fmt.sample_rate) == 0)
		throw SnapException("Sample format not found");

	SampleFormat sampleFormat(
		SWAP_32(chunk_fmt.sample_rate),
		SWAP_16(chunk_fmt.bits_per_sample),
		SWAP_16(chunk_fmt.num_channels));

	return sampleFormat;
}

Example #4

0

Show file

File: ctf.c Project: DataIX/src

static void
write_unsized_type_rec(ctf_buf_t *b, ctf_type_t *ctt)
{
	ctf_stype_t *cts = (ctf_stype_t *)ctt;

	if (target_requires_swap) {
		SWAP_32(cts->ctt_name);
		SWAP_16(cts->ctt_info);
		SWAP_16(cts->ctt_size);
	}

	ctf_buf_write(b, cts, sizeof (*cts));
}

Example #5

0

Show file

File: ctf.c Project: DataIX/src

static void
write_functions(iidesc_t *idp, ctf_buf_t *b)
{
	ushort_t fdata[2];
	ushort_t id;
	int nargs;
	int i;

	if (!idp) {
		fdata[0] = 0;
		ctf_buf_write(b, &fdata[0], sizeof (fdata[0]));

		debug(3, "Wrote function (null)\n");
		return;
	}

	nargs = idp->ii_nargs + (idp->ii_vargs != 0);

	if (nargs > CTF_MAX_VLEN) {
		terminate("function %s has too many args: %d > %d\n",
		    idp->ii_name, nargs, CTF_MAX_VLEN);
	}

	fdata[0] = CTF_TYPE_INFO(CTF_K_FUNCTION, 1, nargs);
	fdata[1] = idp->ii_dtype->t_id;

	if (target_requires_swap) {
		SWAP_16(fdata[0]);
		SWAP_16(fdata[1]);
	}

	ctf_buf_write(b, fdata, sizeof (fdata));

	for (i = 0; i < idp->ii_nargs; i++) {
		id = idp->ii_args[i]->t_id;

		if (target_requires_swap) {
			SWAP_16(id);
		}

		ctf_buf_write(b, &id, sizeof (id));
	}

	if (idp->ii_vargs) {
		id = 0;
		ctf_buf_write(b, &id, sizeof (id));
	}

	debug(3, "Wrote function %s (%d args)\n", idp->ii_name, nargs);
}

Example #6

0

Show file

File: swap.c Project: TronicLabs/sdcc

/* now for something ugly */
static void testSwap_16_ptr(void)
{
#if defined (SDCC)
#include <sdcc-lib.h> /* just to get _AUTOMEM or _STATMEM */
#if defined (SDCC_STACK_AUTO)
#define MY_STATIC static
#else
#define MY_STATIC
#endif
    MY_STATIC unsigned long _STATMEM tt=TEST_VECT_32;

    /* swapping with little register pressure */
    {
        unsigned char c;

        /* uglyness += 1 */
        c = *(0+(unsigned char _STATMEM *)&tt);
        *(0+(unsigned char _STATMEM *)&tt) = *(2+(unsigned char _STATMEM *)&tt);
        *(2+(unsigned char _STATMEM *)&tt) = c;
        c = *(1+(unsigned char _STATMEM *)&tt);
        *(1+(unsigned char _STATMEM *)&tt) = *(3+(unsigned char _STATMEM *)&tt);
        *(3+(unsigned char _STATMEM *)&tt) = c;
        /* uglyness -= 1 */
    }
    ASSERT( tt == SWAP_16(TEST_VECT_32));
#endif
}

Example #7

0

Show file

File: virtmem.c Project: Azarien/open-watcom-v2

extern unsigned_16 DWRVMReadWord( drmem_hdl hdl )
/***********************************************/
{
    page_entry  *node;
    unsigned_16 off;
    virt_struct vm;

    vm.l = hdl;
    ACCESSPAGE( node, vm );
    off = NODE_OFF(vm);
    if( off <= MAX_NODE_SIZE - 2 ) {
        // we can read both bytes now.
        // must not swap bytes in source buffer!
        off = *((unsigned_16 *)( node->mem + off ));
    } else {
        off = *(unsigned_8 *)( node->mem + off );
        vm.l++;
        ACCESSPAGE( node, vm );
        off |= ((unsigned_16)*node->mem) << 8;
    }
    if( DWRCurrNode->byte_swap ) {
        SWAP_16( off );
    }
    return( off );
}

Example #8

0

Show file