main.cpp

00001 /* DPCM & Rice Golomb Lossless Audio Player and Realtime encoder */
00002 #include "SDHCFileSystem.h"
00003 #include "mbed.h"
00004 #include "string"
00005 #include "_bitio.h"
00006 
00007 //FILE    *infp,*outfp;
00008 SDFileSystem sd(p5, p6, p7, p8, "sd");
00009 DigitalOut led1(LED1);
00010 DigitalOut led2(LED2);
00011 AnalogOut DACout(p18);
00012 Ticker tick;
00013 
00014 // BU9480F define
00015 SPI bu9480f(p11,p12,p13);
00016 DigitalOut LRCLK(p14);
00017 // BU9480F define.end
00018 
00019 
00020 // a FIFO for the DAC
00021 #define TXFIFO_FULL 1
00022 #define RAM_LENGTH 8192//8192
00023 #define RAM_LIMIT (RAM_LENGTH - 1) 
00024 volatile short DAC_fifo[RAM_LENGTH];
00025 volatile short DAC_wptr=0;
00026 volatile short DAC_rptr=0;
00027 volatile short DAC_on;
00028 volatile short DAC_diff=0;
00029 
00030 void dac_out()
00031 {
00032   //  printf("\t%d\r\n",DAC_diff);
00033     if (DAC_diff > 1) {
00034         led2 = 0;        
00035         
00036         LRCLK = 0;
00037         bu9480f.write(DAC_fifo[DAC_rptr++]);
00038         DAC_rptr &= RAM_LIMIT;
00039         
00040         LRCLK = 1;
00041         bu9480f.write(DAC_fifo[DAC_rptr++]);
00042         DAC_rptr &= RAM_LIMIT;
00043         
00044         DAC_diff-=2;
00045         
00046    }else led2 = 1;
00047 }
00048 
00049 void encode(long int n){
00050     int zero_shift = 0;
00051     
00052     if(n < 0){
00053         putbit(0);                    // sign (put 0:if n as negative)
00054         n = -n;                        // n = abs(n)
00055         //printf("\t 0");
00056     }
00057     else{ 
00058         putbit(1);                    // sign (put 1:if n as positive)
00059         //printf("\t 1");
00060     }
00061     zero_shift = (n >> (k));
00062     //printf("\t shift= %d",zero_shift);
00063     while(zero_shift > 0){
00064 
00065         zero_shift--;
00066         putbit(0);
00067     }    // put n/(2^k) 0's
00068     
00069     putbit(1);                        // terminating "1"
00070     putbits(k,rightbits(k,n));
00071     //printf("\t finish= %d \r\n",(n & ((1U<<k)-1)));
00072 }
00073 
00074 
00075 
00076 void decode(void){
00077     //short dac_data;
00078     long int decode_buff;
00079     short diff,diff2;
00080     unsigned int buff_sign,zero_shift;
00081     //char flag;
00082     
00083     diff = 0;
00084     diff2 = 0;
00085     // get sign(1 for positive, 0 for negative)
00086     while(1){
00087         
00088         if((buff_sign = getbit())==OVERRUN)break;
00089         zero_shift = 0;
00090         while(getbit()==0)zero_shift++;
00091         
00092         decode_buff = (signed int)((1U << k)*zero_shift);
00093         decode_buff += (getbits(k));
00094         
00095         if(!buff_sign)decode_buff =- decode_buff;
00096         /* return decode_buff; */
00097         diff =(diff + decode_buff);
00098         DAC_fifo[DAC_wptr++]=(short)diff;
00099         DAC_wptr &= RAM_LIMIT;
00100         //DAC_diff++;
00101         while (DAC_diff > RAM_LIMIT){
00102             led1 = 1;
00103         }   //wait
00104         led1=0;
00105         
00106         if((buff_sign = getbit())==OVERRUN)break;
00107         zero_shift = 0;
00108         while(getbit()==0)zero_shift++;
00109         
00110         decode_buff = (signed int)((1U << k)*zero_shift);
00111         decode_buff += (getbits(k));
00112         
00113         if(!buff_sign)decode_buff =- decode_buff;
00114         /* return decode_buff; */
00115         diff2 =(diff2 + decode_buff);
00116 
00117         DAC_fifo[DAC_wptr++]=(short)diff2;
00118         DAC_wptr &= RAM_LIMIT;
00119         DAC_diff+=2;
00120         
00121         while (DAC_diff > RAM_LIMIT){
00122             led1 = 1;
00123         }   //wait
00124         led1=0;
00125         
00126     
00127          
00128     }
00129 }
00130 
00131   
00132 int main() {
00133 
00134     
00135     if ( NULL == (infp = fopen( "/sd/test.rgm", "rb" )) ) {
00136         printf( "\r\nError: The message file cannot be accessed\r\n" );
00137         return -1;
00138     }
00139     // bu9480f init
00140     bu9480f.format(16,0);
00141     bu9480f.frequency(16000000); //16MHz
00142     // bu9480f init.end
00143     
00144       
00145     tick.attach_us(&dac_out, 41); //set 24.000kHz sampling data   
00146     decode();
00147     tick.detach();    
00148         
00149     fclose( infp );
00150     //fclose( outfp );  
00151 
00152  
00153     
00154     while (1);
00155 }
00156