load ueDetectionWaveform.mat;
rxWaveform = double(rxWaveform) / 32768;

% Perform frequency offset estimation and correction
foffset = lteFrequencyOffset(enb,rxWaveform);
rxWaveform = lteFrequencyCorrect(enb,rxWaveform,foffset);

% Perform timing synchronization to the first whole subframe of the
% waveform
toffset = lteDLFrameOffset(enb,rxWaveform);
ofdmInfo = lteOFDMInfo(enb);
sfLength = ofdmInfo.SamplingRate * 1e-3;
offsetSubframes = floor(toffset / sfLength);
toffset = toffset - (offsetSubframes * sfLength);
rxWaveform = rxWaveform(1+toffset:end,:);
enb.NSubframe = mod(-offsetSubframes,10);

rxgrid = lteOFDMDemodulate(enb,rxWaveform);

cec.PilotAverage = 'UserDefined';     % Type of pilot averaging
cec.FreqWindow = 13;                  % Frequency window size
cec.TimeWindow = 9;                   % Time window size
cec.InterpType = 'cubic';             % 2D interpolation type
cec.InterpWindow = 'Centered';        % Interpolation window type
cec.InterpWinSize = 1;                % Interpolation window size

% Maximum number of bit errors allowed to consider a detection as valid
maxErrors = 2;

% Minimum PDCCH power in dB (relative to the cell-specific reference signal
% used for channel estimation) to consider a detection as valid
minPDCCHPower = -5.0;

% Initialize results table
results = table;

% Get DCI formats and lengths for DCI messages in the common search space
pdcchCommon = struct('SearchSpace','Common');
pdcchCommon.ControlChannelType = 'PDCCH';
CIF = 'Off'; % enable or disable Carrier Indicator Field
pdcchCommon.EnableCarrierIndication = CIF;
[dciInfoCommon,pdcchCommon] = getUniqueDCILengths(enb,pdcchCommon);

% Get DCI formats and lengths for DCI messages in the UE-specific search
% space. The length of a DCI message of a given format may be affected by
% various UE-specific higher-layer parameters so the set of different
% unique lengths across those parameters is recorded, along with the
% corresponding parameter combinations
pdcchUESpecific = struct('SearchSpace','UESpecific');
pdcchUESpecific.ControlChannelType = 'PDCCH';
pdcchUESpecific.EnableCarrierIndication = CIF;
[dciInfoUESpecific,pdcchUESpecific] = getUniqueDCILengths(enb,pdcchUESpecific);

% Establish the number of subframes in the waveform
griddims = lteResourceGridSize(enb);
L = griddims(2);
nSubframes = floor(size(rxgrid,2) / L);

