abx.c

音频编码

    sx = k->n > 1  ?  sqrt ( (k->x2 - k->x*k->x/k->n) / (k->n - 1) )  :  0.l;
    sy = k->n > 1  ?  sqrt ( (k->y2 - k->y*k->y/k->n) / (k->n - 1) )  :  0.l;
    x  = k->n > 0  ?  k->x/k->n  :  0.l;
    y  = k->n > 0  ?  k->y/k->n  :  0.l;
    
    b  = sx != 0   ?  sy/sx * sgn(r)  :  0.l;
    if (verbose)
        fprintf ( stderr, "r=%Lf  sx=%Lf  sy=%Lf  x=%Lf  y=%Lf  b=%Lf\n", r, sx, sy, x, y, b );
    return b;
}


int  feed ( int fd, const stereo_t* p, int len )
{
    write ( fd, p, sizeof(stereo_t) * len );
    return len;
}


short  round ( double f )
{
    long  x = (long) floor ( f + 0.5 );
    return x == (short)x  ?  (short)x  :  (short) ((x >> 31) ^ 0x7FFF);
}


int  feed2 ( int fd, const stereo_t* p1, const stereo_t* p2, int len )
{
    stereo_t  tmp [30000];   /* An arbitrary size, hope that no overruns occure */
    int       i;
    
    if (len > sizeof(tmp)/sizeof(*tmp))
        len = sizeof(tmp)/sizeof(*tmp);
    for ( i = 0; i < len; i++ ) {
        double f = cos ( M_PI/2*i/len );
        f *= f;
        tmp [i] [0] = round ( p1 [i] [0] * f + p2 [i] [0] * (1. - f) );
        tmp [i] [1] = round ( p1 [i] [1] * f + p2 [i] [1] * (1. - f) );
    }

    write ( fd, tmp, sizeof(stereo_t) * len );
    return len;
}


int feedfac ( int fd, const stereo_t* p1, const stereo_t* p2, int len, double fac1, double fac2 )
{
    stereo_t  tmp [30000];   /* An arbitrary size, hope that no overruns occure */
    int       i;
    
    if (len > sizeof(tmp)/sizeof(*tmp))
        len = sizeof(tmp)/sizeof(*tmp);
    for ( i = 0; i < len; i++ ) {
        tmp [i] [0] = round ( p1 [i] [0] * fac1 + p2 [i] [0] * fac2 );
        tmp [i] [1] = round ( p1 [i] [1] * fac1 + p2 [i] [1] * fac2 );
    }

    write ( fd, tmp, sizeof(stereo_t) * len );
    return len;
}


void setup ( int fdd, int samples, long freq )
{
    int status, org, arg;

    // Nach vorn verschoben
    if ( -1 == (status = ioctl (fdd, SOUND_PCM_SYNC, 0)) )
        perror ("SOUND_PCM_SYNC ioctl failed");

    org = arg = 2;
    if ( -1 == (status = ioctl (fdd, SOUND_PCM_WRITE_CHANNELS, &arg)) )
        perror ("SOUND_PCM_WRITE_CHANNELS ioctl failed");
    if (arg != org)
        perror ("unable to set number of channels");
    fprintf (stderr, "%1u*", arg);

    org = arg = 16;
    if ( -1 == (status = ioctl (fdd, SOUND_PCM_WRITE_BITS, &arg)) )
        perror ("SOUND_PCM_WRITE_BITS ioctl failed");
    if (arg != org)
        perror ("unable to set sample size");
    fprintf (stderr, "%2u bit ", arg);

    org = arg = AFMT_S16_LE;
    if ( -1 == ioctl (fdd, SNDCTL_DSP_SETFMT, &arg) )
        perror ("SNDCTL_DSP_SETFMT ioctl failed");
    if ((arg & org) == 0)
        perror ("unable to set data format");

    org = arg = freq;
    if ( -1 == (status = ioctl (fdd, SOUND_PCM_WRITE_RATE, &arg)) )
        perror ("SOUND_PCM_WRITE_WRITE ioctl failed");
    fprintf (stderr, "%5u Hz*%.3f sec\n", arg, (double)samples/arg );

    org = arg = DMA_SAMPLES;
    if ( -1 == (status = ioctl (fdd, SNDCTL_DSP_SETFRAGMENT, &arg)) )
        perror ("SNDCTL_DSP_SETFRAGMENT ioctl failed");
}


