开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 磁盘/存储 > SCSI/ASPI > 查看源码
resample.c
资源名称：cdrecord-1.8.tar.gz　[点击查看]
上传用户：xiejiait
上传日期：2007-01-06
资源大小：881k
文件大小：27k
源码类别：

SCSI/ASPI

开发平台：

MultiPlatform

resample.c：源码内容
  1. /* @(#)resample.c 1.2 99/12/19 Copyright 1998,1999 Heiko Eissfeldt */
  2. #ifndef lint
  3. static char     sccsid[] =
  4. "@(#)resample.c 1.2 99/12/19 Copyright 1998,1999 Heiko Eissfeldt";
  6. #endif
  7. /* resampling module 
  8.  *
  9.  * The audio data has been read. Here are the
  10.  * functions to ensure a correct continuation
  11.  * of the output stream and to convert to a
  12.  * lower sample rate.
  13.  *
  14.  */
  16. #undef DEBUG_VOTE_ENDIANESS
  17. #undef DEBUG_SHIFTS /* simulate bad cdrom drives */
  18. #undef DEBUG_MATCHING
  19. #undef SHOW_JITTER
  20. #undef CHECK_MEM
  22. #include "config.h"
  23. #include <timedefs.h>
  24. #include <stdio.h>
  25. #include <stdlib.h>
  26. #if defined (HAVE_UNISTD_H) && (HAVE_UNISTD_H == 1)
  27. #include <sys/types.h>
  28. #include <unistd.h>
  29. #endif
  30. #include <standard.h>
  31. #include <strdefs.h>
  32. #include <limits.h>
  33. #include <assert.h>
  34. #include <math.h>
  36. #include <scg/scsitransp.h>
  38. #include "mytype.h"
  39. #include "cdda2wav.h"
  40. #include "interface.h"
  41. #include "byteorder.h"
  42. #include "ringbuff.h"
  43. #include "resample.h"
  44. #include "sndconfig.h"
  45. #include "global.h"
  48. int waitforsignal = 0; /* flag: wait for any audio response */
  49. int any_signal = 0;
  51. short undersampling; /* conversion factor */
  52. short samples_to_do; /* loop variable for conversion */
  53. int Halved; /* interpolate due to non integral divider */
  55. static long lsum = 0, rsum = 0;        /* accumulator for left/right channel */
  56. static long ls2 = 0, rs2 = 0, ls3 = 0, rs3 = 0, auxl = 0, auxr = 0;
  58. static const unsigned char *my_symmemmem __PR((const unsigned char *HAYSTACK, const size_t HAYSTACK_LEN, const unsigned char *const NEEDLE, const size_t NEEDLE_LEN));
  59. static const unsigned char *my_memmem __PR((const unsigned char *HAYSTACK, const size_t HAYSTACK_LEN, const unsigned char *const NEEDLE, const size_t NEEDLE_LEN));
  60. static const unsigned char *my_memrmem __PR((const unsigned char *HAYSTACK, const size_t HAYSTACK_LEN, const unsigned char *const NEEDLE, const size_t NEEDLE_LEN));
  61. static const unsigned char *sync_buffers __PR((const unsigned char *const newbuf));
  62. static long interpolate __PR((long p1, long p2, long p3));
  63. static void emit_sample __PR((long lsumval, long rsumval, long channels));
  64. static void change_endianness __PR((UINT4 *pSam, unsigned int Samples));
  65. static void swap_channels __PR((UINT4 *pSam, unsigned int Samples));
  66. static int guess_endianess __PR((UINT4 *p, short *p2, unsigned int SamplesToDo));
  69. #ifdef CHECK_MEM
  70. static void
  71. check_mem __PR((const unsigned char *p, unsigned long amount, const unsigned char *q, unsigned line, char *file));
  73. static void check_mem(p, amount, q, line, file)
  74. const unsigned char *p;
  75. unsigned long amount;
  76. const unsigned char *q;
  77. unsigned line;
  78. char *file;
  79. {
  80. if (p < q || p+amount > q + ENTRY_SIZE) {
  81. fprintf(stderr, "file %s, line %u: invalid buffer range (%p - %p), allowed is (%p - %p)n",
  82. file,line,p, p+amount-1, q, q + ENTRY_SIZE-1);
  83. exit(1);
  84. }
  85. }
  86. #endif
  89. #ifdef DEBUG_MATCHING
  90. int memcmp(const void * a, const void * b, size_t c)
  91. {
  92.   return 1;
  93. }
  94. #endif
  96. static const unsigned char *
  97. my_symmemmem (HAYSTACK, HAYSTACK_LEN, NEEDLE, NEEDLE_LEN)
  98. const unsigned char * HAYSTACK;
  99. const size_t HAYSTACK_LEN;
  100. const unsigned char * const NEEDLE;
  101. const size_t NEEDLE_LEN;
  102. {
  103.   const unsigned char * const UPPER_LIMIT = HAYSTACK + HAYSTACK_LEN - NEEDLE_LEN - 1;
  104.   const unsigned char * HAYSTACK2 = HAYSTACK-1;
  106.   while (HAYSTACK <= UPPER_LIMIT) {
  107.     if (memcmp(NEEDLE, HAYSTACK, NEEDLE_LEN) == 0) {
  108.       return HAYSTACK;
  109.     } else {
  110.       if (memcmp(NEEDLE, HAYSTACK2, NEEDLE_LEN) == 0) {
  111.         return HAYSTACK2;
  112.       }
  113.       HAYSTACK2--;
  114.       HAYSTACK++;
  115.     }
  116.   }
  117. #ifdef DEBUG_MATCHING
  118.   HAYSTACK2++;
  119.   HAYSTACK--;
  120.   fprintf(stderr, "scompared %p-%p with %p-%p (%p)n",
  121.    NEEDLE, NEEDLE + NEEDLE_LEN-1,
  122.  HAYSTACK2, HAYSTACK + NEEDLE_LEN-1, HAYSTACK);
  123. #endif
  124.   return NULL;
  125. }
  127. static const unsigned char *
  128. my_memmem (HAYSTACK, HAYSTACK_LEN, NEEDLE, NEEDLE_LEN)
  129. const unsigned char * HAYSTACK;
  130. const size_t HAYSTACK_LEN;
  131. const unsigned char * const NEEDLE;
  132. const size_t NEEDLE_LEN;
  133. {
  134.   const unsigned char * const UPPER_LIMIT = HAYSTACK + HAYSTACK_LEN - NEEDLE_LEN;
  136.   while (HAYSTACK <= UPPER_LIMIT) {
  137.     if (memcmp(NEEDLE, HAYSTACK, NEEDLE_LEN) == 0) {
  138.       return HAYSTACK;
  139.     } else {
  140.       HAYSTACK++;
  141.     }
  142.   }
  143. #ifdef DEBUG_MATCHING
  144.   HAYSTACK--;
  145.   fprintf(stderr, "fcompared %p-%p with %p-%p (%p)n",
  146.    NEEDLE, NEEDLE + NEEDLE_LEN-1,
  147.  HAYSTACK - HAYSTACK_LEN + NEEDLE_LEN, HAYSTACK + NEEDLE_LEN-1,
  148.  HAYSTACK);
  149. #endif
  150.   return NULL;
  151. }
  153. static const unsigned char *
  154. my_memrmem (HAYSTACK, HAYSTACK_LEN, NEEDLE, NEEDLE_LEN)
  155. const unsigned char * HAYSTACK;
  156. const size_t HAYSTACK_LEN;
  157. const unsigned char * const NEEDLE;
  158. const size_t NEEDLE_LEN;
  159. {
  160.   const unsigned char * const LOWER_LIMIT = HAYSTACK - (HAYSTACK_LEN - 1);
  162.   while (HAYSTACK >= LOWER_LIMIT) {
  163.     if (memcmp(NEEDLE, HAYSTACK, NEEDLE_LEN) == 0) {
  164.       return HAYSTACK;
  165.     } else {
  166.       HAYSTACK--;
  167.     }
  168.   }
  169. #ifdef DEBUG_MATCHING
  170.   HAYSTACK++;
  171.   fprintf(stderr, "bcompared %p-%p with %p-%p (%p)n",
  172.    NEEDLE, NEEDLE + NEEDLE_LEN-1,
  173.  HAYSTACK, HAYSTACK + (HAYSTACK_LEN - 1),
  174.  HAYSTACK + (HAYSTACK_LEN - 1) - NEEDLE_LEN - 1);
  175. #endif
  176.   return NULL;
  177. }
  179. /* find continuation in new buffer */
  180. static const unsigned char *
  181. sync_buffers(newbuf)
  182. const unsigned char * const newbuf;
  183. {
  184.     const unsigned char *retval = newbuf;
  186.     if (global.overlap != 0) {
  187.       /* find position of SYNC_SIZE bytes 
  188.  of the old buffer in the new buffer */
  189.       size_t haystack_len;
  190.       const size_t needle_len = SYNC_SIZE;
  191.       const unsigned char * const oldbuf = (const unsigned char *) (get_previous_read_buffer()->data);
  192.       const unsigned char * haystack;
  193.       const unsigned char * needle;
  195.       /* compare the previous buffer with the new one
  196.        *
  197.        * 1. symmetrical search:
  198.        *   look for the last SYNC_SIZE bytes of the previous buffer
  199.        *   in the new buffer (from the optimum to the outer positions).
  200.        *
  201.        * 2. if the first approach did not find anything do forward search
  202.        *   look for the last SYNC_SIZE bytes of the previous buffer
  203.        *   in the new buffer (from behind the overlap to the end).
  204.        *   
  205.        */
  207.       haystack_len = min((global.nsectors - global.overlap)*CD_FRAMESIZE_RAW
  208.  +SYNC_SIZE+1,
  209.        global.overlap*CD_FRAMESIZE_RAW);
  210.       /* expected here */
  211.       haystack = newbuf + CD_FRAMESIZE_RAW*global.overlap - SYNC_SIZE;
  212.       needle = oldbuf + CD_FRAMESIZE_RAW*global.nsectors - SYNC_SIZE; 
  214. #ifdef DEBUG_MATCHING
  215. fprintf(stderr, "oldbuf    %p-%p  new %p-%p %u %u %un",
  216. oldbuf, oldbuf + CD_FRAMESIZE_RAW*global.nsectors - 1,
  217. newbuf, newbuf + CD_FRAMESIZE_RAW*global.nsectors - 1,
  218. CD_FRAMESIZE_RAW*global.nsectors, global.nsectors, global.overlap);
  219. #endif
  221.       retval = my_symmemmem(haystack, haystack_len, needle, needle_len);
  222.       if (retval != NULL) {
  223. retval += SYNC_SIZE;
  224.       } else {
  225. /* fallback to asymmetrical search */
  227. /* if there is no asymmetrical part left, return with 'not found' */
  228. if (2*global.overlap == global.nsectors) {
  229.   retval = NULL;
  230. } else if (2*global.overlap > global.nsectors) {
  231.   /* the asymmetrical part is in front, search backwards */
  232.           haystack_len = (2*global.overlap-global.nsectors)*CD_FRAMESIZE_RAW;
  233.           haystack = newbuf + haystack_len - 1;
  234.           retval = my_memrmem(haystack, haystack_len, needle, needle_len);
  235. } else {
  236.   /* the asymmetrical part is at the end, search forward */
  237.           haystack = newbuf + 2*(global.overlap*CD_FRAMESIZE_RAW - SYNC_SIZE);
  238.           haystack_len = (global.nsectors-2*global.overlap)*CD_FRAMESIZE_RAW + 2*SYNC_SIZE;
  239.           retval = my_memmem(haystack, haystack_len, needle, needle_len);
  240. }
  241.         if (retval != NULL)
  242.   retval += SYNC_SIZE;
  243.       }
  245. #ifdef SHOW_JITTER
  246.       if (retval) {
  247. fprintf(stderr,"%dn",
  248. retval-(newbuf+global.overlap*CD_FRAMESIZE_RAW));
  249.       } else {
  250. fprintf(stderr,"no matchn");
  251.       }
  252. #endif
  253.     }
  255.     return retval;
  256. }
  258. /* quadratic interpolation
  259.  * p1, p3 span the interval 0 - 2. give interpolated value for 1/2 */
  260. static long int 
  261. interpolate( p1, p2, p3)
  262. long int p1;
  263. long int p2;
  264. long int p3;
  265. {
  266.   return (3L*p1 + 6L*p2 - p3)/8L;
  267. }
  269. static unsigned char *pStart; /* running ptr defining end of output buffer */
  270. static unsigned char *pDst; /* start of output buffer */
  271. /*
  272.  * Write the filtered sample into the output buffer.
  273.  */
  274. static void 
  275. emit_sample( lsumval, rsumval, channels )
  276. long lsumval;
  277. long rsumval;
  278. long channels;
  279. {
  280.     if (global.findminmax) {
  281.        if (rsumval > global.maxamp[0]) global.maxamp[0] = rsumval;
  282.        if (rsumval < global.minamp[0]) global.minamp[0] = rsumval;
  283.        if (lsumval < global.minamp[1]) global.minamp[1] = lsumval;
  284.        if (lsumval > global.maxamp[1]) global.maxamp[1] = lsumval;
  285.     }
  286.     /* convert to output format */
  287.     if ( channels == 1 ) {
  288. short sum;       /* mono section */
  289. sum = ( lsumval + rsumval ) >> (global.sh_bits + 1);
  290. if ( global.sh_bits == 8 ) {
  291.     if ( ( (char) sum) != '' ) {
  292. if ( any_signal == 0 ) {
  293.     pStart = (unsigned char *) pDst;
  294.     any_signal = 1;
  295. }
  296.     }
  297.     *pDst++ = ( unsigned char ) sum + ( 1 << 7 );
  298. } else {
  299.     short * myptr = (short *) pDst;
  300.     if ( sum != 0 ) {
  301. if ( any_signal == 0 ) {
  302.     pStart = (unsigned char *) pDst;
  303.     any_signal = 1;
  304. }
  305.     }
  306.     *myptr = sum;
  307.     pDst += sizeof( short );
  308. }
  309.     } else {
  310. /* stereo section */
  311. lsumval >>= global.sh_bits;
  312. rsumval >>= global.sh_bits;
  313. if ( global.sh_bits == 8 ) {
  314.     if ( (( char ) lsumval != '') || (( char ) rsumval != '')) {
  315. if ( any_signal == 0 ) {
  316.     pStart = (unsigned char *) pDst;
  317.     any_signal = 1;
  318. }
  319.     }
  320.     *pDst++ = ( unsigned char )( short ) lsumval + ( 1 << 7 );
  321.     *pDst++ = ( unsigned char )( short ) rsumval + ( 1 << 7 );
  322. } else {
  323.     short * myptr = (short *) pDst;
  324.     if ( (( short ) lsumval != 0) || (( short ) rsumval != 0)) {
  325. if ( any_signal == 0 ) {
  326.     pStart = (unsigned char *) pDst;
  327.     any_signal = 1;
  328. }
  329.     }
  330.     *myptr++ = ( short ) lsumval;
  331.     *myptr   = ( short ) rsumval;
  332.     pDst += 2*sizeof( short );
  333. }
  334.     }
  335. }
  337. static void change_endianness(pSam, Samples)
  338. UINT4 *pSam;
  339. unsigned int Samples;
  340. {
  341.   UINT4 *pend = (pSam + Samples);
  343.   /* type UINT4 may not be greater than the assumed biggest type */
  344. #if (SIZEOF_LONG_INT < 4)
  345. error type unsigned long is too small
  346. #endif
  348. #if (SIZEOF_LONG_INT == 4)
  350.   unsigned long *plong = (unsigned long *)pSam;
  352.   for (; plong < pend;) {
  353.     *plong = ((*plong >> 8L) & UINT_C(0x00ff00ff)) |
  354.              ((*plong << 8L) & UINT_C(0xff00ff00));
  355.     plong++;
  356.   }
  357. #else  /* sizeof long unsigned > 4 bytes */
  358. #if (SIZEOF_LONG_INT == 8)
  359. #define INTEGRAL_LONGS (SIZEOF_LONG_INT-1UL)
  360.   register unsigned long *plong;
  361.   unsigned long *pend0 = (unsigned long *) (((unsigned long) pend) & ~ INTEGRAL_LONGS);
  363.   if (((unsigned long) pSam) & INTEGRAL_LONGS) {
  364.     *pSam = ((*pSam >> 8L) & UINT_C(0x00ff00ff)) |
  365.             ((*pSam << 8L) & UINT_C(0xff00ff00));
  366.     pSam++;
  367.   }
  369.   plong = (unsigned long *)pSam;
  371.   for (; plong < pend0;) {
  372.     *plong = ((*plong >> 8L) & ULONG_C(0x00ff00ff00ff00ff)) |
  373.              ((*plong << 8L) & ULONG_C(0xff00ff00ff00ff00));
  374.     plong++;
  375.   }
  377.   if (((unsigned long *) pend) != pend0) {
  378.     UINT4 *pint = (UINT4 *) pend0;
  380.     for (;pint < pend;) {
  381.       *pint = ((*pint >> 8) & UINT_C(0x00ff00ff)) |
  382.               ((*pint << 8) & UINT_C(0xff00ff00));
  383.       pint++;
  384.     }
  385.   }
  386. #else  /* sizeof long unsigned > 4 bytes but not 8 */
  387.   {
  388.     UINT4 *pint = pSam;
  390.     for (;pint < pend;) {
  391.       *pint = ((*pint >> 8) & UINT_C(0x00ff00ff)) |
  392.               ((*pint << 8) & UINT_C(0xff00ff00));
  393.       pint++;
  394.     }
  395.   }
  396. #endif
  397. #endif
  398. }
  400. static void swap_channels(pSam, Samples)
  401. UINT4 *pSam;
  402. unsigned int Samples;
  403. {
  404.   UINT4 *pend = (pSam + Samples);
  406.   /* type UINT4 may not be greater than the assumed biggest type */
  407. #if (SIZEOF_LONG_INT < 4)
  408. error type unsigned long is too small
  409. #endif
  411. #if (SIZEOF_LONG_INT == 4)
  413.   unsigned long *plong = (unsigned long *)pSam;
  415.   for (; plong < pend;) {
  416.     *plong = ((*plong >> 16L) & UINT_C(0x0000ffff)) |
  417.              ((*plong << 16L) & UINT_C(0xffff0000));
  418.     plong++;
  419.   }
  420. #else  /* sizeof long unsigned > 4 bytes */
  421. #if (SIZEOF_LONG_INT == 8)
  422. #define INTEGRAL_LONGS (SIZEOF_LONG_INT-1UL)
  423.   register unsigned long *plong;
  424.   unsigned long *pend0 = (unsigned long *) (((unsigned long) pend) & ~ INTEGRAL_LONGS);
  426.   if (((unsigned long) pSam) & INTEGRAL_LONGS) {
  427.     *pSam = ((*pSam >> 16L) & UINT_C(0x0000ffff)) |
  428.             ((*pSam << 16L) & UINT_C(0xffff0000));
  429.     pSam++;
  430.   }
  432.   plong = (unsigned long *)pSam;
  434.   for (; plong < pend0;) {
  435.     *plong = ((*plong >> 16L) & ULONG_C(0x0000ffff0000ffff)) |
  436.              ((*plong << 16L) & ULONG_C(0xffff0000ffff0000));
  437.     plong++;
  438.   }
  440.   if (((unsigned long *) pend) != pend0) {
  441.     UINT4 *pint = (UINT4 *) pend0;
  443.     for (;pint < pend;) {
  444.       *pint = ((*pint >> 16L) & UINT_C(0x0000ffff)) |
  445.               ((*pint << 16L) & UINT_C(0xffff0000));
  446.       pint++;
  447.     }
  448.   }
  449. #else  /* sizeof long unsigned > 4 bytes but not 8 */
  450.   {
  451.     UINT4 *pint = pSam;
  453.     for (;pint < pend;) {
  454.       *pint = ((*pint >> 16L) & UINT_C(0x0000ffff)) |
  455.               ((*pint << 16L) & UINT_C(0xffff0000));
  456.       pint++;
  457.     }
  458.   }
  459. #endif
  460. #endif
  461. }
  463. #ifdef ECHO_TO_SOUNDCARD
  464. static long ReSampleBuffer __PR((unsigned char *p, unsigned char *newp, long samples));
  465. static long ReSampleBuffer( p, newp, samples)
  466. unsigned char *p;
  467. unsigned char *newp;
  468. long samples;
  469. {
  470. double idx=0;
  471. long    di=0,si=0;
  473. if (global.playback_rate == 100.0) {
  474. memcpy(newp, p, 4* samples);
  475. di = samples;
  476. } else while( si < samples ){
  477. memcpy( newp+(di*4), p+(si*4), 4 );
  478. idx += (double)(global.playback_rate/100.0);
  479. si = (long)idx;
  480. di++;
  481. }
  482. return di;
  483. }
  484. #endif
  486. static int guess_endianess(p, p2, SamplesToDo)
  487. UINT4 *p;
  488. short *p2;
  489. unsigned SamplesToDo;
  490. {
  491.     /* analyse samples */
  492.     int vote_for_little = 0;
  493.     int vote_for_big = 0;
  494.     int total_votes;
  496.     while (((UINT4 *)p2 - p) + (unsigned) 1 < SamplesToDo) {
  497.       unsigned char *p3 = (unsigned char *)p2;
  498. #if MY_LITTLE_ENDIAN == 1
  499.       int diff_lowl = *(p2+0) - *(p2+2);
  500.       int diff_lowr = *(p2+1) - *(p2+3);
  501.       int diff_bigl = ((*(p3  ) << 8) + *(p3+1)) - ((*(p3+4) << 8) + *(p3+5));
  502.       int diff_bigr = ((*(p3+2) << 8) + *(p3+3)) - ((*(p3+6) << 8) + *(p3+7));
  503. #else
  504.       int diff_lowl = ((*(p3+1) << 8) + *(p3  )) - ((*(p3+5) << 8) + *(p3+4));
  505.       int diff_lowr = ((*(p3+3) << 8) + *(p3+2)) - ((*(p3+7) << 8) + *(p3+6));
  506.       int diff_bigl = *(p2+0) - *(p2+2);
  507.       int diff_bigr = *(p2+1) - *(p2+3);
  508. #endif
  510.       if ((abs(diff_lowl) + abs(diff_lowr)) <
  511.   (abs(diff_bigl) + abs(diff_bigr))) {
  512. vote_for_little++;
  513.       } else {
  514. if ((abs(diff_lowl) + abs(diff_lowr)) >
  515.     (abs(diff_bigl) + abs(diff_bigr))) {
  516.   vote_for_big++;
  517. }
  518.       }
  519.       p2 += 2;
  520.    }
  521. #ifdef DEBUG_VOTE_ENDIANESS
  522.    if (global.quiet != 1)
  523.      fprintf(stderr, "votes for little: %4d,  votes for big: %4dn", 
  524. vote_for_little, vote_for_big);
  525. #endif
  526.    total_votes = vote_for_big + vote_for_little;
  527.    if (total_votes < 3
  528.        || abs(vote_for_big - vote_for_little) < total_votes/3) {
  529.      return -1;
  530.    } else {
  531. if (vote_for_big > vote_for_little)
  532. return 1;
  533. else
  534. return 0;
  535.    }
  536. }
  538. int jitterShift = 0; 
  540. unsigned char *synchronize(p, SamplesToDo, TotSamplesDone)
  541. UINT4 *p;
  542. unsigned SamplesToDo;
  543. unsigned TotSamplesDone;
  544. {
  545.   static int jitter = 0;
  546.   char *pSrc;                   /* start of cdrom buffer */
  548.   /* if endianess is unknown, guess endianess based on 
  549.      differences between succesive samples. If endianess
  550.      is correct, the differences are smaller than with the
  551.      opposite byte order.
  552.    */
  553.   if ((*in_lendian) < 0) {
  554.     short *p2 = (short *)p;
  556.     /* skip constant samples */
  557.     while ((((UINT4 *)p2 - p) + (unsigned) 1 < SamplesToDo)
  558.            && *p2 == *(p2+2)) p2++;
  560.     if (((UINT4 *)p2 - p) + (unsigned) 1 < SamplesToDo) {
  561.       switch (guess_endianess(p, p2, SamplesToDo)) {
  562.         case -1: break;
  563.         case  1: (*in_lendian) = 0;
  564. #if 0
  565.          if (global.quiet != 1)
  566.    fprintf(stderr, "big endian detectedn");
  567. #endif
  568. break;
  569.         case  0: (*in_lendian) = 1;
  570. #if 0
  571.          if (global.quiet != 1)
  572.    fprintf(stderr, "little endian detectedn");
  573. #endif
  574. break;
  575.       }
  576.     }
  577.   }
  579.   /* ENDIAN ISSUES:
  580.    * the individual endianess of cdrom/cd-writer, cpu, 
  581.    * sound card and audio output format need a careful treatment.
  582.    *
  583.    * For possible sample processing (rate conversion) we need
  584.    * the samples in cpu byte order. This is the first conversion.
  585.    *
  586.    * After processing it depends on the endianness of the output
  587.    * format, whether a second conversion is needed.
  588.    *
  589.    */
  591.   if (global.need_hostorder && (*in_lendian) != MY_LITTLE_ENDIAN) {
  592.     /* change endianess of delivered samples to native cpu order */
  593.     change_endianness(p, SamplesToDo);
  594.   }
  596.   /* synchronisation code */
  597.   if (TotSamplesDone != 0 && global.overlap != 0 && SamplesToDo > CD_FRAMESAMPLES) {
  599.     pSrc = (char *) sync_buffers((unsigned char *)p);
  600.     if (!pSrc ) {
  601.       return NULL;
  602.     }
  603.     if (pSrc) {
  604.       jitter = ((unsigned char *)pSrc - (((unsigned char *)p) + global.overlap*CD_FRAMESIZE_RAW))/4;
  605.       jitterShift += jitter;
  606.       SamplesToDo -= jitter + global.overlap*CD_FRAMESAMPLES;
  607. #if 0
  608.       fprintf(stderr,
  609.     "Length: pre %d, diff1 %ld, diff2 %ld, min %ldn", SamplesToDo,
  610.    (TotSamplesWanted - TotSamplesDone),
  611.    SamplesNeeded((TotSamplesWanted - TotSamplesDone), undersampling),
  612.    min(SamplesToDo, SamplesNeeded((TotSamplesWanted - TotSamplesDone), undersampling)));
  613. #endif
  614.     }
  615.   } else {
  616.     pSrc = ( char * ) p;
  617.   }
  618.   return (unsigned char *) pSrc;
  619. }
  621. /* convert cdda data to required output format
  622.  * sync code for unreliable cdroms included
  623.  * 
  624.  */
  625. long 
  626. SaveBuffer (p, SamplesToDo, TotSamplesDone)
  627. UINT4 *p;
  628. unsigned long SamplesToDo;
  629. unsigned long *TotSamplesDone;
  630. {
  631.   UINT4 *pSrc;                   /* start of cdrom buffer */
  632.   UINT4 *pSrcStop;               /* end of cdrom buffer */
  634.   /* in case of different endianness between host and output format,
  635.      copy in a seperate buffer and modify the local copy */
  636.   if ( ((!global.need_hostorder && global.need_big_endian == (*in_lendian)) ||
  637.  (global.need_hostorder && global.need_big_endian != MY_BIG_ENDIAN))
  638.       && global.OutSampleSize > 1) {
  639.      static UINT4 *localoutputbuffer;
  640.      if (localoutputbuffer == NULL) {
  641.        localoutputbuffer = (UINT4 *) malloc(global.nsectors*CD_FRAMESIZE_RAW);
  642.        if (localoutputbuffer == NULL) {
  643.          perror("cannot allocate local buffer");
  644.          return 1;
  645.        }
  646.      }
  647.      memcpy(localoutputbuffer, p, SamplesToDo*4);
  648.      p = localoutputbuffer;
  649.   }
  651.   pSrc = p;
  652.   pDst = (unsigned char *) p;
  653.   pStart = ( unsigned char * ) pSrc;
  654.   pSrcStop = pSrc + SamplesToDo;
  656.   /* code for subsampling and output stage */
  658.   if (global.ismono && global.findmono) {
  659.     short *pmm;
  660.     for (pmm = (short *)pStart; (UINT4 *) pmm < pSrcStop; pmm += 2) {
  661.       if (*pmm != *(pmm+1)) {
  662.         global.ismono = 0;
  663.         break;
  664.       }
  665.     }
  666.   }
  667.   /* optimize the case of no conversion */
  668.   if (1 && undersampling == 1 && samples_to_do == 1 &&
  669.        global.channels == 2 && global.OutSampleSize == 2 && Halved == 0) {
  670.     /* output format is the original cdda format ->
  671.      * just forward the buffer 
  672.      */
  673.       
  674.     if ( waitforsignal != 0 && any_signal == 0) {
  675.       int *myptr = (int *)pStart;
  676.       while ((UINT4 *)myptr < pSrcStop && *myptr == 0) myptr++;
  677.       pStart = (unsigned char *) myptr;
  678.       /* scan for first signal */
  679.       if ( (UINT4 *)pStart != pSrcStop ) {
  680. /* first non null amplitude is found in buffer */
  681. any_signal = 1;
  682.       }
  683.     }
  684.     pDst = (unsigned char *) pSrcStop; /* set pDst to end */
  686.     if (global.deemphasize) {
  687.       /* this implements an attenuation treble shelving filter 
  688.          to undo the effect of pre-emphasis. The filter is of
  689.          a recursive first order */
  690.       static short lastin[2] = { 0, 0 };
  691.       static double lastout[2] = { 0.0, 0.0 };
  692.       short *pmm;
  694.       /* Here is the gnuplot file for the frequency response
  695.          of the deemphasis. The error is below +-0.1dB
  697. # first define the ideal filter. We use the tenfold sampling frequency.
  698. T=1./441000.
  699. OmegaU=1./15E-6
  700. OmegaL=15./50.*OmegaU
  701. V0=OmegaL/OmegaU
  702. H0=V0-1.
  703. B=V0*tan(OmegaU*T/2.)
  704. # the coefficients follow
  705. a1=(B - 1.)/(B + 1.)
  706. b0=(1.0 + (1.0 - a1) * H0/2.)
  707. b1=(a1 + (a1 - 1.0) * H0/2.)
  708. # helper variables
  709. D=b1/b0
  710. o=2*pi*T
  711. H2(f)=b0*sqrt((1+2*cos(f*o)*D+D*D)/(1+2*cos(f*o)*a1+a1*a1))
  712. # now approximate the ideal curve with a fitted one for sampling frequency
  713. # of 44100 Hz.
  714. T2=1./44100.
  715. V02=0.3365
  716. OmegaU2=1./19E-6
  717. B2=V02*tan(OmegaU2*T2/2.)
  718. # the coefficients follow
  719. a12=(B2 - 1.)/(B2 + 1.)
  720. b02=(1.0 + (1.0 - a12) * (V02-1.)/2.)
  721. b12=(a12 + (a12 - 1.0) * (V02-1.)/2.)
  722. # helper variables
  723. D2=b12/b02
  724. o2=2*pi*T2
  725. H(f)=b02*sqrt((1+2*cos(f*o2)*D2+D2*D2)/(1+2*cos(f*o2)*a12+a12*a12))
  726. # plot best, real, ideal, level with halved attenuation,
  727. #      level at full attentuation, 10fold magnified error
  728. set logscale x
  729. set grid xtics ytics mxtics mytics
  730. plot [f=1000:20000] [-12:2] 20*log10(H(f)),20*log10(H2(f)),  20*log10(OmegaL/(2*pi*f)), 0.5*20*log10(V0), 20*log10(V0), 200*log10(H(f)/H2(f))
  731. pause -1 "Hit return to continue"
  732.        */
  734. #ifdef TEST
  735. #define V0 0.3365
  736. #define OMEGAG (1./19e-6)
  737. #define T (1./44100.)
  738. #define H0 (V0-1.)
  739. #define B (V0*tan((OMEGAG * T)/2.0))
  740. #define a1 ((B - 1.)/(B + 1.))
  741. #define b0  (1.0 + (1.0 - a1) * H0/2.0)
  742. #define b1  (a1 + (a1 - 1.0) * H0/2.0)
  743. #else
  744. #define a1 -0.62786881719628784282
  745. #define b0  0.45995451989513153057
  746. #define b1  -0.08782333709141937339
  747. #endif
  749.       for (pmm = (short *)pStart; pmm < (short *)pDst;) {
  750.         lastout[0] = *pmm * b0 + lastin[0] * b1 - lastout[0] * a1;
  751.         lastin[0] = *pmm;
  752.         *pmm++ = lastout[0] > 0.0 ? lastout[0] + 0.5 : lastout[0] - 0.5;
  753.         lastout[1] = *pmm * b0 + lastin[1] * b1 - lastout[1] * a1;
  754.         lastin[1] = *pmm;
  755.         *pmm++ = lastout[1] > 0.0 ? lastout[1] + 0.5 : lastout[1] - 0.5;
  756.       }
  757.     }
  759.     if (global.swapchannels == 1) {
  760. swap_channels((UINT4 *)pStart, SamplesToDo);
  761.     }
  763.     if (global.findminmax) {
  764.       short *pmm;
  765.       for (pmm = (short *)pStart; pmm < (short *)pDst; pmm++) {
  766.         if (*pmm < global.minamp[1]) global.minamp[1] = *pmm;
  767.         if (*pmm > global.maxamp[1]) global.maxamp[1] = *pmm;
  768.         pmm++;
  769.         if (*pmm < global.minamp[0]) global.minamp[0] = *pmm;
  770.         if (*pmm > global.maxamp[0]) global.maxamp[0] = *pmm;
  771.       }
  772.     }
  773.   } else {
  775. #define none_missing 0
  776. #define one_missing 1
  777. #define two_missing 2
  778. #define collecting 3
  780.     static int sample_state = collecting;
  781.     static int Toggle_on = 0;
  783.     if (global.channels == 2 && global.swapchannels == 1) {
  784. swap_channels((UINT4 *)pStart, SamplesToDo);
  785.     }
  787.     /* conversion required */
  788.     while ( pSrc < pSrcStop ) {
  789.   
  790. long l,r;
  792. long iSamples_left = (pSrcStop - pSrc) / sizeof(short) / 2;
  793. short *myptr = (short *) pSrc;
  795. /* LSB l, MSB l */
  796. l = *myptr++; /* left channel */
  797. r = *myptr++; /* right channel */
  798. pSrc = (UINT4 *) myptr;
  800. switch (sample_state) {
  801. case two_missing:
  802. two__missing:
  803.     ls2 += l; rs2 += r;
  804.     if (undersampling > 1) {
  805. ls3 += l; rs3 += r;
  806.     }
  807.     sample_state = one_missing;
  808.     break;
  809. case one_missing:
  810.     auxl = l; auxr = r;
  812.     ls3 += l; rs3 += r;
  813.     sample_state = none_missing;
  815.     /* FALLTHROUGH */
  816. none__missing:
  817. case none_missing:
  818.     /* Filtered samples are complete. Now interpolate and scale. */
  820.     if (Halved != 0 && Toggle_on == 0) {
  821.                 lsum = interpolate(lsum, ls2, ls3)/(int) undersampling;
  822.         rsum = interpolate(rsum, rs2, rs3)/(int) undersampling;
  823.             } else {
  824. lsum /= (int) undersampling;
  825. rsum /= (int) undersampling;
  826.             }
  827.     emit_sample(lsum, rsum, global.channels);
  828.     /* reload counter */
  829.     samples_to_do = undersampling - 1;
  830.     lsum = auxl;
  831.     rsum = auxr;
  832.     /* reset sample register */
  833.     auxl = ls2 = ls3 = 0;
  834.     auxr = rs2 = rs3 = 0;
  835.     Toggle_on ^= 1;
  836.     sample_state = collecting;
  837.     break;
  838. case collecting:
  839.     if ( samples_to_do > 0) {
  840. samples_to_do--;
  841. if (Halved != 0 && Toggle_on == 0) {
  842.     /* Divider x.5 : we need data for quadratic interpolation */
  843.     iSamples_left--;
  845.     lsum += l; rsum += r;
  846.     if ( samples_to_do < undersampling - 1) {
  847. ls2 += l; rs2 += r;
  848.     }
  849.     if ( samples_to_do < undersampling - 2) {
  850. ls3 += l; rs3 += r;
  851.     }
  852. } else {
  853.     /* integral divider */
  854.     lsum += l;
  855.     rsum += r;
  856.     iSamples_left--;
  857. }
  858.     } else {
  859.         if (Halved != 0 && Toggle_on == 0) {
  860.     sample_state = two_missing;
  861.     goto two__missing;
  862. } else {
  863.     auxl = l;
  864.     auxr = r;
  865.     sample_state = none_missing;
  866.     goto none__missing;
  867. }
  868.     }
  869.     break;
  870. } /* switch state */
  872.     } /* while */
  874.     /* flush_buffer */
  875.     if ((samples_to_do == 0 && Halved == 0))
  876.     {
  877. if (Halved != 0 && Toggle_on == 0) {
  878.     lsum = interpolate(lsum, ls2, ls3)/(int) undersampling;
  879.     rsum = interpolate(rsum, rs2, rs3)/(int) undersampling;
  880. } else {
  881.     lsum /= (int) undersampling;
  882.     rsum /= (int) undersampling;
  883. }
  884. emit_sample(lsum, rsum, global.channels);
  886. /* reload counter */
  887. samples_to_do = undersampling;
  889. /* reset sample register */
  890. lsum = auxl = ls2 = ls3 = 0;
  891. rsum = auxr = rs2 = rs3 = 0;
  892. Toggle_on ^= 1;
  893. sample_state = collecting;
  894.     }
  896.   } /* if optimize else */
  898.   if ( waitforsignal == 0 ) pStart = (unsigned char *)p;
  899.   else if (any_signal != 0) global.SkippedSamples += ((UINT4 *)pStart - p);
  900.   else global.SkippedSamples += (pSrcStop - p);
  902.   if ( waitforsignal == 0 || any_signal != 0) {
  903.     int retval = 0;
  904.     unsigned outlen;
  906.     assert(pDst >= pStart);
  907.     outlen = (size_t) (pDst - pStart);
  909.     if (outlen <= 0) return 0;
  911. #ifdef ECHO_TO_SOUNDCARD
  913.     /* this assumes the soundcard needs samples in native cpu byte order */
  914.     if (global.echo != 0) {
  915.                static unsigned char *newp;
  916.                unsigned    newlen;
  918.                newlen = (100*(outlen/4))/global.playback_rate;
  919.                newlen = (newlen*4);
  920.                if ( (newp != NULL) || (newp = (unsigned char *) malloc( 2*global.nsectors*CD_FRAMESIZE_RAW+32 )) ) {
  921. newlen = 4*ReSampleBuffer( pStart, newp, outlen/4 );
  922. write_snd_device((char *)newp, newlen);
  923.                }
  924.     }
  925. #endif
  927.     if ( global.no_file != 0 ) {
  928.         *TotSamplesDone += SamplesToDo;
  929.         return 0;
  930.     }
  931.     if ( (!global.need_hostorder && global.need_big_endian == (*in_lendian)) ||
  932.  (global.need_hostorder && global.need_big_endian != MY_BIG_ENDIAN)) {
  933.       if ( global.OutSampleSize > 1) {
  934.         /* change endianness from input sample or native cpu order 
  935.            to required output endianness */
  936.         change_endianness((UINT4 *)pStart, outlen/4);
  937.       }
  938.     }
  939.     if ((unsigned)(retval = write ( global.audio, pStart, outlen )) == outlen) {
  940.         *TotSamplesDone += SamplesToDo;
  941. return 0;
  942.     } else {
  943.         fprintf(stderr, "write(audio, 0x%p, %u) = %dn",pStart,outlen,retval);
  944.         perror("Probably disk space exhausted");
  945.         return 1;
  946.     }
  947.   } else return 0;
  948. }