coldfire_mpegsubb.s

Application (fix point) for playing MP3 data on embedded systems. mp3play is designed to be able to

//              a1: out_sample_buffer
//              a2: dewindow (##4)
//              d0: buffer offset
//              d1.w: w_begin  (#2)
//              d2.w: w_width  (#2)
//              d3.w: freq_div (#2)
//              d4.l: dew_shift (##4)
//              -> a1 = out_sample_buffer + out_sample_length
MPEGSUBB_window_band:

			   sub.l	#44, sp
               movem.l  d2-d7/a2-a6,(sp)

	       move.l	sp@(48), a0
	       move.l	sp@(52), a1
	       move.l	sp@(56), a2
	       move.l	sp@(60), d0
	       move.l	sp@(64), d1
	       move.l	sp@(68), d2
	       move.l	sp@(72), d3
	       move.l	sp@(76), d4
	       ext.l	d1
	       ext.l	d2
	       ext.l	d3

//               move.w   w_begin,d1 // #2
               move.l   d2,-(sp) // #2
               move.l   a2,a4    // ##4
               lea.l    pc@(pcm_loops),a2 // #2
               move.w   (a2,d3.l*2),d6 // #2
	       ext.l	d6
               move.l   d3,d2 // #2

//               lea.l    window_table,a2     //  ##4 External now
               lea.l    (a4,d1.l*2),a2       //  ##4 a2 = &dewindow[ w_begin ]
               moveq.l  # INT_FACTOR-15,d7    //  ##4 External now
               add.l    d4,d7                //  ##4 new scale
               add.l    d0,d1
               and.l    #15,d1               // d1 = start
               move.l   a0,a4                // buf0 = &buf_ptr[ 0 ]
               lea      (a0,d1.l*2),a3       // buf1 = &buf_ptr[ start ]
//               move.w   w_width,d3 // #2
               move.l   (sp),d3 // #2
               add.l    d1,d3
			   ext.l    d3
               cmp.l    #16,d3
               jble      window_band1
               move.l   #16,d3               // d3 = top
window_band1:
               sub.l    d1,d3                // d3 = cnt1
//               move.w   w_width,d4  // #2
               move.l   (sp),d4 // #2
			   ext.l    d4
               sub.l    d3,d4                // d4 = cnt0

//               move.w   freq_div,d2 // #2
               lsl.l    #4,d2
               move.l   d2,d5
               sub.l    d3,d5                // off1 = freq_div*16 - cnt1
               ext.l    d5
               add.l    d5,d5
               move.l   d5,a5                // a5 = off1
               move.l   d2,d5
               sub.l    d4,d5                // off0 = freq_div*16 - cnt0
               add.l    d5,d5
               move.l   d5,a6                // a6 = off0
//               sub.w    w_width,d2           // offd = freq_div*16 - w_width (#2)
               sub.l    (sp),d2                // offd = freq_div*16 - w_width (#2)
               ext.l    d2
               add.l    d2,d2

//               moveq.l  # WINDOW_FACTOR+INT_FACTOR-15,d7 // ##4 External now
//               move.w   pcm_count,d6  // #2
//               subq.w   #1,d6         // for DBRA loop ; #2


#define MULADDN(p1, p2) jbsr      mulladdwin_ ## p1 ## _ ## p2

#ifdef COLDFIRE_MAC

/* This code isn't really set up for using the coldfire MAC unit.
 * It would be better if the in memory data items were all in .l format
 * then the macl instruction suite could be used to decrease execution
 * time fairly impressively.
 */
// The mac instruction in this one is "mac.w d5l, d1l"
#define MULADDWIN(p1)		\
	move.w	(p1)+, d1;	\
	move.w	(a2)+, d5;	\
	dc.w	0xa205;		\
	dc.w	0x0000

//              MULADD0 <rept num>
// The mac instruction here is "move.l #0, acc"
#define MULADD0(p1)			\
               dc.w	0xa13c;		\
	       dc.l	0;		\
               MULADDN  (a3,p1)

//              MULADD1 <rept num>
// The mac instruction here is "move.l acc, d5"
#define MULADD1(p1)			\
               add.l    a5,a3;		\
               MULADDN  (a4,p1);	\
	       dc.w	0xa185

#else					// ! COLDFIRE_MAC
//              MULADDWIN {a3|a4}
#define MULADDWIN(p1)			\
               move.w   (p1)+,d1;	\
               muls.w   (a2)+,d1;	\
               add.l    d1,d5


//              MULADD0 <rept num>
#define MULADD0(p1)			\
               clr.l    d5;		\
               MULADDN  (a3,p1)

//              MULADD1 <rept num>
#define MULADD1(p1)			\
               add.l    a5,a3;		\
               MULADDN  (a4,p1)
#endif					// COLDFIRE_MAC

               // CHECKBOUNDS <loop label>
