celpsyn.m

FS1016源代码

    end
    [ codeword( CODELENGTH2+1:CODELENGTH1 ), pointer ] = ...
    unpack( stream, [1,1,1,1], pointer );

    % EXTRACT CODEWORD FROM STREAM ARRAY
    codeword( 1:CODELENGTH2 ) = stream( bitprotect );

    % REPACK EXPANSION BIT (BISNU BIT)
    codeword( 11 ) = 0;

    % DECODE HAMMING ERROR PROTECTION
    [ codeword, twoerror, syndrome ] = ...
    decodham( CODELENGTH1, hmatrix, syndrometable, paritybit, codeword );

    % DISABLE PARITY CHECK
    twoerror = FALSE;

    % ESTIMATE BIT ERROR RATE - RUNNING AVERAGE OF BAD SYNDROMES
    if syndrome ~= 0
        syndrome = 1;
    end
    syndavg = ( 1.0 - (1.0/SYNDRUN) ) * syndavg + ( 1.0 / SYNDRUN ) * syndrome;

    % REPACK ERROR CORRECTED, PROTECTED BITS
    stream( bitprotect ) = codeword( 1:CODELENGTH2 );

    % FRAME REPEAT IF TWO ERRORS HAVE BEEN DETECTED IN THE CODEWORD
    % THIS FEATURE IS DISABLED FOR TRUE FS1016 SIMULATION, WHICH CAN ONLY
    % DETECT AND CORRECT SINGLE BIT ERRORS GIVEN THE HAMMING(11,15)
    % PROTECTION SCHEME. THE ADDITIONAL PARITYBIT VARIABLE CAN BE USED
    % TO DETECT 2 ERRORS, HOWEVER IT IS OUTSIDE OF THE FS1016 DEFINED
    % BITSTREAM, SO IT HAS BEEN DISABLED BY DEFAULT HERE.
    % SEE FALSE CONSTANT FOR TWOERROR, ABOVE.
    if twoerror == TRUE
        fprintf( 'celpexec: two errors have occured in frame %d\n', FrameCnt );
    end
end

% DECODE CELP SYNTHESIS PARAMETERS FROM THE BIT STREAM, INCLUDING
% LSPs, CODEBOOK INDICIES, AND CODEBOOK GAINS

% UNPACK LSPS FROM DATA STREAM AND DECODE
pointer = 0;
[ findex, pointer ] = unpack( stream, sbits, pointer );
newfreq = lspdecod( findex, no );

% INTERPOLATE LSPS FOR NN SUBFRAMES
lsp = intsynth( newfreq, nn, no, twoerror, syndavg );

% DECODE CODEBOOK AND PITCH PARAMETERS TO SET UP FOR SYNTHESIS
bitpointer = pointer;
[ taus, bitpointer ] = dcodtau( pbits(1), pbits(2), bitsum1, bitsum2, ...
                                bitpointer, nn, stream, pddecode, pdtabi );
[ pgs, bitpointer ] = dcodpg( pbits(3), bitsum1, bitsum2, bitpointer, ...
                              nn, stream );
[ cbi, bitpointer ] = dcodcbi( cbbits, bitsum1, bitsum2, bitpointer, ...
                               nn, stream );
[ cbg, bitpointer ] = dcodcbg( cbgbits, bitsum1, bitsum2, bitpointer, ...
                               nn, stream );

% ADJUST SUBFRAME COUNTER FOR ANALYSIS-SYNTHESIS SIMULATIONS BECAUSE
% NSEG HAS BEEN RUN UP BY NN DURING ANALYSIS
if SimType == ANALYSIS
    nseg = nseg - nn;
end