% For each subframe in the waveform, attempt to decode the PDCCH
startSubframe = enb.NSubframe;
CFIs = zeros(1,nSubframes);
for i = 0:nSubframes-1

    % Extract the current subframe
    rxSubframe = rxgrid(:,(i*L) + (1:L),:);

    % Perform channel estimation
    [hest,nest] = lteDLChannelEstimate(enb,cec,rxSubframe);

    % If the current subframe contains the first occurrence of the MIB in
    % the waveform, decode the MIB to establish the frame number
    if (enb.NSubframe==0 && i<10)
        startFrame = decodeMIB(enb,rxSubframe,hest,nest,i);
    end

    % Get PCFICH indices, extract received PCFICH symbols and corresponding
    % channel estimate, demodulate PCFICH, decode and record CFI
    pcfichIndices = ltePCFICHIndices(enb);
    [pcfichRx,pcfichHest] = lteExtractResources(pcfichIndices,rxSubframe,hest);
    pcfichBits = ltePCFICHDecode(enb,pcfichRx,pcfichHest,nest);
    enb.CFI = lteCFIDecode(pcfichBits);
    CFIs(i+1) = enb.CFI;

    % Get PDCCH indices
    pdcchIndices = ltePDCCHIndices(enb);

    % Extract received PDCCH symbols and corresponding channel estimate
    [pdcchRx,pdcchHest] = lteExtractResources(pdcchIndices,rxSubframe,hest);

    % Perform PDCCH demodulation to obtain the received PDCCH bits, which
    % may contain encoded DCI messages for one or more users
    [pdcchBits,pdcchSymbols] = ltePDCCHDecode(enb,pdcchRx,pdcchHest,nest);

    % Initialize array of PDCCH format / candidate / DCI format
    % combinations, which represent possible UEs (i.e. possible locations
    % for DCI messages providing a downlink or uplink grant for a UE)
    possibleUEs = [];

    % PDCCH format for UE-specific search space can be 0, 1, 2, or 3
    for pdcchFormat = 0:3

        ue = struct();

        % Get all PDCCH candidate indices and the number of candidates M
        % for the current PDCCH format
        ue.PDCCHFormat = pdcchFormat;
        candidates = getPDCCHCandidates(enb,ue);
        M = size(candidates,1);

        % For each candidate
        for m = 1:M

            % Record PDCCH candidate indices
            ue.Candidate = candidates(m,:);

            % For each DCI format in the UE-specific search space
            dciFormats = fieldnames(dciInfoUESpecific);
            for dciFormatIdx = 1:length(dciFormats)

                % Record DCI format
                ue.DCIFormat = dciFormats{dciFormatIdx};

                % Record this PDCCH format / candidate / DCI format
                % combination as a possible "UE". For DCI formats that have
                % different lengths across the UE-specific higher-layer
                % parameters, each length is recorded as a different
                % possible UE
                dciLengths = dciInfoUESpecific.(ue.DCIFormat);
                for dciLengthIdx = 1:length(dciLengths)
                    ue.DCILength = dciLengths(dciLengthIdx);
                    ue.PDCCH = pdcchUESpecific.(ue.DCIFormat)(dciLengthIdx);
                    possibleUEs = [possibleUEs ue]; %#ok<AGROW>
                end

            end

            % For PDCCH formats 2 or 3, record the possibility of a DCI
            % message in the common search space in this candidate location
            % with format 1A or 1C. Such DCI messages correspond to System
            % Information, Paging, or Random Access Response message rather
            % than uplink or downlink grants for a UE, but are searched for
            % in this example for completeness
            if (any(pdcchFormat==[2 3]))
                for dciFormat = {'Format1A' 'Format1C'}
                    ue.DCIFormat = dciFormat{1};
                    ue.DCILength = dciInfoCommon.(ue.DCIFormat);
                    ue.PDCCH = pdcchCommon.(ue.DCIFormat);
                    possibleUEs = [possibleUEs ue]; %#ok<AGROW>
                end
            end

        end

    end

    % For each possible UE
    for ue = possibleUEs

        % Get the received candidate bits from the received PDCCH bits (for
        % DCI decoding)
        bitIdx = ue.Candidate;
        candidateBits = pdcchBits(bitIdx(1):bitIdx(2));

        % Get the received candidate symbols from the received PDCCH
        % symbols (for PDCCH power estimation). The modulation order Qm = 2
        % is used to convert candidate bit indices into candidate symbol
        % indices (QPSK modulation is always used for PDCCH)
        Qm = 2;
        symIdx = [((bitIdx(1) - 1) / Qm) + 1 bitIdx(2)/Qm];
        candidateSymbols = pdcchSymbols(symIdx(1):symIdx(2));

        % Decode the received candidate bits and get the RNTI. Assuming a
        % CRC pass (CRC = 0), the 2nd output from lteDCIDecode will
        % correspond to the RNTI
        [dciMessageBits,RNTI] = lteDCIDecode(ue.DCILength,candidateBits);

        % Re-encode the decoded DCI message bits (using the detected RNTI)
        % and establish the number of bit errors between the re-encoded
        % candidate bits and received candidate bits
        ue.RNTI = RNTI;
        reencodedCandidateBits = lteDCIEncode(ue,dciMessageBits);
        numErrors = sum(int8(candidateBits > 0) ~= reencodedCandidateBits);

        % If the number of bit errors is greater than maxErrors, continue
        % to the next possible UE (the rest of the loop body here is not
        % executed)
        if (numErrors > maxErrors)
            continue;
        end

        % Create DCI message structure from message bit payload. This is
        % performed because for some DCI formats (e.g. format 0 versus
        % format 1A), the true DCI format amongst DCI formats with
        % the same length can be determined by the value of a message bit
        dci = lteDCI(enb,ue.PDCCH,dciMessageBits);

        % Create table entry for the current DCI message
        result = struct();
        result.Subframe = i;
        result.DetectedRNTI = string(dec2hex(ue.RNTI,4));
        result.NumErrors = numErrors;
        result.DCIFormat = string(dci.DCIFormat);
        result.PDCCHFormat = ue.PDCCHFormat;
        result.Candidate = ue.Candidate;
        result.PDCCHPower = round(10*log10(var(candidateSymbols)),2);
        result.DCI = {dci};
        result = struct2table(result);

        % Check if a DCI message has previously been successfully decoded
        % in this subframe with the same RNTI, DCI format and starting
        % candidate location as the current DCI message (but with a
        % different PDCCH format)
        if (~isempty(results))
            match = (results.Subframe == result.Subframe);
            match = match & (results.DetectedRNTI == result.DetectedRNTI);
            match = match & strcmpi(results.DCIFormat,result.DCIFormat);
            match = match & (results.Candidate(:,1) == result.Candidate(1));
            match = find(match~=0);
        else
            match = [];
        end

        % If a DCI message satisfies the criteria above, it must have been
        % for a smaller PDCCH format and therefore represents successful
        % decoding of part of the current message, i.e. decoding a subset
        % of the candidate Control Channel Elements (CCEs). Therefore the
        % previous result can be replaced with the current result. Note
        % that for larger PDCCH formats the number of bit errors will tend
        % to be bigger as there are more candidate bits, so at low SNRs the
        % detected PDCCH format here may be lower than the true PDCCH
        % format (i.e. the number of errors in the bits for the true PDCCH
        % format exceeds maxErrors)
        if (isempty(match))
            results = [results; result]; %#ok<AGROW>
        else
            results(match,:) = result;
        end

    end

    % Update the subframe number
    enb.NSubframe = mod(enb.NSubframe + 1,10);

