if ~exist('dvbs2xLDPCParityMatrices.mat','file')
    if ~exist('s2xLDPCParityMatrices.zip','file')
        url = 'https://ssd.mathworks.com/supportfiles/spc/satcom/DVB/s2xLDPCParityMatrices.zip';
        websave('s2xLDPCParityMatrices.zip',url);
        unzip('s2xLDPCParityMatrices.zip');
    end
    addpath('s2xLDPCParityMatrices');
end

cfgDVBS2X.StreamFormat = "TS";
cfgDVBS2X.PLSDecimalCode = 191;                   % 64APSK 7/9 with pilots
cfgDVBS2X.DFL = 50128;
cfgDVBS2X.ScalingMethod = "Unit average power";
cfgDVBS2X.RolloffFactor = 0.35;
cfgDVBS2X.SamplesPerSymbol = 2

simParams.sps = cfgDVBS2X.SamplesPerSymbol;              % Samples per symbol
simParams.numFrames = 30;                                % Number of frames to be processed
simParams.chanBW = 36e6;                                 % Channel bandwidth in Hertz
simParams.cfo = 2e6;                                     % Carrier frequency offset in Hertz
simParams.sco = 2;                                       % Sampling clock offset in parts per million
simParams.phNoiseLevel = "Low";           % Phase noise level provided as 'Low', 'Medium', or 'High'
simParams. EsNodB = 25;                                   % Energy per symbol to noise ratio in decibels

[data,txOut,rxIn,phyConfig,rxParams] = HelperDVBS2XRxInputGenerate(cfgDVBS2X,simParams);
disp(phyConfig)

% Received signal constellation plot
rxConst = comm.ConstellationDiagram('Title','Received data', ...
    'XLimits',[-1 1],'YLimits',[-1 1], ...
    'ShowReferenceConstellation',false, ...
    'SamplesPerSymbol',simParams.sps);
rxConst(rxIn(1:length(txOut)))

% Transmitted and received signal spectrum visualization
Rsymb = simParams.chanBW/(1 + cfgDVBS2X.RolloffFactor);
Fsamp = Rsymb*simParams.sps;
specAn = dsp.SpectrumAnalyzer('SampleRate',Fsamp, ...
    'ChannelNames',{'Transmitted waveform','Received waveform'}, ...
    'ShowLegend',true);
specAn([txOut,rxIn(1:length(txOut))]);

rxParams.carrSyncLoopBW = 1e-2*0.023;        % Coarse frequency estimator loop bandwidth normalized by symbol rate
rxParams.symbSyncLoopBW = 8e-3;              % Symbol timing synchronizer loop bandwidth normalized by symbol rate
rxParams.symbSyncLock  = 8;                  % Number of frames required for symbol timing error convergence
rxParams.frameSyncLock = 1;                  % Number of frames required for frame synchronization
rxParams.coarseFreqLock = 5;                 % Number of frames required for coarse frequency acquisition
rxParams.fineFreqLock = 4;                   % Number of frames required for fine frequency estimation

% Total frames taken for symbol timing and coarse frequency lock to happen
rxParams.initialTimeFreqSync = rxParams.symbSyncLock + rxParams.frameSyncLock + rxParams.coarseFreqLock;
% Total frames used for overall synchronization
rxParams.totalSyncFrames = rxParams.initialTimeFreqSync + rxParams.fineFreqLock;

% Create time frequency synchronization System object by using
% HelperDVBS2TimeFreqSynchronizer helper object
timeFreqSync = HelperDVBS2TimeFreqSynchronizer( ...
    'CarrSyncLoopBW',rxParams.carrSyncLoopBW, ...
    'SymbSyncLoopBW',rxParams.symbSyncLoopBW, ...
    'SamplesPerSymbol',simParams.sps, ...
    'DataFrameSize',rxParams.xFecFrameSize, ...
    'SymbSyncTransitFrames',rxParams.symbSyncLock, ...
    'FrameSyncAveragingFrames',rxParams.frameSyncLock);

