自学教程：C++ swab函数代码示例

int a52_fillbuff(sh_audio_t *sh_audio){int length=0;int flags=0;int sample_rate=0;int bit_rate=0;    sh_audio->a_in_buffer_len=0;    /* sync frame:*/while(1){    while(sh_audio->a_in_buffer_len<8){	int c=demux_getc(sh_audio->ds);	if(c<0) return -1; /* EOF*/        sh_audio->a_in_buffer[sh_audio->a_in_buffer_len++]=c;    }    if(sh_audio->format!=0x2000) swab(sh_audio->a_in_buffer,sh_audio->a_in_buffer,8);    length = a52_syncinfo (sh_audio->a_in_buffer, &flags, &sample_rate, &bit_rate);    if(length>=7 && length<=3840) break; /* we're done.*/    /* bad file => resync*/    if(sh_audio->format!=0x2000) swab(sh_audio->a_in_buffer,sh_audio->a_in_buffer,8);    memmove(sh_audio->a_in_buffer,sh_audio->a_in_buffer+1,7);    --sh_audio->a_in_buffer_len;}    mp_msg(MSGT_DECAUDIO,MSGL_DBG2,"a52: len=%d  flags=0x%X  %d Hz %d bit/s/n",length,flags,sample_rate,bit_rate);    sh_audio->samplerate=sample_rate;    sh_audio->i_bps=bit_rate/8;    sh_audio->samplesize=sh_audio->sample_format==AF_FORMAT_FLOAT_NE ? 4 : 2;    demux_read_data(sh_audio->ds,sh_audio->a_in_buffer+8,length-8);    if(sh_audio->format!=0x2000)	swab(sh_audio->a_in_buffer+8,sh_audio->a_in_buffer+8,length-8);        if(crc16_block(sh_audio->a_in_buffer+2,length-2)!=0)	mp_msg(MSGT_DECAUDIO,MSGL_STATUS,"a52: CRC check failed!  /n");        return length;}

/* подпр.обр.пс.опер.DC */int SDC(){    /*рабочая переменная */    char *RAB;    /*занулим два старших байта RX.OP_RX */    RX.OP_RX.OP = 0;    RX.OP_RX.R1X2 = 0;    /* если операнд начинается с комбинации F' */    if (memcmp(TEK_ISX_KARTA.STRUCT_BUFCARD.OPERAND,"F'", 2) == 0)    {        /* в перем. c указат.RAB выбираем первую лексему операнда текущей карты исх.текста АССЕМБЛЕРА */        RAB=strtok((char*)TEK_ISX_KARTA.STRUCT_BUFCARD.OPERAND + 2, "'");        /*перевод ASCII-> int */        RX.OP_RX.B2D2 = atoi ( RAB );        /* приведение к соглашениям ЕС ЭВМ */        RAB = (char *) &RX.OP_RX.B2D2;        swab ( RAB , RAB , 2 );    }    else    {        /* иначе сообщение об ошибке */        return (1);    }    /* формирование TXT-карты */    STXT (4);    return (0);                                     /*успешн.завершение подпр.*/}

static void callback(SLBufferQueueItf bufq, void *param){    assert(NULL == param);    if (!eof) {        short *buffer = &buffers[framesPerBuffer * sfinfo.channels * which];        sf_count_t count;        count = sf_readf_short(sndfile, buffer, (sf_count_t) framesPerBuffer);        if (0 >= count) {            eof = SL_BOOLEAN_TRUE;        } else {            SLuint32 nbytes = count * sfinfo.channels * sizeof(short);            if (byteOrder != nativeByteOrder) {                swab(buffer, buffer, nbytes);            }            if (bitsPerSample == 8) {                squeeze(buffer, (unsigned char *) buffer, nbytes);                nbytes /= 2;            }            SLresult result = (*bufq)->Enqueue(bufq, buffer, nbytes);            assert(SL_RESULT_SUCCESS == result);            if (++which >= numBuffers)                which = 0;        }    }}

uint16_t Sound::swapends(uint16_t u){    if (!am_big_endian()) return u;    uint16_t v;    swab(&u, &v, 2);    return v;}

