static fsal_status_t wire_to_host(struct fsal_export *exp_hdl,
fsal_digesttype_t in_type,
struct gsh_buffdesc *fh_desc,
int flags)
{
size_t fh_min;
uint64_t *hashkey;
ushort *len;
fh_min = 1;
if (fh_desc->len < fh_min) {
LogMajor(COMPONENT_FSAL,
"Size mismatch for handle. should be >= %zu, got %zu",
fh_min, fh_desc->len);
return fsalstat(ERR_FSAL_SERVERFAULT, 0);
}
hashkey = (uint64_t *)fh_desc->addr;
len = (ushort *)((char *)hashkey + sizeof(uint64_t));
if (flags & FH_FSAL_BIG_ENDIAN) {
#if (BYTE_ORDER != BIG_ENDIAN)
*len = bswap_16(*len);
*hashkey = bswap_64(*hashkey);
#endif
} else {
#if (BYTE_ORDER == BIG_ENDIAN)
*len = bswap_16(*len);
*hashkey = bswap_64(*hashkey);
#endif
}
return fsalstat(ERR_FSAL_NO_ERROR, 0);
}
void ffiget_arg_length(unsigned char *c, long clen, unsigned char *a, long alen) {
uint16_t arg;
memcpy(&arg, a, sizeof(arg));
arg = bswap_16(arg);
uint16_t len_result = bswap_16(strlen(argv[arg]));
memcpy(a, &len_result, sizeof(len_result));
}
static int pci_get_vendor(
unsigned char bus,
unsigned char dev,
int func)
{
int retval;
char path[100];
int fd;
short vendor, device;
sprintf(path,"/proc/bus/pci/%02d/%02x.0", bus, dev);
fd = open(path,O_RDONLY|O_SYNC);
if (fd == -1) {
retval=0xFFFF;
}
else if (pread(fd, &vendor, 2, PCI_VENDOR_ID) == 2 &&
pread(fd, &device, 2, PCI_DEVICE_ID) == 2) {
vendor = bswap_16(vendor);
device = bswap_16(device);
retval = vendor + (device<<16); /*no worries about byte order,
all ppc are bigendian*/
} else {
retval = 0xFFFF;
}
if (fd > 0) {
close(fd);
}
return retval;
}
int check_elf_header(Elf32_Ehdr *const ehdr)
{
if (! ehdr || strncmp((void *)ehdr, ELFMAG, SELFMAG) != 0 ||
ehdr->e_ident[EI_CLASS] != ELFCLASS32 ||
ehdr->e_ident[EI_VERSION] != EV_CURRENT)
{
return 1;
}
/* Check if the target endianness matches the host's endianness */
byteswap = 0;
#if __BYTE_ORDER == __LITTLE_ENDIAN
if (ehdr->e_ident[5] == ELFDATA2MSB) {
/* Ick -- we will have to byte-swap everything */
byteswap = 1;
}
#elif __BYTE_ORDER == __BIG_ENDIAN
if (ehdr->e_ident[5] == ELFDATA2LSB) {
byteswap = 1;
}
#else
#error Unknown host byte order!
#endif
/* Be vary lazy, and only byteswap the stuff we use */
if (byteswap==1) {
ehdr->e_type=bswap_16(ehdr->e_type);
ehdr->e_machine=bswap_16(ehdr->e_machine);
ehdr->e_phoff=bswap_32(ehdr->e_phoff);
ehdr->e_shoff=bswap_32(ehdr->e_shoff);
ehdr->e_phnum=bswap_16(ehdr->e_phnum);
ehdr->e_shnum=bswap_16(ehdr->e_shnum);
}
return 0;
}
int volume_id_probe_squashfs(struct volume_id *id, uint64_t off, uint64_t size)
{
struct squashfs_super *sqs;
info("probing at offset 0x%" PRIx64 "\n", off);
sqs = (struct squashfs_super *) volume_id_get_buffer(id, off, 0x200);
if (sqs == NULL)
return -1;
if (sqs->s_magic == SQUASHFS_MAGIC || sqs->s_magic == SQUASHFS_MAGIC_LZMA) {
snprintf(id->type_version, sizeof(id->type_version), "%u.%u",
sqs->s_major, sqs->s_minor);
goto found;
}
if (sqs->s_magic == bswap_32(SQUASHFS_MAGIC) || sqs->s_magic == bswap_32(SQUASHFS_MAGIC_LZMA)) {
snprintf(id->type_version, sizeof(id->type_version), "%u.%u",
bswap_16(sqs->s_major), bswap_16(sqs->s_minor));
goto found;
}
return -1;
found:
volume_id_set_usage(id, VOLUME_ID_FILESYSTEM);
id->type = "squashfs";
return 0;
}
void DeepStarComponent::byteSwap( deepStarData *stardata ) {
stardata->RA = bswap_32( stardata->RA );
stardata->Dec = bswap_32( stardata->Dec );
stardata->dRA = bswap_16( stardata->dRA );
stardata->dDec = bswap_16( stardata->dDec );
stardata->B = bswap_16( stardata->B );
stardata->V = bswap_16( stardata->V );
}
static void ocfs2_swap_extent_block_header(struct ocfs2_extent_block *eb)
{
eb->h_suballoc_slot = bswap_16(eb->h_suballoc_slot);
eb->h_suballoc_bit = bswap_16(eb->h_suballoc_bit);
eb->h_fs_generation = bswap_32(eb->h_fs_generation);
eb->h_blkno = bswap_64(eb->h_blkno);
eb->h_next_leaf_blk = bswap_64(eb->h_next_leaf_blk);
}
int
lynx_init (st_rominfo_t *rominfo)
{
int result = -1;
rominfo->console_usage = lynx_usage[0].help;
rominfo->copier_usage = unknown_usage[0].help;
ucon64_fread (&lnx_header, 0, LNX_HEADER_LEN, ucon64.rom);
if (!strncmp (lnx_header.magic, "LYNX", 4))
result = 0;
else
result = -1;
if (ucon64.console == UCON64_LYNX)
result = 0;
if (!strncmp (lnx_header.magic, "LYNX", 4))
{
rominfo->buheader_len = UCON64_ISSET (ucon64.buheader_len) ?
ucon64.buheader_len : (int) LNX_HEADER_LEN;
if (UCON64_ISSET (ucon64.buheader_len) && !ucon64.buheader_len)
return ucon64.console == UCON64_LYNX ? 0 : result;
ucon64_fread (&lnx_header, 0, LNX_HEADER_LEN, ucon64.rom);
rominfo->buheader = &lnx_header;
// internal ROM name
strcpy (rominfo->name, lnx_header.cartname);
// ROM maker
rominfo->maker = lnx_header.manufname;
// misc stuff
sprintf (rominfo->misc,
"Internal Size: Bank0 %hd Bytes (%.4f Mb)\n"
" Bank1 %hd Bytes (%.4f Mb)\n"
"Version: %hd\n"
"Rotation: %s",
#ifdef WORDS_BIGENDIAN
bswap_16 (lnx_header.page_size_bank0) * 256,
TOMBIT_F (bswap_16 (lnx_header.page_size_bank0) * 256),
bswap_16 (lnx_header.page_size_bank1) * 256,
TOMBIT_F (bswap_16 (lnx_header.page_size_bank1) * 256),
bswap_16 (lnx_header.version),
#else
lnx_header.page_size_bank0 * 256,
TOMBIT_F (lnx_header.page_size_bank0 * 256),
lnx_header.page_size_bank1 * 256,
TOMBIT_F (lnx_header.page_size_bank1 * 256),
lnx_header.version,
#endif
(!lnx_header.rotation) ? "No" : ((lnx_header.rotation == 1) ? "Left" : "Right"));
}
return result;
}
bool YapClient::sendSyncCommand()
{
char pktHeader[4] = { 0, 0, 0, 0 };
uint16_t pktLen;
char * ppp = 0;
if (d->cmdPacket->length() == 0) {
fprintf(stderr, "Command is empty\n");
return false;
}
pktLen = 0;
::memset(pktHeader, 0, sizeof(pktHeader));
pktLen = d->cmdPacket->length();
pktLen = bswap_16(pktLen);
::memcpy(pktHeader, &pktLen, 2);
pktHeader[3] = kPacketFlagSyncMask;
if (!writeSocket(d->cmdSocketFd, pktHeader, 4))
goto Detached;
if (!writeSocket(d->cmdSocketFd, (char*) d->cmdBuffer, d->cmdPacket->length()))
goto Detached;
pktLen = 0;
::memset(pktHeader, 0, sizeof(pktHeader));
if (!readSocketSync(d->cmdSocketFd, pktHeader, 4))
goto Detached;
ppp = ((char *)&pktHeader[0]);
pktLen = *((uint16_t*) ppp);
pktLen = bswap_16(pktLen);
if (pktLen > kMaxMsgLen) {
fprintf(stderr, "YAP: Message too large %u > %u\n", pktLen, kMaxMsgLen);
goto Detached;
}
if (!readSocketSync(d->cmdSocketFd, (char*) d->replyBuffer, pktLen))
goto Detached;
d->replyPacket->reset();
d->replyPacket->setReadTotalLength(pktLen);
return true;
Detached:
serverDisconnected();
closeMsgSocket();
closeCmdSocket();
return false;
}
void DeepStarComponent::byteSwap( starData *stardata ) {
stardata->RA = bswap_32( stardata->RA );
stardata->Dec = bswap_32( stardata->Dec );
stardata->dRA = bswap_32( stardata->dRA );
stardata->dDec = bswap_32( stardata->dDec );
stardata->parallax = bswap_32( stardata->parallax );
stardata->HD = bswap_32( stardata->HD );
stardata->mag = bswap_16( stardata->mag );
stardata->bv_index = bswap_16( stardata->bv_index );
}
static void ocfs2_swap_group_desc_header(struct ocfs2_group_desc *gd)
{
gd->bg_size = bswap_16(gd->bg_size);
gd->bg_bits = bswap_16(gd->bg_bits);
gd->bg_free_bits_count = bswap_16(gd->bg_free_bits_count);
gd->bg_chain = bswap_16(gd->bg_chain);
gd->bg_generation = bswap_32(gd->bg_generation);
gd->bg_next_group = bswap_64(gd->bg_next_group);
gd->bg_parent_dinode = bswap_64(gd->bg_parent_dinode);
gd->bg_blkno = bswap_64(gd->bg_blkno);
}
int cfg_blob_copy( blob_t *from, void *to ) {
size_t len = from->options & BLOB_LENGTH_MASK;
if( to != NULL ) {
if( is_host_endian( from ) ||
( ( from->options & BLOB_LENGTH_MASK ) == 1 )
)
__copy( from, to );
else {
__copy( from, to );
if( from->options & BLOB_ARRAY )
switch( len ) {
case 2:
for( char *limit = to + 2 * from->array.length, *cyc = to;
cyc < limit;
cyc += 2
)
bswap_16( *( ( uint16_t* ) cyc ) );
break;
case 4:
for( char *limit = to + 4 * from->array.length, *cyc = to;
cyc < limit;
cyc += 4
)
bswap_32( *( ( uint32_t* ) cyc ) );
break;
default:
for( char *limit = to + len * from->array.length, *cyc = to;
cyc < limit;
cyc += len
)
__swap_bytes( cyc, len );
}
else
switch( len ) {
case 2:
bswap_16( *( ( uint16_t* ) to ) );
break;
case 4:
bswap_32( *( ( uint32_t* ) to ) );
break;
default:
__swap_bytes( to, len );
};
}
}
if( from->options & BLOB_ARRAY )
return ( len * from->array.length )
else
return len;
}
int volume_id_probe_minix(struct volume_id *id, uint64_t off, uint64_t size)
{
uint8_t *buf;
struct minix_super_block *ms;
struct minix3_super_block *m3s;
info("probing at offset 0x%" PRIx64 "\n", off);
buf = volume_id_get_buffer(id, off + MINIX_SUPERBLOCK_OFFSET, 0x200);
if (buf == NULL)
return -1;
ms = (struct minix_super_block *) buf;
if (ms->s_magic == MINIX_SUPER_MAGIC ||
ms->s_magic == bswap_16(MINIX_SUPER_MAGIC)) {
strcpy(id->type_version, "1");
goto found;
}
if (ms->s_magic == MINIX_SUPER_MAGIC2 ||
ms->s_magic == bswap_16(MINIX_SUPER_MAGIC2)) {
strcpy(id->type_version, "1");
goto found;
}
if (ms->s_magic == MINIX2_SUPER_MAGIC ||
ms->s_magic == bswap_16(MINIX2_SUPER_MAGIC)) {
strcpy(id->type_version, "2");
goto found;
}
if (ms->s_magic == MINIX2_SUPER_MAGIC2 ||
ms->s_magic == bswap_16(MINIX2_SUPER_MAGIC2)) {
strcpy(id->type_version, "2");
goto found;
}
m3s = (struct minix3_super_block *) buf;
if (m3s->s_magic == MINIX3_SUPER_MAGIC ||
m3s->s_magic == bswap_16(MINIX3_SUPER_MAGIC)) {
strcpy(id->type_version, "3");
goto found;
}
goto exit;
found:
volume_id_set_usage(id, VOLUME_ID_FILESYSTEM);
id->type = "minix";
return 0;
exit:
return -1;
}
void ocfs2_swap_group_desc(struct ocfs2_group_desc *gd)
{
if (cpu_is_little_endian)
return;
gd->bg_size = bswap_16(gd->bg_size);
gd->bg_bits = bswap_16(gd->bg_bits);
gd->bg_free_bits_count = bswap_16(gd->bg_free_bits_count);
gd->bg_chain = bswap_16(gd->bg_chain);
gd->bg_generation = bswap_32(gd->bg_generation);
gd->bg_next_group = bswap_64(gd->bg_next_group);
gd->bg_parent_dinode = bswap_64(gd->bg_parent_dinode);
gd->bg_blkno = bswap_64(gd->bg_blkno);
}
bool YapClient::connect()
{
// connect to remote server
struct sockaddr_un socketAddr;
d->cmdSocketFd = ::socket(PF_LOCAL, SOCK_STREAM, 0);
if (d->cmdSocketFd < 0)
return false;
memset(&socketAddr, 0, sizeof(socketAddr));
socketAddr.sun_family = AF_LOCAL;
strncpy(socketAddr.sun_path, d->cmdSocketPath, G_N_ELEMENTS(socketAddr.sun_path));
socketAddr.sun_path[G_N_ELEMENTS(socketAddr.sun_path)-1] = '\0';
if (::connect(d->cmdSocketFd, (struct sockaddr*) &socketAddr,
SUN_LEN(&socketAddr)) != 0) {
close(d->cmdSocketFd);
d->cmdSocketFd = -1;
fprintf(stderr, "YAP: Failed to connect to server\n");
return false;
}
// send our msg server socket path
int16_t strLen = ::strlen(d->msgServerSocketPath);
int16_t pktLen = bswap_16(strLen);
if (!writeSocket(d->cmdSocketFd, (char*) &pktLen, 2))
return false;
if (!writeSocket(d->cmdSocketFd, d->msgServerSocketPath, strLen))
return false;
strLen = ::strlen(d->msgServerSocketPostfix);
pktLen = bswap_16(strLen);
if (!writeSocket(d->cmdSocketFd, (char*) &pktLen, 2))
return false;
if (!writeSocket(d->cmdSocketFd, d->msgServerSocketPostfix, strLen))
return false;
// Add io channel to know when the command socket is disconnected.
d->cmdIoChannel = g_io_channel_unix_new(d->cmdSocketFd);
d->cmdIoSource = g_io_create_watch(d->cmdIoChannel, (GIOCondition) (G_IO_HUP));
g_source_set_callback(d->cmdIoSource, (GSourceFunc) YapClientPriv::ioCallback, this, NULL);
g_source_attach(d->cmdIoSource, d->mainCtxt);
return true;
}
bool DeepStarComponent::openDataFile() {
if( starReader.getFileHandle() )
return true;
starReader.openFile( dataFileName );
fileOpened = false;
if( !starReader.getFileHandle() )
qDebug() << "WARNING: Failed to open deep star catalog " << dataFileName << ". Disabling it." << endl;
else if( !starReader.readHeader() )
qDebug() << "WARNING: Header read error for deep star catalog " << dataFileName << "!! Disabling it!" << endl;
else {
qint16 faintmag;
quint8 htm_level;
fread( &faintmag, 2, 1, starReader.getFileHandle() );
if( starReader.getByteSwap() )
faintmag = bswap_16( faintmag );
if( starReader.guessRecordSize() == 16 )
m_FaintMagnitude = faintmag / 1000.0;
else
m_FaintMagnitude = faintmag / 100.0;
fread( &htm_level, 1, 1, starReader.getFileHandle() );
qDebug() << "Processing " << dataFileName << ", HTMesh Level" << htm_level;
m_skyMesh = SkyMesh::Instance( htm_level );
if( !m_skyMesh ) {
if( !( m_skyMesh = SkyMesh::Create( htm_level ) ) ) {
qDebug() << "Could not create HTMesh of level " << htm_level << " for catalog " << dataFileName << ". Skipping it.";
return false;
}
}
meshLevel = htm_level;
fread( &MSpT, 2, 1, starReader.getFileHandle() );
if( starReader.getByteSwap() )
MSpT = bswap_16( MSpT );
fileOpened = true;
qDebug() << " Sky Mesh Size: " << m_skyMesh->size();
for (long int i = 0; i < m_skyMesh->size(); i++) {
StarBlockList *sbl = new StarBlockList( i, this );
if( !sbl ) {
qDebug() << "NULL starBlockList. Expect trouble!";
}
m_starBlockList.append( sbl );
}
m_zoomMagLimit = 0.06;
}
return fileOpened;
}
static int
vars_get_variable_size(efi_guid_t guid, const char *name, size_t *size)
{
int errno_value;
int ret = -1;
char *path = NULL;
int rc = asprintf(&path, VARS_PATH "%s-"GUID_FORMAT"/size",
name, guid.a, guid.b, guid.c, bswap_16(guid.d),
guid.e[0], guid.e[1], guid.e[2], guid.e[3],
guid.e[4], guid.e[5]);
if (rc < 0)
goto err;
long long int retsize = 0;
rc = get_size_from_file(path, &retsize);
if (rc >= 0) {
ret = 0;
*size = (size_t) retsize;
}
err:
errno_value = errno;
if (path)
free(path);
errno = errno_value;
return ret;
}
static void tpm_hash2pcr(struct xc_dom_image *dom, char *cmdline)
{
struct tpmfront_dev* tpm = init_tpmfront(NULL);
uint8_t *resp;
size_t resplen = 0;
struct pcr_extend_cmd cmd;
/* If all guests have access to a vTPM, it may be useful to replace this
* with ASSERT(tpm) to prevent configuration errors from allowing a guest
* to boot without a TPM (or with a TPM that has not been sent any
* measurements, which could allow forging the measurements).
*/
if (!tpm)
return;
cmd.tag = bswap_16(TPM_TAG_RQU_COMMAND);
cmd.size = bswap_32(sizeof(cmd));
cmd.ord = bswap_32(TPM_ORD_Extend);
cmd.pcr = bswap_32(4); // PCR #4 for kernel
sha1(dom->kernel_blob, dom->kernel_size, cmd.hash);
tpmfront_cmd(tpm, (void*)&cmd, sizeof(cmd), &resp, &resplen);
cmd.pcr = bswap_32(5); // PCR #5 for cmdline
sha1(cmdline, strlen(cmdline), cmd.hash);
tpmfront_cmd(tpm, (void*)&cmd, sizeof(cmd), &resp, &resplen);
cmd.pcr = bswap_32(5); // PCR #5 for initrd
sha1(dom->ramdisk_blob, dom->ramdisk_size, cmd.hash);
tpmfront_cmd(tpm, (void*)&cmd, sizeof(cmd), &resp, &resplen);
shutdown_tpmfront(tpm);
}
/* serialize channels data to the parcel. return parcel and its "size" */
static void *ParcelCtor(const struct Manifest *manifest,
uint32_t *size, uint32_t binds, uint32_t connects)
{
struct NSParcel *p;
int64_t end = binds + connects;
int64_t m = 0, n = 0;
int64_t i;
/* allocate parcel */
*size = sizeof *p + (end - 1) * sizeof(struct NSRecord);
p = g_malloc(*size);
/* parcel header */
p->node = bswap_32(manifest->node);
p->bind_number = bswap_32(binds);
p->connect_number = bswap_32(connects);
/* populate parcel with bind/connect records */
for(i = 0; i < end; ++i)
{
struct Connection *c;
NEXT_SRC();
p->records[i].host = bswap_32(c->host);
p->records[i].port = bswap_16(c->port);
}
return (void*)p;
}
/* commitchanges() writes the new headers back to the original file
* and sets the file to its new size.
*/
static int commitchanges(int fd, Elf_Ehdr const *ehdr, Elf_Phdr *phdrs,
unsigned long newsize)
{
size_t n;
unsigned long e_phoff;
short e_phnum;
e_phnum=ehdr->e_phnum;
if (swap_bytes) e_phnum=bswap_16(e_phnum);
e_phoff=ehdr->e_phoff;
#if (ELF_CLASS==ELFCLASS64)
if (swap_bytes) {
e_phoff=bswap_64(e_phoff);
}
#else
if (swap_bytes) {
e_phoff=bswap_32(e_phoff);
}
#endif
/* Save the changes to the ELF header, if any.
*/
if (lseek(fd, 0, SEEK_SET))
return ferr("could not rewind file");
errno = 0;
if (write(fd, ehdr, sizeof *ehdr) != sizeof *ehdr)
return err("could not modify file");
/* Save the changes to the program segment header table, if any.
*/
if (lseek(fd, e_phoff, SEEK_SET) == (off_t)-1) {
err("could not seek in file.");
goto warning;
}
n = e_phnum * sizeof *phdrs;
if (write(fd, phdrs, n) != (ssize_t)n) {
err("could not write to file");
goto warning;
}
/* Eleventh-hour sanity check: don't truncate before the end of
* the program segment header table.
*/
if (newsize < e_phoff + n)
newsize = e_phoff + n;
/* Chop off the end of the file.
*/
if (ftruncate(fd, newsize)) {
err("could not resize file");
goto warning;
}
return 1;
warning:
return err("ELF file may have been corrupted!");
}
static int
lynx_b (st_rominfo_t *rominfo, int bank, const char *value)
{
st_lnx_header_t header;
short int *bankvar;
char dest_name[FILENAME_MAX];
if (!rominfo->buheader_len)
{
fprintf (stderr, "ERROR: This is no LNX file\n\n");
return -1;
}
ucon64_fread (&header, 0, sizeof (st_lnx_header_t), ucon64.rom);
bankvar = (bank == 0 ? &header.page_size_bank0 : &header.page_size_bank1);
if ((atol (value) % 64) != 0 || (atol (value) > 512))
*bankvar = 0;
else
#ifdef WORDS_BIGENDIAN
*bankvar = bswap_16 (atol (value) * 4);
#else
*bankvar = atol (value) * 4;
#endif
strcpy (dest_name, ucon64.rom);
ucon64_file_handler (dest_name, NULL, 0);
fcopy (ucon64.rom, 0, ucon64.file_size, dest_name, "wb");
ucon64_fwrite (&header, 0, sizeof (st_lnx_header_t), dest_name, "r+b");
printf (ucon64_msg[WROTE], dest_name);
return 0;
}
size_t EndianStream::writeUInt16(uint16_t value) {
debug_assertp(_stream!=NULL, this, "Wrapped stream cannot be NULL");
if (_order!=DUCT_BYTEORDER) {
value=bswap_16(value);
}
return _stream->writeUInt16(value);
}
long long read_factors(string filename, dd::FactorGraph &fg)
{
ifstream file;
file.open(filename.c_str(), ios::in | ios::binary);
long long count = 0;
long long id;
long long weightid;
short type;
long long edge_count;
while (file.good()) {
file.read((char *)&id, 8);
file.read((char *)&weightid, 8);
file.read((char *)&type, 2);
if (!file.read((char *)&edge_count, 8)) break;
id = bswap_64(id);
weightid = bswap_64(weightid);
type = bswap_16(type);
edge_count = bswap_64(edge_count);
count++;
fg.factors[fg.c_nfactor] = dd::Factor(id, weightid, type, edge_count);
fg.c_nfactor ++;
}
file.close();
return count;
}
static void unpack_nbuf16_swap(nbuf *x) {
unsigned i;
for (i = x->used; i; --i) {
x->data.raw[i - 1] = bswap_16(x->data.u16[i - 1]) + x->min;
}
}
/**
* Send a GLX reply to the client.
*
* Technically speaking, there are several different ways to encode a GLX
* reply. The primary difference is whether or not certain fields (e.g.,
* retval, size, and "pad3") are set. This function gets around that by
* always setting all of the fields to "reasonable" values. This does no
* harm to clients, but it does make the server-side code much more compact.
*
* \warning
* This function assumes that values stored in \c data will be byte-swapped
* by the caller if necessary.
*/
void
__glXSendReplySwap( ClientPtr client, const void * data, size_t elements,
size_t element_size, GLboolean always_array, CARD32 retval )
{
size_t reply_ints = 0;
if ( __glXErrorOccured() ) {
elements = 0;
}
else if ( (elements > 1) || always_array ) {
reply_ints = bytes_to_int32(elements * element_size);
}
__glXReply.length = bswap_32( reply_ints );
__glXReply.type = X_Reply;
__glXReply.sequenceNumber = bswap_16( client->sequence );
__glXReply.size = bswap_32( elements );
__glXReply.retval = bswap_32( retval );
/* It is faster on almost always every architecture to just copy the 8
* bytes, even when not necessary, than check to see of the value of
* elements requires it. Copying the data when not needed will do no
* harm.
*/
(void) memcpy( & __glXReply.pad3, data, 8 );
WriteToClient( client, sz_xGLXSingleReply, (char *) & __glXReply );
if ( reply_ints != 0 ) {
WriteToClient( client, reply_ints * 4, (char *) data );
}
}
static inline void u16_to_uuid128(void *dst, uint16_t u16)
{
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
u16 = bswap_16(u16);
#endif
memcpy(dst, &u16, 2);
}
uint64_t elf_access_unsigned(struct elf_binary * elf, elf_ptrval base,
uint64_t moreoffset, size_t size)
{
elf_ptrval ptrval = base + moreoffset;
bool need_swap = elf_swap(elf);
const uint8_t *u8;
const uint16_t *u16;
const uint32_t *u32;
const uint64_t *u64;
if ( !elf_access_ok(elf, ptrval, size) )
return 0;
switch ( size )
{
case 1:
u8 = (const void*)ptrval;
return *u8;
case 2:
u16 = (const void*)ptrval;
return need_swap ? bswap_16(*u16) : *u16;
case 4:
u32 = (const void*)ptrval;
return need_swap ? bswap_32(*u32) : *u32;
case 8:
u64 = (const void*)ptrval;
return need_swap ? bswap_64(*u64) : *u64;
default:
return 0;
}
}
// ----------------------------------------------------------------------------------------------
// Put 'Image' to window.
// ----------------------------------------------------------------------------------------------
void wsConvert( wsTWindow * win,unsigned char * Image,unsigned int Size )
{
const uint8_t *src[4] = { Image, NULL, NULL, NULL };
int src_stride[4] = { 4 * win->xImage->width, 0, 0, 0 };
uint8_t *dst[4] = { win->ImageData, NULL, NULL, NULL };
int dst_stride[4];
int i;
sws_ctx = sws_getCachedContext(sws_ctx, win->xImage->width, win->xImage->height, PIX_FMT_RGB32,
win->xImage->width, win->xImage->height, out_pix_fmt,
SWS_POINT, NULL, NULL, NULL);
av_image_fill_linesizes(dst_stride, out_pix_fmt, win->xImage->width);
sws_scale(sws_ctx, src, src_stride, 0, win->xImage->height, dst, dst_stride);
if (!wsNonNativeOrder) return;
switch (win->xImage->bits_per_pixel) {
case 32:
{
uint32_t *d = (uint32_t *) win->ImageData;
for (i = 0; i < win->xImage->width * win->xImage->height; i++)
d[i] = bswap_32(d[i]);
break;
}
case 16:
case 15:
{
uint16_t *d = (uint16_t *) win->ImageData;
for (i = 0; i < win->xImage->width * win->xImage->height; i++)
d[i] = bswap_16(d[i]);
break;
}
}
}
void video_recording_state_t::write_audio_frame(uint8 *buffer)
{
AVCodecContext *c = audio_stream->codec;
av_samples_fill_arrays(audio_frame->data, audio_frame->linesize, buffer, 2, 2048, AV_SAMPLE_FMT_S16, 0);
uint16 *base = (uint16 *)audio_frame->data[0];
for (int i = 0; i < 4096; ++i) {
*base = bswap_16(*base);
++base;
}
AVPacket pkt;
int got_packet = 0;
av_init_packet(&pkt);
pkt.data = NULL;
pkt.size = 0;
if (avcodec_encode_audio2(c, &pkt, audio_frame, &got_packet) < 0) {
fprintf(stderr, "Error encoding an audio frame\n");
}
if (got_packet) {
pkt.pts = pkt.dts = audio_frame->pts++;
pkt.stream_index = audio_stream->index;
if (av_interleaved_write_frame(output_context, &pkt) < 0) {
fprintf(stderr, "Error writing an audio frame\n");
}
if (av_interleaved_write_frame(output_context, NULL) < 0) {
fprintf(stderr, "Error flushing output buffer\n");
}
}
}
void bswap_block (void *ptr, size_t membsize, size_t nmemb) {
int i;
#if BYTE_ORDER==BIG_ENDIAN
for (i = 0 ; i < nmemb ; i++)
switch (membsize) {
case 2:
{
u_int16_t *r = (u_int16_t *)ptr;
for (i = 0 ; i < nmemb ; i++)
r[i] = bswap_16 (r[i]);
break;
}
case 4:
{
u_int32_t *r = (u_int32_t *)ptr;
for (i = 0 ; i < nmemb ; i++)
r[i] = bswap_32 (r[i]);
break;
}
}
#endif
}
