/* a stereo sine-wave 16bps stream */ static FLAC__bool generate_sine16_2(const char *fn, const double sample_rate, const unsigned samples, const double f1, const double a1, const double f2, const double a2, double fmult) { const FLAC__int16 full_scale = 32767; const double delta1 = 2.0 * M_PI / ( sample_rate / f1); const double delta2 = 2.0 * M_PI / ( sample_rate / f2); FILE *f; double theta1, theta2; unsigned i; if(0 == (f = fopen(fn, mode))) return false; for(i = 0, theta1 = theta2 = 0.0; i < samples; i++, theta1 += delta1, theta2 += delta2) { double val = (a1*sin(theta1) + a2*sin(theta2))*(double)full_scale; FLAC__int16 v = (FLAC__int16)(val + 0.5); swap16(&v); if(fwrite(&v, sizeof(v), 1, f) < 1) goto foo; val = -(a1*sin(theta1*fmult) + a2*sin(theta2*fmult))*(double)full_scale; v = (FLAC__int16)(val + 0.5); swap16(&v); if(fwrite(&v, sizeof(v), 1, f) < 1) goto foo; } fclose(f); return true; foo: fclose(f); return false; }
static void correct_data(struct SS_GAMEPAD *data) { data->motion.acc_x = swap16(data->motion.acc_x) - zeroG; data->motion.acc_y = swap16(data->motion.acc_y) - zeroG; data->motion.acc_z = swap16(data->motion.acc_z) - zeroG; data->motion.z_gyro = swap16(data->motion.z_gyro) - zeroG; }
void ar9380_swap_rom(struct athn_softc *sc) { #if BYTE_ORDER == BIG_ENDIAN struct ar9380_eeprom *eep = sc->eep; struct ar9380_base_eep_hdr *base = &eep->baseEepHeader; struct ar9380_modal_eep_header *modal; int i; base->regDmn[0] = swap16(base->regDmn[0]); base->regDmn[1] = swap16(base->regDmn[1]); base->swreg = swap32(base->swreg); modal = &eep->modalHeader2G; modal->antCtrlCommon = swap32(modal->antCtrlCommon); modal->antCtrlCommon2 = swap32(modal->antCtrlCommon2); modal->papdRateMaskHt20 = swap32(modal->papdRateMaskHt20); modal->papdRateMaskHt40 = swap32(modal->papdRateMaskHt40); for (i = 0; i < AR9380_MAX_CHAINS; i++) modal->antCtrlChain[i] = swap16(modal->antCtrlChain[i]); modal = &eep->modalHeader5G; modal->antCtrlCommon = swap32(modal->antCtrlCommon); modal->antCtrlCommon2 = swap32(modal->antCtrlCommon2); modal->papdRateMaskHt20 = swap32(modal->papdRateMaskHt20); modal->papdRateMaskHt40 = swap32(modal->papdRateMaskHt40); for (i = 0; i < AR9380_MAX_CHAINS; i++) modal->antCtrlChain[i] = swap16(modal->antCtrlChain[i]); #endif }
static void swap_old_header(struct s_ospcl *os) { os->c_type = swap32(os->c_type); os->c_date = swap32(os->c_date); os->c_ddate = swap32(os->c_ddate); os->c_volume = swap32(os->c_volume); os->c_tapea = swap32(os->c_tapea); os->c_inumber = swap16(os->c_inumber); os->c_magic = swap32(os->c_magic); os->c_checksum = swap32(os->c_checksum); os->c_odinode.odi_mode = swap16(os->c_odinode.odi_mode); os->c_odinode.odi_nlink = swap16(os->c_odinode.odi_nlink); os->c_odinode.odi_uid = swap16(os->c_odinode.odi_uid); os->c_odinode.odi_gid = swap16(os->c_odinode.odi_gid); os->c_odinode.odi_size = swap32(os->c_odinode.odi_size); os->c_odinode.odi_rdev = swap32(os->c_odinode.odi_rdev); os->c_odinode.odi_atime = swap32(os->c_odinode.odi_atime); os->c_odinode.odi_mtime = swap32(os->c_odinode.odi_mtime); os->c_odinode.odi_ctime = swap32(os->c_odinode.odi_ctime); os->c_count = swap32(os->c_count); }
/* a stereo wasted-bits-per-sample 16bps stream */ static FLAC__bool generate_wbps16(const char *fn, unsigned samples) { FILE *f; unsigned sample; if(0 == (f = fopen(fn, mode))) return false; for(sample = 0; sample < samples; sample++) { FLAC__int16 l = (sample % 2000) << 2; FLAC__int16 r = (sample % 1000) << 3; swap16(&l); swap16(&r); if(fwrite(&l, sizeof(l), 1, f) < 1) goto foo; if(fwrite(&r, sizeof(r), 1, f) < 1) goto foo; } fclose(f); return true; foo: fclose(f); return false; }
bool WvOut :: setWavFile( const char *fileName ) { char name[128]; strncpy(name, fileName, 128); if ( strstr(name, ".wav") == NULL) strcat(name, ".wav"); fd = fopen(name, "wb"); if ( !fd ) { sprintf(msg, "WvOut: Could not create WAV file: %s", name); return false; } struct wavhdr hdr = {"RIF", 44, "WAV", "fmt", 16, 1, 1, (SINT32) Stk::sampleRate(), 0, 2, 16, "dat", 0}; hdr.riff[3] = 'F'; hdr.wave[3] = 'E'; hdr.fmt[3] = ' '; hdr.data[3] = 'a'; hdr.num_chans = (SINT16) channels; if ( dataType == STK_SINT8 ) hdr.bits_per_samp = 8; else if ( dataType == STK_SINT16 ) hdr.bits_per_samp = 16; else if ( dataType == STK_SINT32 ) hdr.bits_per_samp = 32; else if ( dataType == MY_FLOAT32 ) { hdr.format_tag = 3; hdr.bits_per_samp = 32; } else if ( dataType == MY_FLOAT64 ) { hdr.format_tag = 3; hdr.bits_per_samp = 64; } hdr.bytes_per_samp = (SINT16) (channels * hdr.bits_per_samp / 8); hdr.bytes_per_sec = (SINT32) (hdr.sample_rate * hdr.bytes_per_samp); byteswap = false; #ifndef __LITTLE_ENDIAN__ byteswap = true; swap32((unsigned char *)&hdr.file_size); swap32((unsigned char *)&hdr.chunk_size); swap16((unsigned char *)&hdr.format_tag); swap16((unsigned char *)&hdr.num_chans); swap32((unsigned char *)&hdr.sample_rate); swap32((unsigned char *)&hdr.bytes_per_sec); swap16((unsigned char *)&hdr.bytes_per_samp); swap16((unsigned char *)&hdr.bits_per_samp); #endif if ( fwrite(&hdr, 4, 11, fd) != 11 ) { sprintf(msg, "WvOut: Could not write WAV header for file %s", name); return false; } printf("\nCreating WAV file: %s\n", name); return true; }
void test_macros() { assert(swap16(0) == 0); assert(swap16(0x0102) == 0x0201); assert(swap32(0) == 0); assert(swap32(0x01020304) == 0x04030201); assert(swap64(0) == 0); assert(swap64(0x0102030405060708ULL) == 0x0807060504030201ULL); }
bool WvOut :: setWavFile( const char *fileName ) { char name[8192]; strncpy(name, fileName, 8192); if ( strstr(name, ".wav") == NULL) strcat(name, ".wav"); fd_ = fopen(name, "wb"); if ( !fd_ ) { errorString_ << "WvOut: could not create WAV file: " << name; return false; } struct wavhdr hdr = {"RIF", 44, "WAV", "fmt", 16, 1, 1, (SINT32) Stk::sampleRate(), 0, 2, 16, "dat", 0}; hdr.riff[3] = 'F'; hdr.wave[3] = 'E'; hdr.fmt[3] = ' '; hdr.data[3] = 'a'; hdr.num_chans = (SINT16) channels_; if ( dataType_ == STK_SINT8 ) hdr.bits_per_samp = 8; else if ( dataType_ == STK_SINT16 ) hdr.bits_per_samp = 16; else if ( dataType_ == STK_SINT32 ) hdr.bits_per_samp = 32; else if ( dataType_ == STK_FLOAT32 ) { hdr.format_tag = 3; hdr.bits_per_samp = 32; } else if ( dataType_ == STK_FLOAT64 ) { hdr.format_tag = 3; hdr.bits_per_samp = 64; } hdr.bytes_per_samp = (SINT16) (channels_ * hdr.bits_per_samp / 8); hdr.bytes_per_sec = (SINT32) (hdr.sample_rate * hdr.bytes_per_samp); byteswap_ = false; #ifndef __LITTLE_ENDIAN__ byteswap_ = true; swap32((unsigned char *)&hdr.file_size); swap32((unsigned char *)&hdr.chunk_size); swap16((unsigned char *)&hdr.format_tag); swap16((unsigned char *)&hdr.num_chans); swap32((unsigned char *)&hdr.sample_rate); swap32((unsigned char *)&hdr.bytes_per_sec); swap16((unsigned char *)&hdr.bytes_per_samp); swap16((unsigned char *)&hdr.bits_per_samp); #endif if ( fwrite(&hdr, 4, 11, fd_) != 11 ) { errorString_ << "WvOut: could not write WAV header for file " << name << '.'; return false; } errorString_ << "WvOut: creating WAV file: " << name; handleError( StkError::WARNING ); return true; }
static u32 swap32 (u32 value) { u16 l, h; conv32to16 (value, &l, &h); conv16to32 (swap16 (h), swap16 (l), &value); return value; }
/* * reimplement pcap_open_offline with privsep, this is the * unprivileged part. * XXX merge with above? */ static void swap_hdr(struct pcap_file_header *hp) { hp->version_major = swap16(hp->version_major); hp->version_minor = swap16(hp->version_minor); hp->thiszone = swap32(hp->thiszone); hp->sigfigs = swap32(hp->sigfigs); hp->snaplen = swap32(hp->snaplen); hp->linktype = swap32(hp->linktype); }
//---------------------------------------------------------------------- static void swap_pef_reloc_header(pef_reloc_header_t &prh) { #if __MF__ qnotused(prh); #else prh.sectionIndex = swap16(prh.sectionIndex); prh.reservedA = swap16(prh.reservedA); prh.relocCount = swap32(prh.relocCount); prh.firstRelocOffset = swap32(prh.firstRelocOffset); #endif }
void readff(const char * filename) { std::string temp(filename); if(temp.size() <= 3) { puts("fixing filename"); temp += ".ff"; filename = temp.data(); } // Unfortunately I have to duplicate code or else use gotos or logic variables. else if(temp.substr(temp.length()-3) != ".ff") { puts("fixing filename"); temp += ".ff"; filename = temp.data(); } FILE* file = fopen(filename, "rb"); printf("reading file %s\n", filename); if(file != NULL) { char name[8]; fread(name, 1, 8, file); printf("%.8s -- header magic\n", name); if(memcmp(name, "farbfeld", 8) == 0) { { unsigned int scratch[2]; fread(scratch, 4, 2, file); width = swap32(scratch[0]); height = swap32(scratch[1]); std::cout << width << " " << height << " -- dimensions\n"; dimensions(width, height); } for(auto& t : data) { unsigned short scratch[4]; fread(scratch, 2, 4, file); t.r = swap16(scratch[0])*1.0/0xFFFF; t.g = swap16(scratch[1])*1.0/0xFFFF; t.b = swap16(scratch[2])*1.0/0xFFFF; } } else puts("Not a valid farbfeld file."); fclose(file); std::cout << data.size() << " -- number of pixels in farbfeld\n"; } else puts("Error opening file."); }
char *devprop_generate_string(struct DevPropString *string) { char *buffer = (char*)MALLOC(string->length * 2); char *ptr = buffer; if(!buffer) return NULL; sprintf(buffer, "%08x%08x%04x%04x", swap32(string->length), string->WHAT2, swap16(string->numentries), string->WHAT3); buffer += 24; int i = 0, x = 0; while(i < string->numentries) { sprintf(buffer, "%08x%04x%04x", swap32(string->entries[i]->length), swap16(string->entries[i]->numentries), string->entries[i]->WHAT2); buffer += 16; sprintf(buffer, "%02x%02x%04x%08x%08x", string->entries[i]->acpi_dev_path.type, string->entries[i]->acpi_dev_path.subtype, swap16(string->entries[i]->acpi_dev_path.length), string->entries[i]->acpi_dev_path._HID, swap32(string->entries[i]->acpi_dev_path._UID)); buffer += 24; for(x=0; x < string->entries[i]->num_pci_devpaths; x++) { sprintf(buffer, "%02x%02x%04x%02x%02x", string->entries[i]->pci_dev_path[x].type, string->entries[i]->pci_dev_path[x].subtype, swap16(string->entries[i]->pci_dev_path[x].length), string->entries[i]->pci_dev_path[x].function, string->entries[i]->pci_dev_path[x].device); buffer += 12; } sprintf(buffer, "%02x%02x%04x", string->entries[i]->path_end.type, string->entries[i]->path_end.subtype, swap16(string->entries[i]->path_end.length)); buffer += 8; uint8_t *dataptr = string->entries[i]->data; for(x = 0; x < (string->entries[i]->length) - (24 + (6 * string->entries[i]->num_pci_devpaths)) ; x++) { sprintf(buffer, "%02x", *dataptr++); buffer += 2; } i++; } return ptr; }
static void sibling_extent(ffs_sort_t *entry, uint32_t size_sib_entry, block_info_t *block_info){ f3s_extptr_t next, dir_next; f3s_head_t dir_extent; uint32_t pos, nbytes; uint16_t extent_flags; // // Setup 'next' pointer to new extent // dir_next.logi_unit = swap16(target_endian,block_info->block_index + 1); dir_next.index = swap16(target_endian,block_info->extent_index); // // now write the entry to the correct place // 'next' entry is // pos = entry->extent_pos; lseek(flashimage, pos, SEEK_SET); if (read(flashimage,&dir_extent,sizeof(dir_extent)) != sizeof(dir_extent)) mk_flash_exit("read failed: %s\n",strerror(errno)); dir_extent.status &= swap16(target_endian,~F3S_EXT_NO_NEXT); dir_extent.next = dir_next; lseek(flashimage, pos, SEEK_SET); memcpy(blk_buffer_ptr,&dir_extent, sizeof(dir_extent)); if ((nbytes = write(flashimage,blk_buffer_ptr,sizeof(dir_extent))) !=sizeof(dir_extent)) mk_flash_exit("write failed: %s\n",strerror(errno)); entry->status |=FFS_SORT_ENTRY_SET; // // write extent for the new entry // extent_flags = ~F3S_EXT_TYPE & 0xff00; extent_flags |= (F3S_EXT_DIR | F3S_EXT_NO_NEXT | F3S_EXT_NO_SUPER | F3S_EXT_ALLOC | F3S_EXT_LAST | F3S_EXT_NO_SPLIT); next.logi_unit = FNULL; next.index = FNULL; write_extent(block_info, next, extent_flags, size_sib_entry); }
static size_t __icmp_echo(icmp_hdr_t *hdr, uint8_t type, uint16_t id, uint16_t seq, void *data, size_t dlen) { loc_t pkt; hdr->ping.id = swap16(id); hdr->ping.seq = swap16(seq); pkt.addr = hdr; pkt.linear += sizeof(icmp_hdr_t); memcpy(pkt.addr, data, dlen); return __icmp_gen(hdr, type, 0, dlen); }
//---------------------------------------------------------------------- static void swap_pef(pef_t &pef) { #if __MF__ qnotused(pef); #else pef.formatVersion = swap32(pef.formatVersion); pef.dateTimeStamp = swap32(pef.dateTimeStamp); pef.oldDefVersion = swap32(pef.oldDefVersion); pef.oldImpVersion = swap32(pef.oldImpVersion); pef.currentVersion = swap32(pef.currentVersion); pef.reservedA = swap32(pef.reservedA); pef.sectionCount = swap16(pef.sectionCount); pef.instSectionCount = swap16(pef.instSectionCount); #endif }
}int udpCreateSocket(int8u bindOption, int32u ip, int16u port, int8u seq) { int8u buf[9]; buf[0] = SNIC_UDP_CREATE_SOCKET_REQ; buf[1] = seq; buf[2] = bindOption; if (bindOption) { int32u myip = swap32(ip); int16u myport = swap16(port); memcpy(buf+3, (int8u*)&myip, 4); memcpy(buf+7, (int8u*)&myport, 2); serial_transmit(CMD_ID_SNIC, buf, 9, ACK_NOT_REQUIRED); } else serial_transmit(CMD_ID_SNIC, buf, 3, ACK_NOT_REQUIRED); printf("-udpCreateSocket\n\r"); while (1) { if(SN8200_API_HasInput()) { ProcessSN8200Input(); } if(IsCreateSocketResponsed) { IsCreateSocketResponsed = false; break; } mdelay(1); } return 0; }int udpSendFromSock(int32u ip, int16u iPort, int8u shortsock, int8u conMode, int8u *sendbuf, int16u len, int8u seq)
}int udpSendFromSock(int32u ip, int16u iPort, int8u shortsock, int8u conMode, int8u *sendbuf, int16u len, int8u seq) { int8u buf[2048+12]; int16u mybufsize; if (len == 0 || len > MAX_BUFFER_SIZE) { len = MAX_BUFFER_SIZE; } buf[0] = SNIC_UDP_SEND_FROM_SOCKET_REQ; buf[1] = seq; memcpy(buf+2, (int8u*)&ip, 4); memcpy(buf+6, (int8u*)&iPort, 2); buf[8] = shortsock; buf[9] = conMode; mybufsize = swap16(len); memcpy(buf+10, (int8u*)&mybufsize, 2); memcpy(buf+12, sendbuf, len); serial_transmit(CMD_ID_SNIC, buf, 12+len, ACK_NOT_REQUIRED); printf("-udpSendFromSock\n\r"); timeout = 10000; while (timeout--) { if(SN8200_API_HasInput()) { ProcessSN8200Input(); } if(sendUDPDone) { sendUDPDone = 0; break; } mdelay(1); } return 0; }int udpStartRecv(int32u sock, int16u bufsize, int8u seq)
Psmf::Psmf(u32 data) { headerOffset = data; magic = Memory::Read_U32(data); version = Memory::Read_U32(data + 4); streamOffset = swap32(Memory::Read_U32(data + 8)); streamSize = swap32(Memory::Read_U32(data + 12)); streamDataTotalSize = swap32(Memory::Read_U32(data + 0x50)); presentationStartTime = getMpegTimeStamp(Memory::GetPointer(data + PSMF_FIRST_TIMESTAMP_OFFSET)); presentationEndTime = getMpegTimeStamp(Memory::GetPointer(data + PSMF_LAST_TIMESTAMP_OFFSET)); streamDataNextBlockSize = swap32(Memory::Read_U32(data + 0x6A)); streamDataNextInnerBlockSize = swap32(Memory::Read_U32(data + 0x7C)); numStreams = swap16(Memory::Read_U16(data + 0x80)); currentStreamNum = -1; currentAudioStreamNum = -1; currentVideoStreamNum = -1; for (int i = 0; i < numStreams; i++) { PsmfStream *stream = 0; u32 currentStreamAddr = data + 0x82 + i * 16; int streamId = Memory::Read_U8(currentStreamAddr); if ((streamId & PSMF_VIDEO_STREAM_ID) == PSMF_VIDEO_STREAM_ID) { stream = new PsmfStream(PSMF_AVC_STREAM, ++currentVideoStreamNum); stream->readMPEGVideoStreamParams(currentStreamAddr, this); } else if ((streamId & PSMF_AUDIO_STREAM_ID) == PSMF_AUDIO_STREAM_ID) { stream = new PsmfStream(PSMF_ATRAC_STREAM, ++currentAudioStreamNum); stream->readPrivateAudioStreamParams(currentStreamAddr, this); } if (stream) { currentStreamNum++; streamMap[currentStreamNum] = stream; } } }
}int fillNSendHttpReq(int8u seq, char* domain, char* uri, char method, char* contentType, char* otherHeader, int contentLen, char* content, unsigned char timeout, char moreData, char isHttps) { char *ptr = NULL; int8u buf[1024]; int16u encodedLen = moreData?contentLen|0x8000:contentLen; memset(buf, 0, sizeof(buf)); buf[0] = SNIC_HTTP_REQ; buf[1] = seq; *((int16u*)&buf[2]) = 0x5000; //swapped buf[4] = method; buf[5] = timeout; if (isHttps) { buf[0] = SNIC_HTTPS_REQ; *((int16u*)&buf[2]) = 0xbb01; // 443 swapped } ptr = (char*)buf+6; ptr += sprintf(ptr, "%s", domain)+1; ptr += sprintf(ptr, "%s", uri)+1; ptr += sprintf(ptr, "%s", contentType)+1; ptr += sprintf(ptr, "%s", otherHeader)+1; *((int16u*)ptr) = swap16(encodedLen); ptr += 2; if (contentLen) memcpy(ptr, content, contentLen); serial_transmit(CMD_ID_SNIC, buf, ptr-(char*)buf+contentLen, ACK_NOT_REQUIRED); return 0; }/*add HttpMoreReq cmd*/
FXbool InputPlugin::read_int16_be(FXshort & value) { if (read(&value,2)==2) { value = swap16(value); return true; } return false; }
//------------------------------------------------------------------------- static void swap_prc(DatabaseHdrType &h) { h.attributes = swap16(h.attributes); h.version = swap16(h.version); h.creationDate = swap32(h.creationDate); h.modificationDate = swap32(h.modificationDate); h.lastBackupDate = swap32(h.lastBackupDate); h.modificationNumber = swap32(h.modificationNumber); h.appInfoID = swap32(h.appInfoID); h.sortInfoID = swap32(h.sortInfoID); // h.type = swap32(h.type); // h.id = swap32(h.id); h.uniqueIDSeed = swap32(h.uniqueIDSeed); h.nextRecordListID = swap32(h.nextRecordListID); h.numRecords = swap16(h.numRecords); }
long cdda_read(cdrom_drive *d, void *buffer, long beginsector, long sectors){ if(d->opened){ if(sectors>0){ sectors=d->read_audio(d,buffer,beginsector,sectors); if(sectors!=-1){ /* byteswap? */ if(d->bigendianp==-1) /* not determined yet */ d->bigendianp=data_bigendianp(d); if(d->bigendianp!=bigendianp()){ int i; u_int16_t *p=(u_int16_t *)buffer; long els=sectors*CD_FRAMESIZE_RAW/2; for(i=0;i<els;i++)p[i]=swap16(p[i]); } } } return(sectors); } cderror(d,"400: Device not open\n"); return(-400); }
}int getTCPinfo(void) { char tempIPstr[32]; char teststr[8]; if (strlen(IPstr)==0) strcpy(IPstr, "192.168.10.101"); if (strlen(Portstr)==0) strcpy(Portstr, "0x6990"); printf("Enter server IP to connect: \n\r"); scanf("%s", tempIPstr); printf("\n\r"); if (strlen(tempIPstr)) strcpy(IPstr, tempIPstr); destIP = inet_addr(IPstr); if (destIP == INADDR_NONE || destIP == INADDR_ANY) { return CMD_ERROR; } printf("Enter server port number: \n\r"); scanf("%s", teststr); printf("\n\r"); if (strlen(teststr)) strcpy(Portstr, teststr); destPort = strtol(Portstr, NULL, 0); destPort = swap16(destPort); if (destPort > 0xFFFF) { printf("Invalid port, max limit 0xFFFF \n\r"); return CMD_ERROR; } return 0; }int setTCPinfo(void)
/* a mono full-scale deflection 16bps stream */ static FLAC__bool generate_fsd16(const char *fn, const int pattern[], unsigned reps) { FILE *f; unsigned rep, p; FLAC__ASSERT(pattern != 0); if(0 == (f = fopen(fn, mode))) return false; for(rep = 0; rep < reps; rep++) { for(p = 0; pattern[p]; p++) { FLAC__int16 x = pattern[p] > 0? 32767 : -32768; swap16(&x); if(fwrite(&x, sizeof(x), 1, f) < 1) goto foo; } } fclose(f); return true; foo: fclose(f); return false; }
void PortableFile::write16(uint16 value) { if (system_big_endian != big_endian_) { value = swap16(value); } f_.write((const char *)&value, 2); }
}int tcpConnectToServer(int8u shortSock, int32u ip, int16u port, int16u bufsize, int8u timeout, int8u seq) { int8u buf[12]; if (bufsize == 0 || bufsize > MAX_BUFFER_SIZE) { bufsize = MAX_BUFFER_SIZE; } buf[0] = SNIC_TCP_CONNECT_TO_SERVER_REQ; buf[1] = seq; buf[2] = shortSock; memcpy(buf+3, (int8u*)&ip, 4); memcpy(buf+7, (int8u*)&port, 2); bufsize = swap16(bufsize); memcpy(buf+9, (int8u*)&bufsize, 2); buf[11] = timeout; serial_transmit(CMD_ID_SNIC, buf, 12, ACK_NOT_REQUIRED); printf("-tcpConnectToServer\n\r"); mdelay(1000); //Wait module return value while (1) { if(SN8200_API_HasInput()) { ProcessSN8200Input(); } if(IsSNICTCPConnectToServerResponsed) { IsSNICTCPConnectToServerResponsed = false; break; } mdelay(1); } return 0; }int tcpCreateConnection(int8u shortSock, int16u size, int8u maxClient, int8u seq)
}int sendFromSock(int8u shortSocket, int8u * sendBuf, int16u len, int8u timeout, int8u seq) { int8u buf[MAX_BUFFER_SIZE+6]; int16u mybufsize; if (len == 0 || len > MAX_BUFFER_SIZE) { len = MAX_BUFFER_SIZE; } buf[0] = SNIC_SEND_FROM_SOCKET_REQ; buf[1] = seq; buf[2] = shortSocket; buf[3] = 0; mybufsize = swap16(len); memcpy(buf+4, (int8u*)&mybufsize, 2); memcpy(buf+6, sendBuf, len); serial_transmit(CMD_ID_SNIC, buf, 6+len, ACK_NOT_REQUIRED); printf("-sendFromSock\n\r"); while (1) { if(SN8200_API_HasInput()) { ProcessSN8200Input(); } if(IsSNICSendFromSocketResponsed) { IsSNICSendFromSocketResponsed = false; break; } mdelay(1); } return 0; }int udpCreateSocket(int8u bindOption, int32u ip, int16u port, int8u seq)
void WvOut :: writeData( unsigned long frames ) { if ( dataType == STK_SINT8 ) { if ( fileType == WVOUT_WAV ) { // 8-bit WAV data is unsigned! unsigned char sample; for ( unsigned long k=0; k<frames*channels; k++ ) { sample = (unsigned char) (data[k] * 127.0 + 128.0); if ( fwrite(&sample, 1, 1, fd) != 1 ) goto error; } } else { signed char sample; for ( unsigned long k=0; k<frames*channels; k++ ) { sample = (signed char) (data[k] * 127.0); //sample = ((signed char) (( data[k] + 1.0 ) * 127.5 + 0.5)) - 128; if ( fwrite(&sample, 1, 1, fd) != 1 ) goto error; } } } else if ( dataType == STK_SINT16 ) { SINT16 sample; for ( unsigned long k=0; k<frames*channels; k++ ) { sample = (SINT16) (data[k] * 32767.0); //sample = ((SINT16) (( data[k] + 1.0 ) * 32767.5 + 0.5)) - 32768; if ( byteswap ) swap16( (unsigned char *)&sample ); if ( fwrite(&sample, 2, 1, fd) != 1 ) goto error; } } else if ( dataType == STK_SINT32 ) { SINT32 sample; for ( unsigned long k=0; k<frames*channels; k++ ) { sample = (SINT32) (data[k] * 2147483647.0); //sample = ((SINT32) (( data[k] + 1.0 ) * 2147483647.5 + 0.5)) - 2147483648; if ( byteswap ) swap32( (unsigned char *)&sample ); if ( fwrite(&sample, 4, 1, fd) != 1 ) goto error; } } else if ( dataType == MY_FLOAT32 ) { FLOAT32 sample; for ( unsigned long k=0; k<frames*channels; k++ ) { sample = (FLOAT32) (data[k]); if ( byteswap ) swap32( (unsigned char *)&sample ); if ( fwrite(&sample, 4, 1, fd) != 1 ) goto error; } } else if ( dataType == MY_FLOAT64 ) { FLOAT64 sample; for ( unsigned long k=0; k<frames*channels; k++ ) { sample = (FLOAT64) (data[k]); if ( byteswap ) swap64( (unsigned char *)&sample ); if ( fwrite(&sample, 8, 1, fd) != 1 ) goto error; } } return; error: sprintf(msg, "WvOut: Error writing data to file."); handleError(msg, StkError::FILE_ERROR); }
int Vme_Write16(Cmd_Write16 *pCmd_Write16) { short *pRd = pCmd_Write16->vals; short *pWr; int c = pCmd_Write16->cnt; vmeBusToLocalAdrs(0x39, (char *)((long)pCmd_Write16->addr),(char **)&pWr); vmeBusLock(); if(pCmd_Write16->flags & CRATE_MSG_FLAGS_ADRINC) while(c--) *pWr++ = swap16(*pRd++); else while(c--) *pWr = swap16(*pRd++); vmeBusUnlock(); return 0; }