Example #1
0
int main(int argc, char **argv){
	FILE *infile, *outfile;
	HeaderType inHeader, outHeader;
	uint16_t *indata, *outdata = NULL;

	// verifica o uso
	if(argc != 3){
		printf("use: %s infile outfile\n", argv[0]);
		return 1;
	}

	// abre arquivo de entrada
	infile = fopen(argv[1], "rb");
	if(infile == NULL){
		perror(argv[1]);
		exit(1);
	}

	// le arquivo de entrada
	fread(&inHeader, sizeof(HeaderType), 1, infile);
	indata = malloc(inHeader.Subchunk2Size);
	fread(indata, 1, inHeader.Subchunk2Size, infile);

	// verifica formato
	if(inHeader.AudioFormat == PCM_FORMAT){
		adpcm_code(&outHeader, &outdata, inHeader, &indata);
	}else if(inHeader.AudioFormat == ADPCM_FORMAT){
		adpcm_decode(&outHeader, &outdata, inHeader, &indata);
	}else{
		printf("Invalid file format\n");
		exit(1);
	}

	// abre arquivo de saida
	outfile = fopen(argv[2], "wb");
	if(outfile == NULL){
		perror(argv[2]);
		exit(1);
	}

	// escreve arquivo de saida
	fwrite(&outHeader, sizeof(HeaderType), 1, outfile);
	fwrite(outdata, 1, outHeader.Subchunk2Size, outfile);

	if(outdata != NULL){
		free(outdata);
	}
	free(indata);
	fclose(outfile);
	fclose(infile);

	return 0;
}
Example #2
0
void sb_device::device_timer(emu_timer &timer, device_timer_id tid, int param, void *ptr)
{
//    printf("DMA timer expire\n");
	if (tid)
	{
		device_serial_interface::device_timer(timer, tid, param, ptr);
		return;
	}

	UINT16 lsample, rsample;
	switch (m_dsp.flags) {
		case 0: // 8-bit unsigned mono
			m_dacl->write_unsigned8(m_dsp.data[m_dsp.d_rptr]);
			m_dacr->write_unsigned8(m_dsp.data[m_dsp.d_rptr]);
			m_dsp.data[m_dsp.d_rptr++] = 0x80;
			break;
		case SIGNED: // 8-bit signed mono
			m_dacl->write_unsigned8(m_dsp.data[m_dsp.d_rptr] + 128);
			m_dacr->write_unsigned8(m_dsp.data[m_dsp.d_rptr] + 128);
			m_dsp.data[m_dsp.d_rptr++] = 0x00;
			break;
		case STEREO: // 8-bit unsigned stereo
			m_dacl->write_unsigned8(m_dsp.data[m_dsp.d_rptr]);
			m_dsp.data[m_dsp.d_rptr++] = 0x80;
			m_dacr->write_unsigned8(m_dsp.data[m_dsp.d_rptr]);
			m_dsp.data[m_dsp.d_rptr++] = 0x80;
			break;
		case SIGNED | STEREO: // 8-bit signed stereo
			m_dacl->write_unsigned8(m_dsp.data[m_dsp.d_rptr] + 128);
			m_dsp.data[m_dsp.d_rptr++] = 0x00;
			m_dacr->write_unsigned8(m_dsp.data[m_dsp.d_rptr] + 128);
			m_dsp.data[m_dsp.d_rptr++] = 0x00;
			break;
		case SIXTEENBIT: // 16-bit unsigned mono
			lsample = m_dsp.data[m_dsp.d_rptr] | (m_dsp.data[m_dsp.d_rptr+1] << 8);
			m_dsp.data[m_dsp.d_rptr++] = 0x00;
			m_dsp.data[m_dsp.d_rptr++] = 0x80;
			m_dacl->write_unsigned16(lsample);
			m_dacr->write_unsigned16(lsample);
			break;
		case SIXTEENBIT | SIGNED: // 16-bit signed mono
			lsample = m_dsp.data[m_dsp.d_rptr] | (m_dsp.data[m_dsp.d_rptr+1] << 8);
			m_dsp.data[m_dsp.d_rptr++] = 0x00;
			m_dsp.data[m_dsp.d_rptr++] = 0x00;
			m_dacl->write_unsigned16(lsample + 32768);
			m_dacr->write_unsigned16(lsample + 32768);
			break;
		case SIXTEENBIT | STEREO: // 16-bit unsigned stereo
			lsample = m_dsp.data[m_dsp.d_rptr] | (m_dsp.data[m_dsp.d_rptr+1] << 8);
			m_dsp.data[m_dsp.d_rptr++] = 0x00;
			m_dsp.data[m_dsp.d_rptr++] = 0x80;
			m_dsp.d_rptr %= 128;
			rsample = m_dsp.data[m_dsp.d_rptr] | (m_dsp.data[m_dsp.d_rptr+1] << 8);
			m_dsp.data[m_dsp.d_rptr++] = 0x00;
			m_dsp.data[m_dsp.d_rptr++] = 0x80;
			m_dacl->write_unsigned16(lsample);
			m_dacr->write_unsigned16(rsample);
			break;
		case SIXTEENBIT | SIGNED | STEREO: // 16-bit signed stereo
			lsample = m_dsp.data[m_dsp.d_rptr] | (m_dsp.data[m_dsp.d_rptr+1] << 8);
			m_dsp.data[m_dsp.d_rptr++] = 0x00;
			m_dsp.data[m_dsp.d_rptr++] = 0x00;
			m_dsp.d_rptr %= 128;
			rsample = m_dsp.data[m_dsp.d_rptr] | (m_dsp.data[m_dsp.d_rptr+1] << 8);
			m_dsp.data[m_dsp.d_rptr++] = 0x00;
			m_dsp.data[m_dsp.d_rptr++] = 0x00;
			m_dacl->write_unsigned16(lsample + 32768);
			m_dacr->write_unsigned16(rsample + 32768);
			break;
		case ADPCM2:
			if(m_dsp.adpcm_new_ref)
			{
				m_dsp.adpcm_ref = m_dsp.data[m_dsp.d_rptr++];
				m_dsp.adpcm_new_ref = false;
				m_dacl->write_unsigned8(m_dsp.adpcm_ref);
				m_dacr->write_unsigned8(m_dsp.adpcm_ref);
				break;
			}
			lsample = m_dsp.data[m_dsp.d_rptr];
			switch(m_dsp.adpcm_count++)
			{
				case 0:
					adpcm_decode(lsample >> 6, 2);
					break;
				case 1:
					adpcm_decode((lsample >> 4) & 3, 2);
					break;
				case 2:
					adpcm_decode((lsample >> 2) & 3, 2);
					break;
				case 3:
					adpcm_decode(lsample & 3, 2);
					m_dsp.data[m_dsp.d_rptr++] = 0x80;
					m_dsp.adpcm_count = 0;
					break;
			}
			break;
		case ADPCM3:
			if(m_dsp.adpcm_new_ref)
			{
				m_dsp.adpcm_ref = m_dsp.data[m_dsp.d_rptr++];
				m_dsp.adpcm_new_ref = false;
				m_dacl->write_unsigned8(m_dsp.adpcm_ref);
				m_dacr->write_unsigned8(m_dsp.adpcm_ref);
				break;
			}
			lsample = m_dsp.data[m_dsp.d_rptr];
			switch(m_dsp.adpcm_count++)
			{
				case 0:
					adpcm_decode(lsample >> 5, 3);
					break;
				case 1:
					adpcm_decode((lsample >> 2) & 7, 3);
					break;
				case 2:
					adpcm_decode(((lsample & 2) << 1) | (lsample & 1), 3);
					m_dsp.data[m_dsp.d_rptr++] = 0x80;
					m_dsp.adpcm_count = 0;
					break;
			}
			break;
		case ADPCM4:
			if(m_dsp.adpcm_new_ref)
			{
				m_dsp.adpcm_ref = m_dsp.data[m_dsp.d_rptr++];
				m_dsp.adpcm_new_ref = false;
				m_dacl->write_unsigned8(m_dsp.adpcm_ref);
				m_dacr->write_unsigned8(m_dsp.adpcm_ref);
				break;
			}
			lsample = m_dsp.data[m_dsp.d_rptr];
			switch(m_dsp.adpcm_count++)
			{
				case 0:
					adpcm_decode(lsample >> 4, 4);
					break;
				case 1:
					adpcm_decode(lsample & 15, 4);
					m_dsp.data[m_dsp.d_rptr++] = 0x80;
					m_dsp.adpcm_count = 0;
					break;
			}
			break;
		default:
			logerror("SB: unimplemented sample type %x\n", m_dsp.flags);
	}
	m_dsp.d_rptr %= 128;

	if (m_dsp.dma_throttled)
	{
		if (m_dsp.d_rptr == m_dsp.d_wptr)
		{
//            printf("unthrottling DRQ\n");
			if(m_dsp.flags & SIXTEENBIT) // 16-bit audio through 8-bit dma?
				drq16_w(1);
			else
				drq_w(1);   // raise DRQ
			m_dsp.dma_throttled = false;
		}
	}
}
Example #3
0
void Hes_Apu_Adpcm::run_until( blip_time_t end_time )
{
	int volume = state.volume;
	int fadetimer = state.fadetimer;
	int fadecount = state.fadecount;
	int last_time = this->last_time;
	double next_timer = this->next_timer;
	int last_amp = this->last_amp;
	
	Blip_Buffer* output = this->output; // cache often-used values

	while ( state.playflag && last_time < end_time )
	{
		while ( last_time >= next_timer )
		{
			if ( fadetimer )
			{
				if ( fadecount > 0 )
				{
					fadecount--;
					volume = 0xFF * fadecount / fadetimer;
				}
				else if ( fadecount < 0 )
				{
					fadecount++;
					volume = 0xFF - ( 0xFF * fadecount / fadetimer );
				}
			}
            next_timer += 7159.091;
		}
		int amp;
		if ( state.ad_low_nibble )
		{
			amp = adpcm_decode( state.pcmbuf[ state.playptr ] & 0x0F );
			state.ad_low_nibble = false;
			state.playptr++;
			state.playedsamplecount++;
			if ( state.playedsamplecount == state.playlength )
			{
				state.playflag = 0;
			}
		}
		else
		{
			amp = adpcm_decode( state.pcmbuf[ state.playptr ] >> 4 );
			state.ad_low_nibble = true;
		}
		amp = amp * volume / 0xFF;
		int delta = amp - last_amp;
		if ( output && delta )
		{
			last_amp = amp;
			synth.offset_inline( last_time, delta, output );
		}
		last_time += state.freq;
	}

	if ( !state.playflag )
	{
        while ( next_timer <= end_time ) next_timer += 7159.091;
		last_time = end_time;
	}
	
	this->last_time  = last_time;
	this->next_timer = next_timer;
	this->last_amp   = last_amp;
	state.volume = volume;
	state.fadetimer = fadetimer;
	state.fadecount = fadecount;
}
BOOLEAN adpcm_voice_encode(tBTA_ATT_HSDATA *att_data)
{
    //BTM_TRACE_DEBUG0("adpcm_voice_encode");
    uint8_t buffer[MAX_FRAME_SIZE];
    int size;
    int frame_size;
    UINT8       *p = NULL;
    FILE *fp;
    fp = fopen (RTK_STORAGE_PCM_FILE, "a+");
    if (fp == NULL)
    {
       BTM_TRACE_WARNING0("open file failed\n");
       return FALSE;
    }

    p = (UINT8*)(att_data->data+3);
    size = att_data->data_len - 3;

    /* we must receive 12 20-bytes packets followed by a 19-bytes packet */
    switch (size) {
    case 20:
        adpcm_rec_cb.n_20bytes_pkts++;
        if (adpcm_rec_cb.n_20bytes_pkts > 12){
            BTM_TRACE_DEBUG0("20bytes pkt is exceed 12");
            adpcm_rec_cb.n_20bytes_pkts = 1;
            memcpy(adpcm_rec_cb.buffer + (adpcm_rec_cb.n_20bytes_pkts - 1) * 20,p, 20);
        } else {
            memcpy(adpcm_rec_cb.buffer + (adpcm_rec_cb.n_20bytes_pkts - 1) * 20,p, 20);
        }
        break;
    case 19:
        if (adpcm_rec_cb.n_20bytes_pkts != 12) {
            BTM_TRACE_DEBUG0("20bytes pkt!=12,discard the frame");
            adpcm_rec_cb.n_20bytes_pkts = 0;
        } else {
            memcpy(adpcm_rec_cb.buffer + adpcm_rec_cb.n_20bytes_pkts * 20, p, 19);
            adpcm_rec_cb.n_20bytes_pkts = 0;
            frame_size = adpcm_decode(adpcm_rec_cb.adpcm_state, buffer, adpcm_rec_cb.buffer,ADPCM_ENCODED_FRAME_SIZE);
            BTM_TRACE_DEBUG1("frame size= %d",frame_size);
            if(frame_size == 1020)
            {
                fwrite(buffer, frame_size, 1, fp);
                if(adpcm_rec_cb.channel_status)
                {
                    if(isEmpty())
                    {
                        BTM_TRACE_DEBUG0("the buffer empty,send data to socket");
                        VOHOG_LOCK();
                        if(!UIPC_RTKBT_VR_Send_noblock(UIPC_CH_ID_RTKBT_VR_AUDIO, 0, buffer, frame_size))
                        {
                           BTM_TRACE_WARNING0("send data fail, save data to buffer");
                           saveDATAtobuffer(buffer, frame_size);
                        }
                        VOHOG_UNLOCK();
                    } else {
                        BTM_TRACE_DEBUG0("the buffer is not empty, save data to buffer");
                        saveDATAtobuffer(buffer, frame_size);
                    }
                } else {
                    if(!adpcm_rec_cb.channel_status)
                    {
                        BTM_TRACE_DEBUG0("socket is close");
                    }
                    saveDATAtobuffer(buffer, frame_size);
                }
            }else {
                BTM_TRACE_DEBUG0("frame_size is error");
            }
        }
        break;
    default:
        BTM_TRACE_DEBUG0("size is error");
    }
    //BTM_TRACE_DEBUG1("20bytes pkt= %d",adpcm_rec_cb.n_20bytes_pkts);
    free(att_data);
    //fseek(fp,0,SEEK_END);
    //int lSize = ftell(fp);
    //BTM_TRACE_WARNING1("file length %d\n",lSize);
    fclose(fp);
    return TRUE;
}
Example #5
0
int borplay(FILE *fd, char *fname, unsigned int off, unsigned int size) {
	bor_header bh;
	int len, kb = 0;
	short *out;
	unsigned char *in;
	char *p, *artist, *title;
	

	if(fseek(fd, off, SEEK_SET) < 0) std_err();
	if(!fread(&bh, sizeof(bh), 1, fd)) return(-1);
	size -= sizeof(bh);

	if(strncmp(bh.identifier, BOR_IDENTIFIER, sizeof(bh.identifier))) return(0);

	if((bh.version != BOR_MUSIC_VERSION) && (bh.version != NEW_MUSIC_VERSION)) {
		printf("- warning: unknown file version (%08x)\n", bh.version);
	}
	
	// fix title
	for(p = bh.title; *p; p++) {
		if (*p == '_') *p = ' ';
	}
	
	// fix artist
	for(p = bh.artist; *p; p++) {
		if (*p == '_') *p = ' ';
	}
	
	// force mono if it's a v1 file
	if ((bh.version == BOR_MUSIC_VERSION) && (bh.channels != 1))
	{
		printf("- warning: forcing mono playback because of file version; "
				"use the newest Wav2Bor from LavaLit.com to create BOR files "
				"with more than 1 channel of audio\n");
		bh.channels = 1;
	}

	printf("- %08x (%dhz %dch) %s\n",
		off,
		bh.frequency,   bh.channels,
		fname);
	
	// only print title and artist if at least one of them is specified
	if (strlen(bh.artist) && strlen(bh.title))
		printf("  %s - %s\n", bh.artist, bh.title);
	else if (strlen(bh.artist))
		printf("  %s\n", bh.artist);
	else if (strlen(bh.title))
		printf("  %s\n", bh.title);

	if(bh.datastart > sizeof(bh)) {
		bh.datastart -= sizeof(bh);
		if(fseek(fd, bh.datastart, SEEK_CUR) < 0) std_err();
		size -= bh.datastart;
	}

	in = malloc(MUSIC_BUF_SIZE);
	if(!in) std_err();
	out = malloc(MUSIC_BUF_SIZE * 4);
	if(!out) std_err();

	aoinit_fmt(bh.channels, bh.frequency);

#ifndef WIN32
	init_keyboard();
#endif

	while(size && (len = fread(in, 1, MUSIC_BUF_SIZE, fd))) {
		if(size < len) len = size;
		size -= len;
		
		adpcm_decode(in, out, len, bh.channels);
		
		if(!ao_play(device, (void *)out, len * 4)) break;
		
		kb = check_kbhit();
		if(kb) break;
	}

#ifndef WIN32
	close_keyboard();
#endif

	ao_close(device);
	free(in);
	free(out);
	return(kb);
}