void Message ( const char* s, size_t index, long freq, size_t start, size_t stop )
{
    unsigned long  norm_index = 100lu * index / freq;
    unsigned long  norm_start = 100lu * start / freq;
    unsigned long  norm_stop  = 100lu * stop  / freq;

    fprintf ( stderr, "\rListening %s  %2lu:%02lu.%02lu  (%1lu:%02lu.%02lu...%1lu:%02lu.%02lu)%*.*s\rListening %s",
              s,
              norm_index / 6000, norm_index / 100 % 60, norm_index % 100,
              norm_start / 6000, norm_start / 100 % 60, norm_start % 100,
              norm_stop  / 6000, norm_stop  / 100 % 60, norm_stop  % 100,
              36 - (int)strlen(s), 36 - (int)strlen(s), "",
              s );

    fflush  ( stderr );
}


size_t  calc_true_index ( size_t index, size_t start, size_t stop )
{
    if ( start >= stop )
        return start;
    while ( index - start < DMA_SAMPLES )
        index += stop - start;
    return index - DMA_SAMPLES;
}


void testing ( const stereo_t* A, const stereo_t* B, size_t len, long freq )
{
    int     c;
    int     fd    = open ( "/dev/dsp", O_WRONLY );
    int     rnd   = random_number ();   /* Auswahl von X */
    int     state = 0;                  /* derzeitiger F黷tungsmodus */
    float   fac1  = 0.5;
    float   fac2  = 0.5;
    size_t  start = 0;
    size_t  stop  = len;
    size_t  index = start;                  /* derzeitiger Offset auf den Audiostr鰉en */
    char    message [80] = "A  ";

    setup ( fd, len, freq );

    while ( 1 ) {
        c = sel ();
        if ( c == 27 )
            c = sel () + 0x100;

        switch ( c ) {
        case 'A' :
        case 'a' :
            strcpy ( message, "A  " );
            if ( state != 0 )
                state = 2;
            break;

        case 0x100+'0' :
        case '0' :
        case 'B' :
        case 'b' :
            strcpy ( message, "  B" );
            if ( state != 1 )
                state = 3;
            break;

        case 'X' :
        case 'x' :
            strcpy ( message, " X " );
            if ( state != rnd )
                state = rnd + 2;
            break;

        case 'm' :
            state = 8;
            break;

        case 'M' :
            state = (state & 1) + 4;
            break;
            
        case 'x'&0x1F:
            state = (state & 1) + 6;
            break;

        case ' ':
            start = 0;
            stop  = len;
            break;

        case 'o'  :
	    start = calc_true_index ( index, start, stop);
            break;
        case 'p'  :
	    stop  = calc_true_index ( index, start, stop);
            break;
        case 'h'  :
            if ( start > freq/100 )
                start -= freq/100;
            else
                start = 0;
            index = start;
            continue;
        case 'j'  :
            if ( start < stop-freq/100 )
                start += freq/100;
            else
                start = stop;
            index = start;
            continue;
        case 'k'  :
            if ( stop > start+freq/100 )
                stop -= freq/100;
            else
                stop = start;
            continue;
        case 'l'  :
            if ( stop < len-freq/100 )
                stop += freq/100;
            else
                stop = len;
            continue;
        case '\n':
            index = start;
            continue;

        case 'D'+0x100:
            strcpy ( message, "Difference (+40 dB)" );
            state = 9;
            fac1  = -100.;
            fac2  = +100.;
            break;

        case 'd'+0x100:
            strcpy ( message, "Difference (+30 dB)" );
            state = 9;
            fac1  = -32.;
            fac2  = +32.;
            break;

        case 'D' & 0x1F :
            strcpy ( message, "Difference (+20 dB)" );
            state = 9;
            fac1  = -10.;
            fac2  = +10.;
            break;

        case 'D' :
            strcpy ( message, "Difference (+10 dB)" );
            state = 9;
            fac1  = -3.;
            fac2  = +3.;
            break;

        case 'd' :
            strcpy ( message, "Difference (  0 dB)" );
            state = 9;
            fac1  = -1.;
            fac2  = +1.;
            break;

        case 0x100+'1' :
        case 0x100+'2' :
        case 0x100+'3' :
        case 0x100+'4' :
        case 0x100+'5' :
        case 0x100+'6' :
        case 0x100+'7' :
        case 0x100+'8' :
        case 0x100+'9' :
            sprintf ( message, "  B (Errors -%c dB)", (char)c );
            state = 9;
            fac2  = pow (10., -0.05*(c-0x100-'0') );
            fac1  = 1. - fac2;
            break;

        case '1' :
        case '2' :
        case '3' :
        case '4' :
        case '5' :
        case '6' :
        case '7' :
        case '8' :
        case '9' :
            sprintf ( message, "  B (Errors +%c dB)", c );
            state = 9;
            fac2  = pow (10., 0.05*(c-'0') );
            fac1  = 1. - fac2;
            break;

        case 'A' & 0x1F:
            fprintf (stderr, "   Vote for X:=A" );
            eval ( rnd == 0 );
            rnd   = random_number ();
            if ( state == 6  &&  state == 7 )
                state = 6 + rnd;
            else if ( state != rnd )
                state = rnd + 2;
            strcpy ( message," X " );
            break;

        case 'B' & 0x1F:
            fprintf (stderr, "   Vote for X:=B" );
            eval ( rnd == 1 );
            rnd   = random_number ();
            if ( state == 6  &&  state == 7 )
                state = 6 + rnd;
            else if ( state != rnd )
                state = rnd + 2;
            strcpy ( message," X " );
            break;

        case -1:
            break;

        default:
            fprintf (stderr, "\a" );
            break;

        case 'Q':
        case 'q':
            fprintf ( stderr, "\n%-79.79s\r", "Quit program" );
            close (fd);
            fprintf ( stderr, "\n\n");
            return;
        }

        switch (state) {
        case 0: /* A */
            if ( index + BF >= stop )
                index += feed (fd, A+index, stop-index );
            else
                index += feed (fd, A+index, BF );
            break;

        case 1: /* B */
            if ( index + BF >= stop )
                index += feed (fd, B+index, stop-index );
            else
                index += feed (fd, B+index, BF );
            break;

        case 2: /* B => A */
            if ( index + BF >= stop )
                index += feed2 (fd, B+index, A+index, stop-index );
            else
                index += feed2 (fd, B+index, A+index, BF );
            state = 0;
            break;

        case 3: /* A => B */
            if ( index + BF >= stop )
                index += feed2 (fd, A+index, B+index, stop-index );
            else
                index += feed2 (fd, A+index, B+index, BF );
            state = 1;
            break;
            
        case 4: /* A */
            strcpy ( message, "A  " );
            if ( index + BF >= stop )
                index += feed (fd, A+index, stop-index ),
                state++;
            else
                index += feed (fd, A+index, BF );
            break;

        case 5: /* B */
            strcpy ( message, "  B" );
            if ( index + BF >= stop )
                index += feed (fd, B+index, stop-index ),
                state--;
            else
                index += feed (fd, B+index, BF );
            break;

        case 6: /* X */
            strcpy ( message, " X " );
            if ( index + BF >= stop )
                index += feed (fd, (rnd ? B : A)+index, stop-index ),
                state++;
            else
                index += feed (fd, (rnd ? B : A)+index, BF );
            break;

        case 7: /* !X */
            strcpy ( message, "!X " );
            if ( index + BF >= stop )
                index += feed (fd, (rnd ? A : B)+index, stop-index ),
                state--;
            else
                index += feed (fd, (rnd ? A : B)+index, BF );
            break;

        case 8:
            if ( index + BF/2 >= stop )
                index += feed2 (fd, A+index, B+index, stop-index );
            else
                index += feed2 (fd, A+index, B+index, BF/2 );
            Message ( "  B", index, freq, start, stop );
            if ( index + BF >= stop )
                index += feed (fd, B+index, stop-index );
            else
                index += feed (fd, B+index, BF );
            if ( index + BF/2 >= stop )
                index += feed2 (fd, B+index, A+index, stop-index );
            else
                index += feed2 (fd, B+index, A+index, BF/2 );
            Message ( "A  ", index, freq, start, stop );
            if ( index + BF >= stop )
                index += feed (fd, A+index, stop-index );
            else
                index += feed (fd, A+index, BF );
            break;

        case 9: /* Liko */
            if ( index + BF >= stop )
                index += feedfac (fd, A+index, B+index, stop-index, fac1, fac2 );
            else
                index += feedfac (fd, A+index, B+index, BF        , fac1, fac2 );
            break;
            
        default:
            assert (0);
        }

        if (index >= stop)
            index = start;
        Message ( message, calc_true_index ( index, start, stop), freq, start, stop );
    }
}


int  has_ext ( const char* name, const char* ext )