% Initialize error computing parameters
[numFramesLost,pktsErr,bitsErr,pktsRec] = deal(0);

% Initialize data indexing variables
stIdx = 0;
dataSize = rxParams.inputFrameSize;
plFrameSize = rxParams.plFrameSize;
dataStInd = rxParams.totalSyncFrames + 1;
isLastFrame = false;
symSyncOutLen = zeros(rxParams.initialTimeFreqSync,1);

while stIdx < length(rxIn)

    % Use one DVB-S2X PL frame for each iteration.
    endIdx = stIdx + rxParams.plFrameSize*simParams.sps;

    % In the last iteration, all the remaining samples in the received
    % waveform are considered.
    isLastFrame = endIdx > length(rxIn);
    endIdx(isLastFrame) = length(rxIn);
    rxData = rxIn(stIdx+1:endIdx);

    % After coarse frequency offset loop is converged, the FLL works with a reduced loop bandwidth.
    if rxParams.frameCount < rxParams.initialTimeFreqSync
        coarseFreqLock = false;
    else
        coarseFreqLock = true;
    end

    % Retrieve the last frame samples.
    if isLastFrame
        resSymb = plFrameSize - length(rxParams.cfBuffer);
        resSampCnt = resSymb*rxParams.sps - length(rxData);
        if resSampCnt >= 0                           % Inadequate number of samples to fill last frame
            syncIn = [rxData; zeros(resSampCnt, 1)];
        else                                         % Excess samples are available to fill last frame
            syncIn = rxData(1:resSymb*rxParams.sps);
        end
    else
        syncIn = rxData;
    end

    % Apply matched filtering, symbol timing synchronization, frame
    % synchronization, and coarse frequency offset compensation.
    [coarseFreqSyncOut,syncIndex,phEst] = timeFreqSync(syncIn,coarseFreqLock);
    if rxParams.frameCount <= rxParams.initialTimeFreqSync
        symSyncOutLen(rxParams.frameCount) = length(coarseFreqSyncOut);
        if any(abs(diff(symSyncOutLen(1:rxParams.frameCount))) > 5)
            error('Symbol timing synchronization failed. The loop will not converge. No frame will be recovered. Update the symbSyncLoopBW parameter according to the EsNo setting for proper loop convergence.');
        end
    end

    rxParams.syncIndex = syncIndex;

    % The PL frame start index lies somewhere in the middle of the chunk being processed.
    % From fine frequency estimation onwards, the processing happens as a PL frame.
    % A buffer is used to store symbols required to fill one PL frame.
    if isLastFrame
        fineFreqIn = [rxParams.cfBuffer; coarseFreqSyncOut];
    else
        fineFreqIn = [rxParams.cfBuffer; coarseFreqSyncOut(1:rxParams.syncIndex-1)];
    end

    % Estimate the fine frequency error by using the HelperDVBS2FineFreqEst
    % helper function.
    % Add 1 to the conditional check because the buffer used to get one PL frame introduces a delay of one to the loop
    % count.
    if (rxParams.frameCount > rxParams.initialTimeFreqSync + 1) && ...
            (rxParams.frameCount <= rxParams.totalSyncFrames + 1)
        rxParams.fineFreqCorrVal = HelperDVBS2FineFreqEst( ...
            fineFreqIn(rxParams.pilotInd),rxParams.numPilotBlks, ...
            rxParams.refPilots,rxParams.fineFreqCorrVal);
    end
    if rxParams.frameCount >= rxParams.totalSyncFrames + 1
        fineFreqLock = true;
    else
        fineFreqLock = false;
    end


    if fineFreqLock
        % Normalize the frequency estimate by the input symbol rate
        % freqEst = angle(R)/(pi*(N+1)) where N (18) is the number of elements
        % used to compute the mean of auto correlation (R) in
        % HelperDVBS2FineFreqEst.
        freqEst = angle(rxParams.fineFreqCorrVal)/(pi*(19));

        % Generate the symbol indices using frameCount and plFrameSize.
        % Subtract 2 from the rxParams.frameCount because the buffer used to get one
        % PL frame introduces a delay of one to the count.
        phErr = exp(-1j*2*pi*freqEst*((rxParams.frameCount-2)*plFrameSize:(rxParams.frameCount-1)*plFrameSize-1));
        fineFreqOut = fineFreqIn.*phErr(:);

        % Estimate the phase error estimation by using the HelperDVBS2PhaseEst
        % helper function.
        [phEstRes,rxParams.prevPhaseEst] = HelperDVBS2PhaseEst( ...
            fineFreqOut(rxParams.pilotInd),rxParams.refPilots,rxParams.prevPhaseEst);

        % Compensate for the residual frequency and phase offset by using
        % the
        % HelperDVBS2PhaseCompensate helper function.
        % Use two frames for initial phase error estimation. Starting with the
        % second frame, use the phase error estimates from the previous frame and
        % the current frame in compensation.
        % Add 3 to the frame count comparison to account for delays: One
        % frame due to rxParams.cfBuffer delay and two frames used for phase
        % error estimate.
        if rxParams.frameCount >= rxParams.totalSyncFrames + 3
            phaseCompOut = HelperDVBS2PhaseCompensate(rxParams.ffBuffer, ...
                rxParams.pilotEst,phEstRes(2),rxParams.pilotInd);
        end

        rxParams.ffBuffer = fineFreqOut;
        rxParams.pilotEst = phEstRes;

        % The phase compensation on the data portion is performed by
        % interpolating the phase estimates computed on consecutive pilot
        % blocks. The second phase estimate is not available for the data
        % portion after the last pilot block in the last frame. Therefore,
        % the slope of phase estimates computed on all pilot blocks in the
        % last frame is extrapolated and used to compensate for the phase
        % error on the final data portion.
        if isLastFrame
            pilotBlkLen = 36;    % Symbols
            pilotBlkFreq = 1476; % Symbols
            avgSlope = mean(diff(phEstRes(2:end)));
            chunkLen = rxParams.plFrameSize - rxParams.pilotInd(end) + ...
                rxParams.pilotInd(pilotBlkLen);
            estEndPh = phEstRes(end) + avgSlope*chunkLen/pilotBlkFreq;
            phaseCompOut1 = HelperDVBS2PhaseCompensate(rxParams.ffBuffer, ...
                rxParams.pilotEst,estEndPh,rxParams.pilotInd);
        end
    end

    % Recover the input bit stream.
    if rxParams.frameCount >= rxParams.totalSyncFrames + 3
        isValid = true;
        if isLastFrame
            syncOut = [phaseCompOut;phaseCompOut1];
        else
            syncOut = phaseCompOut;
        end
    else
        isValid = false;
        syncOut = [];
    end

    % Update the buffers and counters.
    rxParams.cfBuffer = coarseFreqSyncOut(rxParams.syncIndex:end);
    rxParams.syncIndex = syncIndex;
    rxParams.frameCount = rxParams.frameCount + 1;

    if isValid  % Data valid signal

        % Decode the PL header by using the HelperDVBS2XPLHeaderRecover helper
        % function. Start of frame (SOF) is 26 symbols which are discarded
        % before header decoding. They are only required for frame
        % synchronization.
        rxPLSCode = syncOut(1:90); % First 90 symbols of frame is PL header
        [plsDecCode, phyParams] = HelperDVBS2XPLHeaderRecover(rxPLSCode,rxParams.s2xStatus);
        % Validate the decoded PL header.
        if plsDecCode ~= cfgDVBS2X.PLSDecimalCode
            fprintf('%s\n','PL header decoding failed')
        else % Demodulation and decoding
            for frameCnt = 1:length(syncOut)/rxParams.plFrameSize
                rxFrame = syncOut((frameCnt-1)*rxParams.plFrameSize+1:frameCnt*rxParams.plFrameSize);
                % Estimate noise variance by using
                % HelperDVBS2NoiseVarEstimate helper function.
                nVar = HelperDVBS2NoiseVarEstimate(rxFrame,rxParams.pilotInd,rxParams.refPilots,rxParams.normFlag);
                % The data begins at symbol 91 (after the header symbols).
                rxDataFrame = rxFrame(91:end);
                % Recover the BB frame by using HelperDVBS2XBBFrameRecover
                % helper function.
                rxBBFrame = HelperDVBS2XBBFrameRecover(rxDataFrame,phyParams,rxParams.plScramblingIndex, ...
                    rxParams.numPilotBlks,nVar,false);
                % Recover the input bit stream by using
                % HelperDVBS2StreamRecover helper function.
                if strcmpi(cfgDVBS2X.StreamFormat,'GS') && ~rxParams.UPL
                    [decBits,isFrameLost] = HelperDVBS2StreamRecover(rxBBFrame);
                    if ~isFrameLost && length(decBits) ~= dataSize
                        isFrameLost = true;
                    end
                else
                    [decBits,isFrameLost,pktCRC] = HelperDVBS2StreamRecover(rxBBFrame);
                    if ~isFrameLost && length(decBits) ~= dataSize
                        isFrameLost = true;
                        pktCRC = zeros(0,1,'logical');
                    end
                    % Compute the packet error rate for TS or GS packetized
                    % mode.
                    pktsErr = pktsErr + numel(pktCRC) - sum(pktCRC);
                    pktsRec = pktsRec + numel(pktCRC);
                end
                if ~isFrameLost
                    ts = sprintf('%s','BB header decoding passed.');
                else
                    ts = sprintf('%s','BB header decoding failed.');
                end
                % Compute the number of frames lost. CRC failure of
                % baseband header is considered a frame loss.
                numFramesLost = isFrameLost + numFramesLost;
                fprintf('%s(Number of frames lost = %1d)\n',ts,numFramesLost)
                % Compute the bits in error.
                if isLastFrame && ~isFrameLost
                    bitsErr = bitsErr + sum(data((dataStInd-1)*dataSize+1:dataStInd*dataSize) ~= decBits);
                else
                    if ~isFrameLost
                        bitsErr = bitsErr + sum(data((dataStInd-1)*dataSize+1:dataStInd*dataSize) ~= decBits);
                    end
                end
                dataStInd = dataStInd + 1;
            end
        end
    end
    stIdx = endIdx;