% SYNTHESIZE EACH SUBFRAME
for subframe = 1:nn

    % UPDATE SUBFRAME COUNTER AND VECTOR INDICIES
    nseg = nseg + 1;
    vl = ((subframe-1)*l)+1; vh = vl+l-1;

    % GET STOCHASTIC CODEBOOK INDEX AND UNSMOOTHED GAIN
    cbindex = cbi(subframe);
    decodedgain = cbg(subframe);

    % RUN STOCHASTIC GAIN SMOOTHING IF BIT PROTECTION IS ENABLED
    if protect == TRUE
        decodedgain = smcbg( decodedgain, twoerror, syndavg, cbg, subframe );
    end

    % GENERATE STOCHASTIC EXCITATION VECTOR
    vdecoded(vl:vh) = vdecode( decodedgain, l, cbindex );

    % RUN PITCH LAG SMOOTHING IF BIT PROTECTION IS ENABLED
    if protect == TRUE
        taus(subframe) = smt( taus(subframe), twoerror, syndavg, taus(3), subframe );
    end
    bb(1) = taus(subframe);
    bb(3) = pgs(subframe);

    % RUN PITCH GAIN SMOOTHING IF BIT PROTECTION IS ENABLED
    if protect == TRUE
        bb(3) = smpg( bb(3), twoerror, syndavg, pgs, subframe );
    end

    % GENERATE PITCH EXCITATION VECTOR AND COMBINE WITH STOCHASTIC EXCITATION
    % TO PRODUCE COMPOSITE LPC EXCITATION VECTOR
    [ vdecoded(vl:vh), dps ] = pitchvq( vdecoded(vl:vh), l, dps, idb, bb, 'long' );
    guiExcit(vl:vh) = vdecoded(vl:vh);

    % CONVERT LSPs TO PCs, THEN RUN LPC SYNTHESIS, EXCITED BY VDECODED
    fci = lsptopc( lsp(subframe,:), no );
    [ dss, vdecoded(vl:vh) ] = polefilt( fci, no, dss, vdecoded(vl:vh), l );

    % SCALE AND CLAMP NON-POSTFILTERED DATA TO 16-BIT INTEGER RANGE
    vdecoded(vl:vh) = vdecoded(vl:vh) * descale;
    npf(vl:vh) = min( [ (vdecoded(vl:vh))'; maxv(vl:vh) ] )';
    npf(vl:vh) = round( max( [ (npf(vl:vh))'; minv(vl:vh) ] )' );

    % WRITE NON-POSTFILTERED OUTPUT TO SPEECH FILE
    [ junkbuf, status ] = diskio( WRITE, fpnpf, npf(vl:vh), l );
    if SimType == ANALYSIS

        % COMPUTE SEGMENTAL SNR AND UPDATE SNR AVERAGING ACCUMULATORS FOR
        % THE CURRENT SUBFRAME
        [ sumsnr, framesnr, snrflag, SnrNPF ] = segsnr( ssub(vl:vh), npf(vl:vh), ...
                                                sumsnr, framesnr );

        % COMPUTE DISTANCES/DISTORTIONS (LOG SPECTRAL ERROR, ETC.)
        if ( snrflag == TRUE )
            [ dm, sumdm, framedm ] = disto( ssub(vl:vh), npf(vl:vh), hamws, ...
                                            l, no, sumdm, framedm );
            guidm = dm;
            guisdm = sumdm;
            guiFDM = framedm;
            avgSnrNPF = 10*log10(sumsnr/framesnr);
        end
    end

    % DO POSTFILTERING
    [ vdecoded(vl:vh), ip, op, dp1, dp2, dp3 ] = ...
    postfilt( vdecoded(vl:vh), l, ALPHA, BETA, ip, op, dp1, dp2, dp3, fci, no );

    % TEST FOR CLIPPING IN OUTPUT SPEECH
    % IF CLIPPING IS DETECTED, SCALE SPEECH DOWN UNTIL CLIPPING IS ELIMINATED
    while clip( vdecoded( vl:vh ) ) == TRUE
        vdecoded( vl:vh ) = 0.05 * vdecoded( vl:vh );
        fprintf( 'celpsyn: Clipping detected @ frame %d\n', FrameCnt );
    end

    % CLAMP POSTFILTERED SPEECH TO 16-BIT INTEGER RANGE
    pf(vl:vh) = min( [ (vdecoded(vl:vh))'; maxv(vl:vh) ] )';
    pf(vl:vh) = round( max( [ (pf(vl:vh))'; minv(vl:vh) ] )' );

    % WRITE POSTFILTERED OUTPUT TO SPEECH FILE
    [ junkbuf, status ] = diskio( WRITE, fpo, pf(vl:vh), l );

    % HIGH PASS FILTER OUTPUT SPEECH
    [ dhpf1o, vdecoded(vl:vh) ] = zerofilt( ahpfo, 2, dhpf1o, vdecoded(vl:vh), l );
    [ dhpf2o, vdecoded(vl:vh) ] = polefilt( bhpfo, 2, dhpf2o, vdecoded(vl:vh), l );

    % CLAMP HIGHPASS FILTERED SPEECH TO 16-BIT INTEGER RANGE
    hppf(vl:vh) = min( [ (vdecoded(vl:vh))'; maxv(vl:vh) ] )';
    hppf(vl:vh) = round( max( [ (hppf(vl:vh))'; minv(vl:vh) ] )' );

    % WRITE HIGHPASS FILTERED OUTPUT TO SPEECH FILE
    [ junkbuf, status ] = diskio( WRITE, fphpf, hppf(vl:vh), l );

    % UPDATE AVERAGE SNR ACCUMULATORS
    if SimType == ANALYSIS

        % COMPUTE SEGMENTAL SNR AND UPDATE SNR AVERAGING ACCUMULATORS
        [ sumsnrp, framesnrp, snrflagp, dummy1 ] = segsnr( ssub(vl:vh), pf(vl:vh), ...
                                                   sumsnrp, framesnrp );
        [ sumsnrh, framesnrh, snrflagh, dummy1 ] = segsnr( ssub(vl:vh), hppf(vl:vh), ...
                                                   sumsnrh, framesnrh );

        % COMPUTE LOG SNRs
        if snrflagp == TRUE
            avgSnrPF = 10*log10(sumsnrp/framesnrp);
        end
        if snrflagh == TRUE
            avgSnrHPF = 10*log10(sumsnrh/framesnrh);
        end
    end
end

if SimType == ANALYSIS

    % COMPUTE OVERALL FRAME SNRs (FOUR SUBFRAMES)
    [ dummy1, dummy2, dummy3, SnrNPF ] = segsnr( ssub, npf, 0, 0 );
    [ dummy1, dummy2, dummy3, SnrPF ] = segsnr( ssub, pf, 0, 0 );
    [ dummy1, dummy2, dummy3, SnrHPF ] = segsnr( ssub, hppf, 0, 0 );
end

% GENERATE GRAPHICAL OUTPUTS; PASS VALUES VIA GLOBALS
if guiState == 1
    guiRCs = fci;
    guiSin = ssub;
    guiSout = [ npf, pf, hppf ];
    gui;

    % MUST BREAK OUT OF WHILE SINCE GUI CALLBACK DRIVES SIMULATION
    % WHILE LOOP IS USED ONLY FOR STATUS MODE
    break;
end