#ifdef WINDOW_CLIP
#define CHECKBOUNDS(p1) \
               add.l    a6,a4; \
               add.l    d2,a2; \
               asr.l    d7,d5; \
               move.w   d5,a0; \
               cmp.l    a0,d5; \
               bne.b    2f; \
1: \
               move.w   d5,(a1)+; \
               DBRA     (d6,p1); \
               jbra      window_band9; \
2: \
               not.l    d5; \
               add.l    d5,d5; \
               move.l   IMMED 0xFFFF8000,d5; \
               negx.l   d5; \
               bra.s    1b; \
/*             move.w   d5,(a1)+; */ \
/*             DBRA     (d6,p1); */ \
/*             bra      window_band9; */

#else /* WINDOW_CLIP */

#define CHECKBOUNDS(p1) \
               add.l    a6,a4; \
               add.l    d2,a2; \
               asr.l    d7,d5; \
               move.w   d5,(a1)+; \
               DBRA     (d6,p1); \
               jbra      window_band9

#endif /* WINDOW_CLIP */


//               move.w   w_width,d3 // #2
               move.l   (sp),d3 // #2
	       ext.l	d3
               lea      pc@(window_q0muls),a0
               cmp.l    #4,d3
               jble      window_qmul
               lea      pc@(window_q1muls),a0
               cmp.l    #8,d3
               jble      window_qmul
               lea      pc@(window_q2muls),a0
window_qmul:
               move.l   (a0,d4.l*4),a0
               jmp      (pc,a0)

window_q2mul0:
               MULADD0  (16)
               MULADD1  (0)
               CHECKBOUNDS (window_q2mul0)
window_q2mul1:
               MULADD0  (15)
               MULADD1  (1)
               CHECKBOUNDS (window_q2mul1)
window_q2mul2:
               MULADD0  (14)
               MULADD1  (2)
               CHECKBOUNDS (window_q2mul2)
window_q2mul3:
               MULADD0  (13)
               MULADD1  (3)
               CHECKBOUNDS (window_q2mul3)
window_q2mul4:
               MULADD0  (12)
               MULADD1  (4)
               CHECKBOUNDS (window_q2mul4)
window_q2mul5:
               MULADD0  (11)
               MULADD1  (5)
               CHECKBOUNDS (window_q2mul5)
window_q2mul6:
               MULADD0  (10)
               MULADD1  (6)
               CHECKBOUNDS (window_q2mul6)
window_q2mul7:
               MULADD0  (9)
               MULADD1  (7)
               CHECKBOUNDS (window_q2mul7)
window_q2mul8:
               MULADD0  (8)
               MULADD1  (8)
               CHECKBOUNDS (window_q2mul8)
window_q2mul9:
               MULADD0  (7)
               MULADD1  (9)
               CHECKBOUNDS (window_q2mul9)
window_q2mul10:
               MULADD0  (6)
               MULADD1  (10)
               CHECKBOUNDS (window_q2mul10)
window_q2mul11:
               MULADD0  (5)
               MULADD1  (11)
               CHECKBOUNDS (window_q2mul11)
window_q2mul12:
               MULADD0  (4)
               MULADD1  (12)
               CHECKBOUNDS (window_q2mul12)
window_q2mul13:
               MULADD0  (3)
               MULADD1  (13)
               CHECKBOUNDS (window_q2mul13)
window_q2mul14:
               MULADD0  (2)
               MULADD1  (14)
               CHECKBOUNDS (window_q2mul14)
window_q2mul15:
               MULADD0  (1)
               MULADD1  (15)
               CHECKBOUNDS (window_q2mul15)

window_q1mul0:
               MULADD0  (8)
               MULADD1  (0)
               CHECKBOUNDS (window_q1mul0)
window_q1mul1:
               MULADD0  (7)
               MULADD1  (1)
               CHECKBOUNDS (window_q1mul1)
window_q1mul2:
               MULADD0  (6)
               MULADD1  (2)
               CHECKBOUNDS (window_q1mul2)
window_q1mul3:
               MULADD0  (5)
               MULADD1  (3)
               CHECKBOUNDS (window_q1mul3)
window_q1mul4:
               MULADD0  (4)
               MULADD1  (4)
               CHECKBOUNDS (window_q1mul4)
window_q1mul5:
               MULADD0  (3)
               MULADD1  (5)
               CHECKBOUNDS (window_q1mul5)
window_q1mul6:
               MULADD0  (2)
               MULADD1  (6)
               CHECKBOUNDS (window_q1mul6)
window_q1mul7:
               MULADD0  (1)
               MULADD1  (7)
               CHECKBOUNDS (window_q1mul7)

window_q0mul0:
               MULADD0  (4)
               MULADD1  (0)
               CHECKBOUNDS (window_q0mul0)