end

% Remove results whose estimated PDCCH power (in dB) is lower than the
% minimum power threshold. Without this step, received candidate symbols
% consisting solely of noise (even at a low power) can trigger false
% detections
if (~isempty(results))
    results(results.PDCCHPower < minPDCCHPower,:) = [];
end

% Check if results are empty
if (isempty(results))
    disp('No RNTIs found.');
    return;
end

% In any given subframe, in the case of overlapping results (i.e. where the
% candidate indices of one result are a subset of another), the result with
% the lowest number of bit errors will be selected
overlapping = [];
for i = unique(results.Subframe).'

    % Find result rows which correspond to the current subframe and extract
    % those results
    sf = find(results.Subframe == i).';

    % For each pair of results in this subframe
    for a = sf
        for b = sf

            ca = results{a,'Candidate'};
            cb = results{b,'Candidate'};

            % If the first result's candidate indices are a subset of the
            % second result's candidate indices
            if (ca(1)>=cb(1) && ca(2)<=cb(2))

                % If the first result has more errors
                if (results{a,'NumErrors'}>results{b,'NumErrors'})

                    % Mark the first result in the pair as overlapping
                    % (i.e. mark it for removal)
                    overlapping = [overlapping a]; %#ok<AGROW>

                end

            end

        end
    end

end

% Remove overlapping results
results(overlapping,:) = [];

% Add a label for each row of the results table
results.Properties.RowNames = strsplit(num2str(1:height(results)));

