PDDI ( progressive digital delay insertion ) is a digital audio device to manipulate the delay between words or silent period in a song. Delay can be progressively inserted or removed by using PDDI. The graph below shows the basic operation of PDDI.
To apply our Digital Signal Processing knowledge together with "C" and C50 assembler programming skills, to implement PDDI using the TMS320C50 starter's kit and observe the effects.
Our design is mainly aiming for speech related delay insertion, the sampling rate is chosen as 8k Hz. Because the power spectrum density of human speech is concentrated below 4 k Hz bandwidth, 8 k Hz sampling rate should be sufficient to retain the speech quality. Also such sampling rate is defined by ITU-T ( former CCITT ) for toll quality telephony network.
Threshold level is used to tell silence from active sound. In practical case, this is very hard to determine. The overall sound level is really controlled by the pre-amp. Therefore so as the absolute noise level. Also under different situations, the background noise level could be different. However, we can still find some meaningful value by setting everything to studio condition and measure the noise level.
Here is a plot of a short conversation from radio:
The noise level above is
The threshold level for the above is 3/128 . For a 16 bits A/D, threshold will be :
32768*3/128 = 768.
This way of distinguish active sound from silence is not robust as it is not able to identify strong background noise such as street noise. The most sophisticated way is to use a similar algorithm to VAD ( voice activity detection ) used in GSM. It will remove the strong background noise caused by vehicle, street noise etc by using autocorrelation method and long term filter. However, it is too complicated to implement.
Silence window is used to determine whether it is a low sound pressure level syllabus or a real pause between words. From speech processing literature, within a frame of 10msec to 40 msec, the speech signal is usually stationary. Therefore, we can say that if it is a low sound level syllabus, it should be within 10 m sec.
The silence window can be derived that if it is silence, it should be longer than 40 msec. With sampling rate is 8000 samples / sec, 10 msec * 8000 = 80.
The total delay time can be inserted is limited by the amount memory we can access. In our case, the total memory size is about 8 k. Therefore, the delay time will be:
8 K / 8 K = 1 sec.
By using a lower sampling rate to say about 6k samples/sec, we can get 8 / 6 = 1.33 sec.
ISample = word
* Sampled analogue speech input signal *
OSample = word
* Samples to be written to D/A chip *
WinSize = word
* To count the number of samples below threshold *
MaxWin = constant
* To compare with WindowSize for silence detection *
UserSel = [Normal | Delay Insertion | Buffer Reset]
UserInput = word
* Choice of UserSelection by user *
UserTmp = word
* The character transmitted via RS232 *
receive = word
* The character echoed back from C50 *
WinDiff = word
* The difference between MaxWin and WinSize *
NumSample = word
* The number of delay samples C50 has to send *
The biggest obstacle is the PC - C50 communication. Although the basic operation was demonstrated and well understood, we still don't know whether the increase of the code complexity and with RINT interrupt operating will upset the INT2 ISR.
Also we intend to test PDDI using a microphone. In this case, the noise threshold could be much higher than the one from the radio broadcast program. This has to be solved by trial and error.
Ken C. Pohlmann, "Principles of Digital Audio", Howard W. Sams & Co., Inc., Indiana, USA, 1985.
Talbot - Smith, M., "Audio Engineer's Reference Book", Butterworth-Heinemann Ltd, Great Britain, 1994.
K. Blait Benson, " Audio Engineering Handbook", NewYork, McGraw-Hill, 1988
Luc Baert, "Digital Audio and Compact Disc Technology", Boston, Focal Press, 1995.
The testing was done in the following two steps:
For the normal operation, the input signal is same as the output signal plus some time lagging caused by previous delay insertion.
For the delay insertion operation, the input signal used is a DC shifted square wave with half cycle longer than silence window. The negative half cycle of the wave form is close to zero. The expected output signal should be a square wave with twice of the zero half cycle.
The test confirmed that the negative half cycle was almost doubled.
For buffer reset, after the user has pressed the button, any time delay caused by insertion should disappear and PDDI should go back to normal mode.
The PC, C50, microphone and speaker are connected as below,
We also monitor the output of the pre amp and the output of the DSK using the CRO.
Firstly we tested it using normal mode. No delay could be heard from the speaker.
Then we changed it to delay insertion mode. By listening the time difference between our own voice and the sound replayed by the powered loud speaker, we can tell that delay is gradually inserted. At the maximum delay, the time difference is approximately one second. Also from the CRO, we can see the inserted signal because it is zero voltage dc.
Finally we used circular buffer reset. After reset, there was no time delay heard and it went back to normal mode as expected.
As summary, the testing showed that the program was working and our prediction was correct.
The purpose of bench mark and optimisation is mainly to see how fast these subroutines are and so to derive how fast the sampling rate can be with this set of code. The bench mark is done only on A/D interrupt service routine related code. INT2 related code is unimportant while the program is running. Although INT2 ISR will slow down the execution greatly when it is invoked, it is not continuos.
As there are quite a few branches in the code, only the worst case ( the code executed for the longest time ) is evaluated. In our case, the longest one is as follows;
- In Window routine, the sample is below threshold;
- In ModeSel routine, delay insertion is selected;
- In DelayI routine, SSamp is called;
- In SSamp routine, it branches to ChFlag;
The longest path in Window routine takes 21 cycles. There is one optimisation that can be made which is to use delay RETD instead of RET. It saves 2 cycles. Other branches can not be modified to delay ones as the branch only depend on the previous instruction.
The longest path in ModeSel routine takes 13 cycles. There is no optimisation that can be made.
The longest path in DelayI takes 20 cycles. There is no optimisation that can be made.
The longest path in SSample takes 23 cycles. The modification can be made on the RET. It saves 2 cycles.
Finally in RxSamp ISR, it is same for all conditions which takes 18 cycles.
Overall without optimisation, the longest path takes 95 cycles. The maximum time is 95 * 50 nsec = 4750 nsec. The maximum sampling rate therefore is 210526 sample / sec. It is way higher than the maximum sampling rate the starter's kit can handle. After optimisation, the longest path takes 91 cycles, the maximum sampling rate is 219780. One thing need to notice is that even without any optimisation, the code execution time is more than enough. Therefore it hasn't been our primary concern.
Finally with regarding to the overall code structure, it looks like with less CALLs and RETs the program should run much faster. However strange problems caused by INT2 forced us to use this program structure. The truth is that when the code within one subroutine is too long or branching too far, the program will crash. This program structure we adopted was the only one that wouldn't crash.
The problems are mainly associated with INT2 operation. When PC sends a byte to C50 and causes an INT2 interrupt, the C50 program crashes. Although we still don't fully understand why it crashes under some situation, we were able to solve the problem by a lot of trial and error.
The problem can be best described as a four tears problem.
Firstly, we had a lot of problems to find out how to send a byte to C50 and receive one byte while not using the kernel communication program. We solved the problem by writing another function called outbyte and inbyte. It works with the sample program CHARECHO.ASM. We continued to add code related to RINT ISR into the program, but it didn't work.
We realised that with the code we have, with RINT and INT2 both operating, the program always crashes. We tried to overcome the problem by polling RINT and using INT2 interrupt. It didn't work. We also tried polling both RINT and INT2, it worked. Actually it resulted the LAB4 we had. We thought that the problems were solved and continued on the project by adding more code.
When the code grew in size, the program started to crash again. With the help from our tutor, we recognised that the problem was that after INT2 ISR, the IFR flag should be reset to clear the interrupt. A small program was used to test the thought and it worked. We were rather confident that the key problem was identified and there shouldn't be more trouble ahead.
Finally, when we put the full working code into the program, it crashed again. It could be seen that the crash was caused by code size and branching range. By trial and error, we reduced the code size in each subroutine and increase the number of called functions. The final working program works perfectly. However, in some subroutine, if one more NOP is added, it will crash. We still don't know the exact cause.
During all those attempts, we also evaluated the possibility of using source reload. Every time the user changes the mode, the program will reload the DSK code and restart the C50. It worked and the reloading process takes about 1 second. Because our project has to run in real time, this method was abandoned after all.
- One improvement can be the implementation of PDDR ( Progressive Digital Delay Removal );
- More external memory can be added to increase the total delay time. In C50 the total addressable memory is 64K. The maximum delay is about 8 seconds which has commercial value;
- The window size and threshold value can be controlled by the user to adapt different situations.
The PDDI implemented using C50 Starter's kit is working as we designed. Because the way it was designed and coded, there is no trouble what so ever for real time operation. Further improvement as mentioned above can be done with more time and enough hardware support. With minor modification, this can be marketed and commercialised.
Borland C++ Programmer's Guide
Borland C++ User's Guide
TMS320C5X User's Guide
The core programs are written by the group (Louis Selvon and Bill Zeng). Some supporting subroutines are adopted and modified to suit the needs.
The C50 assembly codes adopted are
- AIC_INIT.ASM
- PROCINIT.ASM
The C50 assembly code adopted and modified is
The host library is rewritten to ease the use. The main procedures are kept as they are with structure changes only. Also two other functions are added to interface with ReadByte and SendByte. For more detail, please refer to the document on C50host.
C50 Code list ( PROJC50.ASM )
; ProjC50.ASM
; This is the final version of PDDI C50 side.
; Designed by Louis Selvon and Bill Zeng
; features
; * The full working version the program
; * include
; + The normal mode operation of PDDI ( in -> out )
; + The delay insertion mode
; * Maximum circular buffer size.
; * Circular Buffer Reset
.mmregs
****** CONSTANTS SETTING *************************
;******************************************
;******************************************
; AIC related constant setting
; The filter is set to about 3.4 k Hz.
; SCF = 288k * 3.6k / 3.4k = 272k which gives A => 18.
; Also sampling rate is 8 k Hz which gives B => 35.
TA .set 18 ;
TB .set 35 ;
RA .set 18 ;
RB .set 35 ;
AicCtl .set 08h ;
;******************************************
;******************************************
; Program related constant setting
CirBufH .set 0b00h ; The head of circular buffer
CirBufT .set 2bffh ; The tail of circular buffer
CBCtrl .set 0feh ; enable CB1 and CB2
; AR6 is mapped to CirBuf 1
; AR7 is mapped to CirBuf 2
ASCII1 .set 31h ; 1 in ASCII
ASCII2 .set 32h ; 2 in ASCII
ASCII3 .set 33h ; 3 in ASCII
ZERO .set 0 ; 0
ONE .set 1 ; one
MaxWin .set 80 ; The max window (default set to 10ms->80 samples)
****** DATA STARTS HERE ********
.ds 0400h
Data .word 0 ; just to identify the start of data page
WinSize .word 0 ; The WindowSize
Thresh .word 250h ; The threshold level, default set to( 250h )
UserSel .word 0 ; The user selection from PC
; ( > 0 for delay removal
; = 0 for normal mode
; < 0 for delay insertion )
UserTmp .word 0 ; stores the user selection temperorily
Sample .word 0 ; Temporary storage for the incomming sample
Count .word 0 ; Use to count the number of delay samples inserted
NumSamp .word 0 ; Storage of total delay samples to insert
InsFlag .word 0 ; indicates whether delay insertion is on
WinDiff .word 0 ; store the difference between MaxWin and WinSize
****** Setup interrupt vector ***
.ps 0080ah ; start to compile from 80ah
Rint: B RxSamp ; RxSamp receives sample
; from AIC and do the processing.
****** CODE STARTS HERE ********
.ps 0a00h
.entry
.listoff
.include "procinit.asm"
.include "aic_init.asm"
.liston
Setup: LDP #ZERO
SPLK #12h,IMR ; Write to interrupt mask register
; It enables RINT and INT2
;*********************************************************
;*********************************************************
;overwrite the INT2 vector
LACC #804h ; setup destination address
; 804h is the ISR table for INT2 ; INT2
SAMM BMAR ; save to block move address register
MAR *,AR0 ; point to AR0
LAR AR0,#BnchInt2 ; load source address
RPT #1 ; move two words
BLDP *+ ; do the move
CLRC INTM ; globally enable interrupts
;****************************************************
;****************************************************
; Setup two circular buffers with the same memory
; location
;******************************************************
SPLK #CirBufH,CBSR1 ; load the head of circular buffer of input pointer
SPLK #CirBufH,CBSR2 ; load the head of circular buffer of output pointer
SPLK #CirBufT,CBER1 ; load the tail of the circular buffer of input pointer
SPLK #CirBufT,CBER2 ; load the tail of the circular buffer of output pointer
LACC #CirBufH ; load the head of CB
SAMM AR7 ; initialise AR7
SAMM AR6 ; initialise AR6
SPLK #CBCtrl,CBCR ; load circular buffer control word
;****************************************************
;****************************************************
; The End of Setup
Main: B Main ; wait
;****************************************************
;****************************************************
;****************************************************
; Int2 receives the user's selction from PC and
; save it to UserSel.
; This ISR will also echo the selction back to PC
; for PC to check whether the right choice was
; received.
; The byte from PC is chosen as
; '1' --> 31H
; '2' --> 32H
; '3' --> 33H
;
; ISR will subtract it by 32H and make
; '1' < 0
; '2' = 0
; '3' > 0
;
; By doing this, it will be easier to do branch operation
;****************************************************
;****************************************************
Int2:
CALL ReadByte ; Read one byte
LDP #Data
SACL UserTmp,0
CALL SendByte ; Send it back
LACC UserTmp
SUB #ASCII2 ; subtract the input by 32h
SACL UserSel,0 ; save user input
LAMM IFR
AND #2h ; clear int2 interrupt
SAMM IFR
RETE
;*************************************************
;*************************************************
; The main operation
;*************************************************
RxSamp: LAMM DRR ; read a sample
LDP #Data
MAR *,AR6 ; load AR6 ( CirBuf1 )
SACL *+,0 ; save the sample to CirBuf1
SACL Sample,0 ; store the sample temporily
CALL Window ; call the Windowing routine
CALL ModeSel ; call the mode selection routine
RETE
;*************************************************
;*************************************************
; ModeSel is a subroutine to select
; which mode the user has chosen.
;***************************************************
ModeSel:
LACC UserSel ; load UserSel to ACC
BCND DIns,LT ; if UserSel < 0 call DelayInsertion
BCND BRes,GT ; if UserSel > 0 call Buffer Reset
Normal: CALL NormalM ; else UserSel = 0 call Normal mode
RET
DIns: CALL DelayI ; call delay insertion routine
RET
BRes: CALL BuffeR ; call buffer reset routine
RET
;**********************************************
;**********************************************
; end of ModeSel
;******************************************************
;******************************************************
; Windowing
; This routine is to distinquish the noise
; from the sound by comparing the sample value
; with the threshold.
; If the sample is bigger than the threshold,
; it will reset the window size
; else it will increment the window size by one.
;
;*******************************************************
;*******************************************************
Window: NOP
LDP #Data
LACC Sample ; load sample to ACC
ABS ; take absolute value
SUB Thresh ; Subtract the threshold
ROL ; rotate the ACC left one bit
BCND BelowT,C ; if the sample is less
; than the threshold jump
; to BelowT(hreshold)
ZAP ; set ACC to zero
SACL WinSize,0 ; reset WindowSize
RET ; return
BelowT: LACC WinSize ; load WinSize
ADD #ONE ; increment by one
SACL WinSize,0 ; save WinSize
SACL NumSamp,1 ; save to number delay samples
LACC #MaxWin ; load constant MaxWin
SUB WinSize ; subtract by WinSize
RETD
SACL WinDiff,0 ; save the difference
;******************************************************
;******************************************************
; The end of Windowing
;******************************************************
;******************************************************
; Delay Insertion
; This routine checks whether to send delay samples
; to D/A if the windowing criteria is satisfied, or if
; more delay samples are required to be sent.
;
;*******************************************************
;*******************************************************
DelayI: ZAP
LDP #Data ; Set data page
LACL InsFlag ; load insertion flag
BCND Insert,GT ; if InsFlag is on, goes to insert
; delay
LACC WinDiff ; load WinDiff
ROL ; rotate left
BCND Insert,C ; If WinSize >= MaxWin then proceed
; with delay insertion
;
; otherwise, do the same operation as Normal
CALL NormalM
RET
Insert: NOP
CALL SSamp ; call SSample ( SendSample )
RET
;******************************************************
;******************************************************
; SSample
; This routine sends delay samples to D/A
; The number of delay samples inserted is 2 * WinSize
;
;*******************************************************
;*******************************************************
SSamp: ZAP ; Set ACC -> 0
SAMM DXR ; Insert delay sample
LDP #Data ; set data page
LACC Count ; Load counter sample -> ACC
ADD #ONE ; Increment counter sample
SACL Count,0 ; Save new counter sample
; check no. of delay samples inserted
LACC NumSamp ; Load NumSamp -> ACC
SUB Count ; Compare NumSamp with Counter sample
ROL
BCND ChFlag,C ; If all delay samples have been inserted
; then go to change flag
LACC #ONE
SACL InsFlag,0 ; else set InsFlag to one
RET ; return
ChFlag: LACC #ZERO
SACL InsFlag,0 ; reset InsFlag
SACL Count,0 ; reset count
RETD
SACL NumSamp,0 ; reset NumSamp
;*******************************************************
;*******************************************************
; The end of Delay Insertion
;******************************************************
;******************************************************
; Circular Buffer Reset
; This subroutine resets the output pointer
;
;******************************************************
;******************************************************
BuffeR: LAMM AR6 ; read in CB1
SAMM AR7 ; write it to CB2
RET ; return
;******************************************************
;******************************************************
; The end of circular buffer reset
;******************************************************
;******************************************************
; Normal mode operation
; The output pointer ( AR7 for second circular buffer )
; will increase by one.
; Nothing else is done
;*******************************************************
;*******************************************************
NormalM:
MAR *,AR7 ; setup the pointer
LACC *+ ; load the output using that pointer
SAMM DXR ; output
RET
;******************************************************
;******************************************************
; The end of Normal Mode
BnchInt2:
B Int2
.listoff
.include "pc_comms.asm"
.liston
.end
PC host code list ( PC_PROJ.CPP )
// This program uses the
// library prepared by Bill Zeng
// to load PDDI into C50
// and start to execute it.
#include
#include "c50host.H"
#define SOLID 219
// **********************************************************************
// **********************************************************************
// void ScreenSetup(void)
//
// It sets up the screen to accept the user input
//
void ScreenSetup(void)
{
int pos_x,pos_y;
textbackground(LIGHTGRAY);
textcolor(DARKGRAY);
clrscr();
pos_y=2;
for(pos_x=5;pos_x<=75;pos_x++)
{
gotoxy(pos_x,pos_y);
putch(SOLID);
gotoxy(pos_x,pos_y+19);
putch(SOLID);
};
pos_x=5;
for(pos_y=2;pos_y<=20;pos_y++)
{
gotoxy(pos_x,pos_y);
putch(SOLID);
gotoxy(pos_x+70,pos_y);
putch(SOLID);
};
textcolor(RED);
gotoxy(14,4);
cprintf("P PPPPPP DDDDDDDD DDDDDDDD IIIIII");
gotoxy(14,5);
cprintf(" PP PP DDDDDDDDD DDDDDDDDD II");
gotoxy(14,6);
cprintf(" PP PP DD DDD DD DDD II");
gotoxy(14,7);
cprintf(" PPPPPPP DD DDD DD DDD II");
gotoxy(14,8);
cprintf(" PP DD DDD DD DDD II");
gotoxy(14,9);
cprintf(" PP DD DDD DD DDD II");
gotoxy(14,10);
cprintf(" PP DDDDDDDDD DDDDDDDDD II");
gotoxy(14,11);
cprintf(" PP DDDDDDDD DDDDDDDD IIIIII");
textcolor(BLACK);
gotoxy(24,13);
cprintf(" by Louis, & Bill");
gotoxy(7,15);
cprintf(" Choice : 1) Delay Insertion 2) Normal Mode");
gotoxy(7,16);
cprintf(" 3) Buffer Rest 4) Quit");
gotoxy(7,18);
textcolor(RED);
cprintf("Sent selection");
gotoxy(7,19);
cprintf("Received ");
textbackground(LIGHTGRAY);
textcolor(RED);
};
void main(void)
{
//
// set file name
char appfile[50]="projc50.dsk";
//
// define message
char message[50];
C50Host pddi_host(appfile,1,19200,0x0a00);
pddi_host.GetMessage(message);
// get the message from C50Host
printf(" C50 status : %s ",message);
// print the message
delay(1000);
unsigned char UserInput; // UserInput is to be sent to C50
// it is then translated to user's selection
// such as DelayInsertion
// , delay removal or normal
unsigned char receive; // receive stores the echo back from
// c50.
//********************************************************
//********************************************************
// Setup the user interface screen
//
ScreenSetup();
while(UserInput!='4')
{
delay(50);
if (kbhit())
{
UserInput=getch();
if ((UserInput=='1')||(UserInput=='2')||(UserInput=='3'))
{
gotoxy(25,18);
cprintf("%c",UserInput);
// send out the userinput
pddi_host.outbyte(UserInput);
// receive the echo
receive=pddi_host.inbyte();
gotoxy(25,19);
cprintf("%c HEX(%X)",receive,receive);
if (UserInput=='3')
{
pddi_host.outbyte('2');
receive=pddi_host.inbyte();
};
};
}; // if keyboard is kit get a user input
} ;
}