end

% Synchronized data constellation plot
syncConst = comm.ConstellationDiagram('Title','Synchronized data', ...
    'XLimits',[-1.7 1.7],'YLimits',[-1.7 1.7], ...
    'ShowReferenceConstellation',false);
syncConst(syncOut)

% Error metrics display
% For GS continuous streams
if strcmpi(cfgDVBS2X.StreamFormat,'GS') && ~rxParams.UPL
    if (simParams.numFrames-rxParams.totalSyncFrames == numFramesLost)
        fprintf("All frames are lost. No bits are retrieved from BB frames.")
    else
        ber = bitsErr/((dataStInd-rxParams.totalSyncFrames)*dataSize);
        fprintf('BER           : %1.2e\n',ber)
    end
else
    % For GS and TS packetized streams
    if pktsRec == 0
        fprintf("All frames are lost. No packets are retrieved from BB frames.")
    else
        if strcmpi(cfgDVBS2X.StreamFormat,'TS')
            pktLen = 1504;
        else
            pktLen = cfgDVBS2X.UPL;      % UP length including sync byte
        end
        ber = bitsErr/(pktsRec*pktLen);
        per = pktsErr/pktsRec;
        fprintf('PER: %1.2e\n',per)
        fprintf('BER: %1.2e\n',ber)
    end
end