intwav_ac3wav_demuxer_c::decode_buffer(int len) {  if (len < 8)    return -1;  if (m_swap_bytes) {    memcpy(      m_buf[m_cur_buf ^ 1]->get_buffer(),         m_buf[m_cur_buf]->get_buffer(),         8);    swab((char *)m_buf[m_cur_buf]->get_buffer() + 8, (char *)m_buf[m_cur_buf ^ 1]->get_buffer() + 8, len - 8);    m_cur_buf ^= 1;  }  unsigned char *base = m_buf[m_cur_buf]->get_buffer();  if ((get_uint16_le(&base[0]) != AC3WAV_SYNC_WORD1) || (get_uint16_le(&base[2]) != AC3WAV_SYNC_WORD2) || (0x01 != base[4]))    return -1;  int payload_len = get_uint16_le(&base[6]) / 8;  if ((payload_len + 8) > len)    return -1;  if (!m_ac3header.decode_header(&base[8], payload_len))    return -1;  return payload_len;}

int save_pgm_uint16(const char* path, const uint16_t* image, size_t w, size_t stride, size_t h){  FILE* f = fopen(path, "wb");  if (f == NULL)  {    perror("open");    return -1;  }  fprintf(f, "P5/n");  fprintf(f, "%lu %lu/n", w, h);  fprintf(f, "65535/n");  uint16_t* tmp;#if __BYTE_ORDER == __LITTLE_ENDIAN  tmp = (uint16_t*)malloc(w*2);#endif  for( size_t y = 0; y < h; ++y)  {#if __BYTE_ORDER == __LITTLE_ENDIAN    swab(image+stride*y, tmp, w*2);#else    tmp = image+stride*y;#endif    fwrite(tmp, w*2, 1, f);  }#if __BYTE_ORDER == __LITTLE_ENDIAN  free(tmp);#endif  fclose(f);  return 0;}

static void callback(SLBufferQueueItf bufq, void *param){    assert(NULL == param);    if (!eof) {        void *buffer = (char *)buffers + framesPerBuffer * sfframesize * which;        ssize_t count = pipeReader->read(buffer, framesPerBuffer, (int64_t) -1);        // on underrun from pipe, substitute silence        if (0 >= count) {            memset(buffer, 0, framesPerBuffer * sfframesize);            count = framesPerBuffer;            ++underruns;        }        if (count > 0) {            SLuint32 nbytes = count * sfframesize;            if (byteOrder != nativeByteOrder) {                swab(buffer, buffer, nbytes);            }            if (transferFormat == AUDIO_FORMAT_PCM_8_BIT) {                squeeze((short *) buffer, (unsigned char *) buffer, nbytes);                nbytes /= 2;            } else if (transferFormat == AUDIO_FORMAT_PCM_24_BIT_PACKED) {                squeeze24((unsigned char *) buffer, (unsigned char *) buffer, nbytes);                nbytes = nbytes * 3 / 4;            }            SLresult result = (*bufq)->Enqueue(bufq, buffer, nbytes);            assert(SL_RESULT_SUCCESS == result);            if (++which >= numBuffers)                which = 0;        }    }}

static int neogeo_init(void){	SceUID fd;	char path[MAX_PATH];   sprintf(path, "%smemcard/%s.bin", launchDir, game_name);   if ((fd = sceIoOpen(path, PSP_O_RDONLY, 0777)) >= 0)   {      sceIoRead(fd, neogeo_memcard, 0x800);      sceIoClose(fd);   }   sprintf(path, "%snvram/%s.nv", launchDir, game_name);   if ((fd = sceIoOpen(path, PSP_O_RDONLY, 0777)) >= 0)   {      sceIoRead(fd, neogeo_sram16, 0x2000);      sceIoClose(fd);      swab(neogeo_sram16, neogeo_sram16, 0x2000);   }	neogeo_driver_init();	neogeo_video_init();	msg_printf(TEXT(DONE2));   return 1;}

QStringList AudioCdRecord::arguments() const{    QStringList args;/*! --------------------- Normal Arguments --------------------!*/    args << "-v";    if( publicRead()           )        args << "-r";    if( dummy()                )        args << "-dummy";    if( force()                )        args << "-force";    if( sessionAtOnce()        )        args << "-sao";    if( trackAtOnce()          )        args << "-tao";    if( swab()                 )        args << "-swab";    if( multiSession()         )        args << "-multi";    if( pad()                  )        args << "-pad";    if( pad() && padSize() > 0 )        args << QString::number( padSize() );    if( eject()                )        args << "-eject";    if( ringBuffer() > 0       )        args << "fs="     + QString::number( ringBuffer() );    if( minimumBuffer() > 0    )        args << "minbuf=" + QString::number( minimumBuffer() );    if( speed() > 0            )        args << "speed="  + QString::number( speed() );    args << "dev=" + currentDevice().toQString();    args << "-audio";    args << files();    /*! -----------------------------------------------------------!*/    return args;}

void neogeo_exit(void){	SceUID fd;	char path[MAX_PATH];	msg_printf(TEXT(PLEASE_WAIT2));   sprintf(path, "%smemcard/%s.bin", launchDir, game_name);   if ((fd = sceIoOpen(path, PSP_O_WRONLY|PSP_O_CREAT, 0777)) >= 0)   {      sceIoWrite(fd, neogeo_memcard, 0x800);      sceIoClose(fd);   }   sprintf(path, "%snvram/%s.nv", launchDir, game_name);   if ((fd = sceIoOpen(path, PSP_O_WRONLY|PSP_O_CREAT, 0777)) >= 0)   {      swab(neogeo_sram16, neogeo_sram16, 0x2000);      sceIoWrite(fd, neogeo_sram16, 0x2000);      sceIoClose(fd);   }	msg_printf(TEXT(DONE2));   sound_exit();   memory_shutdown();}

static void write_data( filter_t *p_filter, const void *p_buf, size_t i_size,                        bool b_input_big_endian ){    filter_sys_t *p_sys = p_filter->p_sys;    assert( p_sys->p_out_buf != NULL );    bool b_output_big_endian =        p_filter->fmt_out.audio.i_format == VLC_CODEC_SPDIFB;    uint8_t *p_out = &p_sys->p_out_buf->p_buffer[p_sys->i_out_offset];    const uint8_t *p_in = p_buf;    assert( p_sys->p_out_buf->i_buffer - p_sys->i_out_offset >= i_size );    if( b_input_big_endian != b_output_big_endian )        swab( p_in, p_out, i_size & ~1 );    else        memcpy( p_out, p_in, i_size & ~1 );    p_sys->i_out_offset += ( i_size & ~1 );    if( i_size & 1 )    {        assert( p_sys->p_out_buf->i_buffer - p_sys->i_out_offset >= 2 );        p_out += ( i_size & ~1 );        set_16( p_filter, p_out, p_in[i_size - 1] << 8 );        p_sys->i_out_offset += 2;    }}

int cbf_swab(const void * src, void * dst, size_t len) {#ifndef USE_SWAB	unsigned char *p1;	unsigned char *p2;#endif		if (len&1) return CBF_ARGUMENT;#ifndef USE_SWAB	p1 = (unsigned char *)src;	p2 = (unsigned char *)dst;		while (len) {	  p2[1] = p1[0];	  p2[0] = p1[1];	  p1+=2; p2+=2;	  len -=2;		}#else    swab(src,dst,len);#endif		return 0;}

/* low level save routine */static int _save_pgm(const char *filename, unsigned w, unsigned h, unsigned stride,		     const char *data){	int fd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0644);	int ret;	if (fd == -1) {		return -1;	}	dprintf(fd,"P5/n%u %u/n%u/n", 		w, h, stride==w?255:65535);	if (__BYTE_ORDER == __LITTLE_ENDIAN && stride == w*2) {		char *data2 = malloc(w*h*2);		swab(data, data2, w*h*2);		ret = write(fd, data2, h*stride);		free(data2);	} else {		ret = write(fd, data, h*stride);	}	if (ret != h*stride) {		close(fd);		return -1;	}	close(fd);	return 0;}

int rom_load(struct rom_t *rom, UINT8 *mem, int idx, int max){	int offset, length;_continue:	offset = rom[idx].offset;	if (rom[idx].skip == 0)	{		file_read(&mem[offset], rom[idx].length);		if (rom[idx].type == ROM_WORDSWAP)			swab(&mem[offset], &mem[offset], rom[idx].length);	}	else	{		int c;		int skip = rom[idx].skip + rom[idx].group;		length = 0;		if (rom[idx].group == 1)		{			if (rom[idx].type == ROM_WORDSWAP)				offset ^= 1;			while (length < rom[idx].length)			{				if ((c = file_getc()) == EOF) break;				mem[offset] = c;				offset += skip;				length++;			}		}		else		{			while (length < rom[idx].length)			{				if ((c = file_getc()) == EOF) break;				mem[offset + 0] = c;				if ((c = file_getc()) == EOF) break;				mem[offset + 1] = c;				offset += skip;				length += 2;			}		}	}	if (++idx != max)	{		if (rom[idx].type == ROM_CONTINUE)		{			goto _continue;		}	}	return idx;}

static intreadehdr(Boot *b){	int i;	/* bitswap the header according to the DATA format */	if(ehdr.ident[CLASS] != ELFCLASS32) {		print("bad ELF class - not 32 bit/n");		return 0;	}	if(ehdr.ident[DATA] == ELFDATA2LSB) {		swab = leswab;		swal = leswal;	} else if(ehdr.ident[DATA] == ELFDATA2MSB) {		swab = beswab;		swal = beswal;	} else {		print("bad ELF encoding - not big or little endian/n");		return 0;	}	memmove(&rehdr, &ehdr, sizeof(Ehdr));	ehdr.type = swab(ehdr.type);	ehdr.machine = swab(ehdr.machine);	ehdr.version = swal(ehdr.version);	ehdr.elfentry = swal(ehdr.elfentry);	ehdr.phoff = swal(ehdr.phoff);	ehdr.shoff = swal(ehdr.shoff);	ehdr.flags = swal(ehdr.flags);	ehdr.ehsize = swab(ehdr.ehsize);	ehdr.phentsize = swab(ehdr.phentsize);	ehdr.phnum = swab(ehdr.phnum);	ehdr.shentsize = swab(ehdr.shentsize);	ehdr.shnum = swab(ehdr.shnum);	ehdr.shstrndx = swab(ehdr.shstrndx);	if(ehdr.type != EXEC || ehdr.version != CURRENT)		return 0;	if(ehdr.phentsize != sizeof(Phdr))		return 0;	if(debug)		print("readehdr OK entry 0x%lux/n", ehdr.elfentry);	curoff = sizeof(Ehdr);	i = ehdr.phoff+ehdr.phentsize*ehdr.phnum - curoff;	b->state = READPHDR;	b->bp = (char*)malloc(i);	b->wp = b->bp;	b->ep = b->wp + i;	phdr = (Phdr*)(b->bp + ehdr.phoff-sizeof(Ehdr));	if(debug)		print("phdr...");	return 1;}

/* Write 3 byte bed header */static int write_bed_header(FILE *bed){    short m;    size_t count;    swab(&magic_no, &m, 2);    count = fwrite(&m, sizeof(short), 1, bed);    count += fwrite(&mode, sizeof(char), 1, bed);    return count;}

intwav_ac3acm_demuxer_c::decode_buffer(int len) {  if ((2 < len) && m_swap_bytes) {    swab((char *)m_buf[m_cur_buf]->get_buffer(), (char *)m_buf[m_cur_buf ^ 1]->get_buffer(), len);    m_cur_buf ^= 1;  }  return 0;}

int ipx_change_default_socket( ushort socket_number ){	int i;	WORD new_ipx_socket;	dpmi_real_regs rregs;	if ( !ipx_installed ) return -3;	// Open a new socket		memset(&rregs,0,sizeof(dpmi_real_regs));	swab( (char *)&socket_number,(char *)&new_ipx_socket, 2 );	rregs.edx = new_ipx_socket;	rregs.eax = ipx_socket_life;	rregs.ebx = 0;	// Open socket	dpmi_real_int386x( 0x7A, &rregs );		new_ipx_socket = rregs.edx & 0xFFFF;		if ( rregs.eax & 0xFF )	{		//printf( (1, "IPX error opening channel %d/n", socket_number-IPX_DEFAULT_SOCKET ));		return -2;	}	for (i=1; i<ipx_num_packets; i++ )	{		ipx_cancel_listen_for_packet(&packets[i].ecb);	}	// Close existing socket...	memset(&rregs,0,sizeof(dpmi_real_regs));	rregs.edx = ipx_socket;	rregs.ebx = 1;	// Close socket	dpmi_real_int386x( 0x7A, &rregs );	ipx_socket = new_ipx_socket;	// Repost all listen requests on the new socket...		for (i=1; i<ipx_num_packets; i++ )	{		packets[i].ecb.in_use = 0;		packets[i].ecb.socket_id = ipx_socket;		ipx_listen_for_packet(&packets[i].ecb);	}	packets[0].ecb.socket_id = ipx_socket;	packets[0].ipx.destination.socket_id = ipx_socket;	ipx_packetnum = 0;	// init packet buffers.	for (i=0; i<MAX_PACKETS; i++ )	{		packet_buffers[i].packetnum = -1;		packet_free_list[i] = i;	}	num_packets = 0;	largest_packet_index = 0;	return 0;}

/*++Function:  _swabSwaps bytes.Return ValueNoneParameterssrc        Data to be copied and swappeddest       Storage location for swapped datan          Number of bytes to be copied and swappedRemarksThe _swab function copies n bytes from src, swaps each pair ofadjacent bytes, and stores the result at dest. The integer n should bean even number to allow for swapping. _swab is typically used toprepare binary data for transfer to a machine that uses a differentbyte order.Examplechar from[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";char   to[] = "..........................";printf("Before:/n%s/n%s/n/n", from, to);_swab(from, to, strlen(from));printf("After:/n%s/n%s/n/n", from, to);Before:ABCDEFGHIJKLMNOPQRSTUVWXYZ..........................After:ABCDEFGHIJKLMNOPQRSTUVWXYZBADCFEHGJILKNMPORQTSVUXWZY--*/void__cdecl_swab(char *src, char *dest, int n){    PERF_ENTRY(_swab);    ENTRY("_swab (src=%p (%s), dest=%p (%s), n=%d)/n", src?src:"NULL", src?src:"NULL", dest?dest:"NULL", dest?dest:"NULL", n);    swab(src, dest, n);    LOGEXIT("_swab returning/n");    PERF_EXIT(_swab);}

/************************************************************* * copyshort *------------------------------------------------------------ * copy a 2-byte int, making sure to use the intended byte * order for the destination, regardless of what the * native byte order is on the current machine */void copyshort( short int val, char *dest, char *intended ){    if ( strcmp( nativorder, intended ))	swab((char *) &val, short_order.ch, 2 );    else	short_order.i2 = val;    *dest++ = short_order.ch[0];    *dest = short_order.ch[1];}

/***************************************************************************** * DoWork: convert a buffer *****************************************************************************/static block_t *DoWork( filter_t * p_filter, block_t *p_in_buf ){    size_t i_length = p_in_buf->i_buffer;    uint8_t * p_in = p_in_buf->p_buffer;    block_t *p_out_buf = NULL;    uint16_t i_data_type = get_data_type( p_filter, p_in_buf );    if( i_data_type == 0 || ( i_length + 8 ) > AOUT_SPDIF_SIZE )        goto out;    size_t i_out_length = p_in_buf->i_nb_samples * 4;    p_out_buf = block_Alloc( i_out_length );    if( !p_out_buf )        goto out;    uint8_t *p_out = p_out_buf->p_buffer;    /* Copy the S/PDIF headers. */    void (*write16)(void *, uint16_t) =        ( p_filter->fmt_out.audio.i_format == VLC_CODEC_SPDIFB )        ? SetWBE : SetWLE;    write16( &p_out[0], 0xf872 ); /* syncword 1 */    write16( &p_out[2], 0x4e1f ); /* syncword 2 */    write16( &p_out[4], i_data_type ); /* data type */    write16( &p_out[6], i_length * 8 ); /* length in bits */    bool b_input_big_endian = is_big_endian( p_filter, p_in_buf );    bool b_output_big_endian =        p_filter->fmt_out.audio.i_format == VLC_CODEC_SPDIFB;    if( b_input_big_endian != b_output_big_endian )    {        swab( p_in, p_out + 8, i_length & ~1 );        /* If i_length is odd, we have to adjust swapping a bit... */        if( i_length & 1 && ( i_length + 9 ) <= i_out_length )        {            p_out[8 + i_length - 1] = 0;            p_out[8 + i_length] = p_in[i_length-1];            i_length++;        }    } else        memcpy( p_out + 8, p_in, i_length );    if( 8 + i_length < i_out_length ) /* padding */        memset( p_out + 8 + i_length, 0, i_out_length - i_length - 8 );    p_out_buf->i_dts = p_in_buf->i_dts;    p_out_buf->i_pts = p_in_buf->i_pts;    p_out_buf->i_nb_samples = p_in_buf->i_nb_samples;    p_out_buf->i_buffer = i_out_length;out:    block_Release( p_in_buf );    return p_out_buf;}

inlinevoid SwitchVectorEndian(std::vector<unsigned short>& data){	BOOST_STATIC_ASSERT(sizeof(unsigned short)==2);	SwabType* p_data=reinterpret_cast <SwabType*>(&data[0]);	swab(p_data,		p_data,		static_cast<int>(data.size()*2));}

intdevread(Device *d, Off b, void *c){	int e;	for (;;)		switch(d->type) {		case Devcw:			return cwread(d, b, c);		case Devjuke:			d = d->j.m;			break;		case Devro:			return roread(d, b, c);		case Devwren:			return wrenread(d, b, c);		case Devworm:		case Devlworm:			return wormread(d, b, c);		case Devfworm:			return fwormread(d, b, c);		case Devmcat:			return mcatread(d, b, c);		case Devmlev:			return mlevread(d, b, c);		case Devmirr:			return mirrread(d, b, c);		case Devpart:			return partread(d, b, c);		case Devswab:			e = devread(d->swab.d, b, c);			if(e == 0)				swab(c, 0);			return e;		case Devnone:			print("read from device none(%lld)/n", (Wideoff)b);			return 1;		default:			panic("illegal device in devread: %Z %lld",				d, (Wideoff)b);			return 1;		}}

void main(void) {   char *source = "AJSM'A S0110T pi!s";   char target[64];   memset(target, NULL, sizeof(target));     swab(source, target, strlen(source));   printf("Source: %s Target %s/n", source, target); }

static void BdExtract( block_t *p_aout_buffer, block_t *p_block,                       unsigned i_frame_length,                       unsigned i_channels, unsigned i_channels_padding,                       unsigned i_bits ){    if( i_channels_padding > 0 )    {        uint8_t *p_src = p_block->p_buffer;        uint8_t *p_dst = p_aout_buffer->p_buffer;        int dst_inc = ((i_bits == 16) ? 2 : 4) * i_channels;        while( i_frame_length > 0 )        {#ifdef WORDS_BIGENDIAN            memcpy( p_dst, p_src, i_channels * i_bits / 8 );#else            if (i_bits == 16) {                swab( (char *)p_dst, (char *)p_src, (i_channels + i_channels_padding) * i_bits / 8 );			// sunqueen modify            } else {                p_dst[0] = 0;                p_dst[1] = p_src[2];                p_dst[2] = p_src[1];                p_dst[3] = p_src[0];            }#endif            p_src += (i_channels + i_channels_padding) * i_bits / 8;            p_dst += dst_inc;            i_frame_length--;        }    }    else    {#ifdef WORDS_BIGENDIAN        memcpy( p_aout_buffer->p_buffer, p_block->p_buffer, p_block->i_buffer );#else        swab( (char *)p_block->p_buffer, (char *)p_aout_buffer->p_buffer, p_block->i_buffer );			// sunqueen modify#endif    }}

static void neogeo_exit(void){	SceUID fd;	char path[MAX_PATH];	video_set_mode(32);	video_clear_screen();	ui_popup_reset();	video_clear_screen();	msg_screen_init(WP_LOGO, ICON_SYSTEM, TEXT(EXIT_EMULATION2));	msg_printf(TEXT(PLEASE_WAIT2));#ifdef ADHOC	if (!adhoc_enable)#endif	{		sprintf(path, "%smemcard/%s.bin", launchDir, game_name);		if ((fd = sceIoOpen(path, PSP_O_WRONLY|PSP_O_CREAT, 0777)) >= 0)		{			sceIoWrite(fd, neogeo_memcard, 0x800);			sceIoClose(fd);		}		sprintf(path, "%snvram/%s.nv", launchDir, game_name);		if ((fd = sceIoOpen(path, PSP_O_WRONLY|PSP_O_CREAT, 0777)) >= 0)		{			swab(neogeo_sram16, neogeo_sram16, 0x2000);			sceIoWrite(fd, neogeo_sram16, 0x2000);			sceIoClose(fd);		}#ifdef COMMAND_LIST		free_commandlist();#endif		if (neogeo_save_sound_flag) option_sound_enable = 1;		save_gamecfg(game_name);	}	msg_printf(TEXT(DONE2));#ifdef ADHOC	if (adhoc_enable) adhocTerm();#endif	show_exit_screen();}

/*	Load a binary image, return # bytes read.*/int  data_load_binary(const char *type, const char *path, const char *filename,				 u8 * loadat, int swap, int fileoffs, int imagesize, 				 int maxsize){	OSRef       ref;	OSSize      size;	OSError     err;	OSSpec      spec;	size = data_find_binary(path, filename, &spec);	if (!size) {		if (*filename) {			command_logger(_L |LOG_USER|LOG_ERROR, 						   _("Cannot find '%s' in path:/n'%s'/n"), 						   filename, path);		}		return 0;	}	logger(_L|L_0, _("Loading %s image %s... "), type, OS_SpecToString1(&spec));	if (imagesize)		size = imagesize;	else if (size - fileoffs > maxsize) {		command_logger(_L | LOG_WARN | LOG_USER, _("%s too long, only %d bytes of %d read... "),			 OS_SpecToString1(&spec), maxsize, size);		size = maxsize - fileoffs;	}	if ((err = OS_Open(&spec, OSReadOnly, &ref)) != OS_NOERR) {		OSerror(err, "/n");		return 0;	}	if ((err = OS_Seek(ref, OSSeekAbs, fileoffs)) != OS_NOERR ||		(err = OS_Read(ref, loadat, &size)) != OS_NOERR) {		OSerror(err, _("could not read/n"));		return 0;	}	if (swap) {		logger(_L, _("swapping bytes... "));		swab((const void *) loadat, (void *) loadat, size);	}	logger(_L| L_0, _("done/n"));	OS_Close(ref);	return size;}

/* подпр.обр.пс.опер.START */int SSTART(){    /* набор рабочих переменных подпрограммы */    char *PTR;    char *METKA;    char *METKA1;    int J;    int RAB;    /* в перем. c указат.METKA1 выбираем первую лексему операнда текущей карты исх.текста АССЕМБЛЕРА */    METKA1 = strtok((char*) TEK_ISX_KARTA.STRUCT_BUFCARD.METKA, " ");    for ( J=0; J<=ITSYM; J++ )    {        /* все метки исх.текста в табл. T_SYM сравниваем со знач.перем. *METKA1 */        METKA = strtok ((char*) T_SYM[J].IMSYM , " ");        /* и при совпадении:      */        if( !strcmp ( METKA , METKA1 ) )        {            /*  берем разность сч.адр. знач.этой метки, образуя длину программы в соглашениях ЕС ЭБМ, и записыв.ее в ESD-карту побайтно */            RAB = CHADR - T_SYM[J].ZNSYM;            PTR = (char *)&RAB;            swab ( PTR , PTR , 2 );            ESD.STR_ESD.DLPRG [0] = 0;            ESD.STR_ESD.DLPRG [1] = *PTR;            ESD.STR_ESD.DLPRG [2] = *(PTR + 1);            /* устанавл.CHADR, равным операнду операт.START исходного текста */            CHADR = T_SYM[J].ZNSYM;            /* формирование поля ADPRG ESD-карты в формате двоичного целого в соглашениях ЕС ЭВМ */            PTR = (char *)&CHADR;            ESD.STR_ESD.ADPRG[2]  = *PTR;            ESD.STR_ESD.ADPRG[1]  = *(PTR+1);            ESD.STR_ESD.ADPRG[0]  = '/x00';            /* формирование имени программы и идентификационнго поля ESD - карты */            memcpy(ESD.STR_ESD.IMPR, METKA, strlen(METKA));            memcpy(ESD.STR_ESD.POLE11, METKA, strlen(METKA));            /* запись об'ектной карты в массив об'ектных карт */            memcpy(OBJTEXT[ITCARD], ESD.BUF_ESD, 80);            ITCARD += 1;                                /*коррекц.инд-са своб.к-ты*/            return (0);                                 /*успешное заверш.подпрогр*/        }    }    return (2);                                     /*ошибочное заверш.прогр. */}

intdts_reader_c::decode_buffer(size_t length) {  if (m_swap_bytes) {    swab(reinterpret_cast<char *>(m_buf[m_cur_buf]), reinterpret_cast<char *>(m_buf[m_cur_buf ^ 1]), length);    m_cur_buf ^= 1;  }  if (m_dts14_to_16) {    mtx::dts::convert_14_to_16_bits(m_buf[m_cur_buf], length / 2, m_buf[m_cur_buf ^ 1]);    m_cur_buf ^= 1;    length     = length * 7 / 8;  }  return length;}