window_q0mul1:
               MULADD0  (3)
               MULADD1  (1)
               CHECKBOUNDS (window_q0mul1)
window_q0mul2:
               MULADD0  (2)
               MULADD1  (2)
               CHECKBOUNDS (window_q0mul2)
window_q0mul3:
               MULADD0  (1)
               MULADD1  (3)
               CHECKBOUNDS (window_q0mul3)

window_band9:
               move.l   (sp)+,d2
               movem.l  (sp),d2-d7/a2-a6
	       add.l    #44, sp
               rts

mulladdwin_a3_16: MULADDWIN(a3)
mulladdwin_a3_15: MULADDWIN(a3)
mulladdwin_a3_14: MULADDWIN(a3)
mulladdwin_a3_13: MULADDWIN(a3)
mulladdwin_a3_12: MULADDWIN(a3)
mulladdwin_a3_11: MULADDWIN(a3)
mulladdwin_a3_10: MULADDWIN(a3)
mulladdwin_a3_9:  MULADDWIN(a3)
mulladdwin_a3_8:  MULADDWIN(a3)
mulladdwin_a3_7:  MULADDWIN(a3)
mulladdwin_a3_6:  MULADDWIN(a3)
mulladdwin_a3_5:  MULADDWIN(a3)
mulladdwin_a3_4:  MULADDWIN(a3)
mulladdwin_a3_3:  MULADDWIN(a3)
mulladdwin_a3_2:  MULADDWIN(a3)
mulladdwin_a3_1:  MULADDWIN(a3)
mulladdwin_a3_0:  rts

mulladdwin_a4_16: MULADDWIN(a4)
mulladdwin_a4_15: MULADDWIN(a4)
mulladdwin_a4_14: MULADDWIN(a4)
mulladdwin_a4_13: MULADDWIN(a4)
mulladdwin_a4_12: MULADDWIN(a4)
mulladdwin_a4_11: MULADDWIN(a4)
mulladdwin_a4_10: MULADDWIN(a4)
mulladdwin_a4_9:  MULADDWIN(a4)
mulladdwin_a4_8:  MULADDWIN(a4)
mulladdwin_a4_7:  MULADDWIN(a4)
mulladdwin_a4_6:  MULADDWIN(a4)
mulladdwin_a4_5:  MULADDWIN(a4)
mulladdwin_a4_4:  MULADDWIN(a4)
mulladdwin_a4_3:  MULADDWIN(a4)
mulladdwin_a4_2:  MULADDWIN(a4)
mulladdwin_a4_1:  MULADDWIN(a4)
mulladdwin_a4_0:  rts


/* Lookup table to allow us to dispatch into the above pile
 * of procedures easily.  These are stored PC relative from the
 * branch instruction before the window_q2mul0 label which means
 * we can pack this lot into the text segment and thus reduce
 * data size a little.
 */
window_q2muls: dc.l     window_q2mul0 - window_q2mul0 + 2
               dc.l     window_q2mul1 - window_q2mul0 + 2
               dc.l     window_q2mul2 - window_q2mul0 + 2
               dc.l     window_q2mul3 - window_q2mul0 + 2
               dc.l     window_q2mul4 - window_q2mul0 + 2
               dc.l     window_q2mul5 - window_q2mul0 + 2
               dc.l     window_q2mul6 - window_q2mul0 + 2
               dc.l     window_q2mul7 - window_q2mul0 + 2
               dc.l     window_q2mul8 - window_q2mul0 + 2
               dc.l     window_q2mul9 - window_q2mul0 + 2
               dc.l     window_q2mul10 - window_q2mul0 + 2
               dc.l     window_q2mul11 - window_q2mul0 + 2
               dc.l     window_q2mul12 - window_q2mul0 + 2
               dc.l     window_q2mul13 - window_q2mul0 + 2
               dc.l     window_q2mul14 - window_q2mul0 + 2
               dc.l     window_q2mul15 - window_q2mul0 + 2

window_q1muls: dc.l     window_q1mul0 - window_q2mul0 + 2
               dc.l     window_q1mul1 - window_q2mul0 + 2
               dc.l     window_q1mul2 - window_q2mul0 + 2
               dc.l     window_q1mul3 - window_q2mul0 + 2
               dc.l     window_q1mul4 - window_q2mul0 + 2
               dc.l     window_q1mul5 - window_q2mul0 + 2
               dc.l     window_q1mul6 - window_q2mul0 + 2
               dc.l     window_q1mul7 - window_q2mul0 + 2

window_q0muls: dc.l     window_q0mul0 - window_q2mul0 + 2
               dc.l     window_q0mul1 - window_q2mul0 + 2
               dc.l     window_q0mul2 - window_q2mul0 + 2
               dc.l     window_q0mul3 - window_q2mul0 + 2