disp(results);

enb.NFrame = startFrame;
enb.NSubframe = startSubframe;
enb.CFI = CFIs;
summary = hPlotDetectedRNTIs(results,enb,rxgrid);

disp(summary);

% Get DCI message information for DCI formats with unique lengths, across
% all UE-specific higher-layer parameters
function [infoOut,pdcchOut] = getUniqueDCILengths(enb,pdcchIn)

    infoOut = [];

    for EnableSRSRequest = {'Off' 'On'}

        pdcchIn.EnableSRSRequest = EnableSRSRequest{1};

        for EnableMultipleCSIRequest = {'Off' 'On'}

            pdcchIn.EnableMultipleCSIRequest = EnableMultipleCSIRequest{1};

            for NTxAnts = [1 2 4]

                pdcchIn.NTxAnts = NTxAnts;

                % Get the DCI message lengths for all formats, as a
                % structure
                info = lteDCIInfo(enb,pdcchIn);

                % Convert the structure into a cell array of field names
                % and values
                formats = fieldnames(info);
                sizes = struct2cell(info);

                % Remove DCI format 3 and 3A as these DCI formats are used
                % for conveying power control commands rather than resource
                % allocations
                dci3idx = ismember(formats,{'Format3','Format3A'});
                formats(dci3idx) = [];
                sizes(dci3idx) = [];

                % Keep only DCI format 1A and 1C for the common search
                % space
                if (strcmpi(pdcchIn.SearchSpace,'Common'))
                    commonidx = ismember(formats,{'Format1A','Format1C'});
                    formats = formats(commonidx);
                    sizes = sizes(commonidx);
                end

                % Find the indices of the unique sizes, the first
                % occurrence of each unique size will be retained in the
                % original order
                [~,idxs] = unique(cat(2,sizes{:}),'stable');

                % If the current UE-specific settings yield unique sizes
                % for any format (compared to all other formats and
                % UE-specific settings thus far), then record them
                if (isempty(infoOut))
                    infoOut = cell2struct(sizes(idxs),formats(idxs));
                    pdcchOut = cell2struct(repmat({pdcchIn},size(idxs)),formats(idxs));
                else
                    sizes_out = struct2cell(infoOut);
                    sizes_out = cat(2,sizes_out{:});
                    for i = idxs.'
                        if (~any(sizes_out==sizes{i}))
                            format = formats{i};
                            infoOut.(format) = [infoOut.(format) sizes{i}];
                            pdcchOut.(format) = [pdcchOut.(format) pdcchIn];
                        end
                    end
                end

            end

        end

    end

end

% Decode the Master Information Block (MIB) to get frame number
function startFrame = decodeMIB(enb,rxSubframe,hest,nest,i)

    pbchIndices = ltePBCHIndices(enb);
    [pbchRx, pbchHest] = lteExtractResources(pbchIndices,rxSubframe,hest);
    [~,~,nfmod4,mibbits] = ltePBCHDecode(enb,pbchRx,pbchHest,nest);
    mib = lteMIB(mibbits);
    startFrame = double(mib.NFrame) + nfmod4;
    if (i>0)
        startFrame = mod(startFrame - 1,1024);
    end

end

% Get all PDCCH candidates for a given eNodeB configuration and UE
% configuration, without having to evaluate all possible RNTIs
function pdcchCandidates = getPDCCHCandidates(enb,ue)

    % PDCCH dimensionality information
    pdcchInfo = ltePDCCHInfo(enb);

    % Aggregation level
    L = 2 ^ ue.PDCCHFormat;

    % Number of candidates
    M = floor(double(pdcchInfo.NCCE)/L);

    % 1 CCE = 9 REGs = 36 REs = 72 bits
    bitsPerCCE = 72;

    % PDCCH candidate indices within PDCCH bits (1-based)
    pdcchCandidates = L*bitsPerCCE*(0:M-1).' + [1 L*bitsPerCCE];

end