common.c

Go to the documentation of this file.

/******************************************************************************
*
*   Copyright (c) 2019 Intel.
*
*   Licensed under the Apache License, Version 2.0 (the "License");
*   you may not use this file except in compliance with the License.
*   You may obtain a copy of the License at
*
*       http://www.apache.org/licenses/LICENSE-2.0
*
*   Unless required by applicable law or agreed to in writing, software
*   distributed under the License is distributed on an "AS IS" BASIS,
*   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*   See the License for the specific language governing permissions and
*   limitations under the License.
*
*******************************************************************************/

#include <assert.h>
#include <err.h>
#include <arpa/inet.h>
#include <sys/time.h>
#include <time.h>

#include "common.h"
#include "xran_fh_o_du.h"
#include "xran_pkt.h"
#include "xran_pkt_up.h"
#include "xran_cp_api.h"
#include "xran_up_api.h"

#include "xran_mlog_lnx.h"

extern enum app_state state;

int iq_playback_buffer_size_dl = IQ_PLAYBACK_BUFFER_BYTES;
int iq_playback_buffer_size_ul = IQ_PLAYBACK_BUFFER_BYTES;

int iq_bfw_buffer_size_dl = IQ_PLAYBACK_BUFFER_BYTES;
int iq_bfw_buffer_size_ul = IQ_PLAYBACK_BUFFER_BYTES;

int iq_srs_buffer_size_ul = IQ_PLAYBACK_BUFFER_BYTES;

uint8_t numCCPorts = 1;
/* Number of antennas supported by front-end */

uint8_t num_eAxc = 4;
/* Number of CPRI ports supported by front-end */

int16_t *p_tx_play_buffer[MAX_ANT_CARRIER_SUPPORTED];
int32_t tx_play_buffer_size[MAX_ANT_CARRIER_SUPPORTED];
int32_t tx_play_buffer_position[MAX_ANT_CARRIER_SUPPORTED];

int16_t *p_tx_prach_play_buffer[MAX_ANT_CARRIER_SUPPORTED];
int32_t tx_prach_play_buffer_size[MAX_ANT_CARRIER_SUPPORTED];
int32_t tx_prach_play_buffer_position[MAX_ANT_CARRIER_SUPPORTED];

int16_t *p_tx_srs_play_buffer[XRAN_MAX_SECTOR_NR*XRAN_MAX_ANT_ARRAY_ELM_NR];
int32_t tx_srs_play_buffer_size[XRAN_MAX_SECTOR_NR*XRAN_MAX_ANT_ARRAY_ELM_NR];
int32_t tx_srs_play_buffer_position[XRAN_MAX_SECTOR_NR*XRAN_MAX_ANT_ARRAY_ELM_NR];

int16_t *p_rx_log_buffer[MAX_ANT_CARRIER_SUPPORTED];
int32_t rx_log_buffer_size[MAX_ANT_CARRIER_SUPPORTED];
int32_t rx_log_buffer_position[MAX_ANT_CARRIER_SUPPORTED];

int16_t *p_prach_log_buffer[MAX_ANT_CARRIER_SUPPORTED];
int32_t prach_log_buffer_size[MAX_ANT_CARRIER_SUPPORTED];
int32_t prach_log_buffer_position[MAX_ANT_CARRIER_SUPPORTED];

int16_t *p_srs_log_buffer[XRAN_MAX_SECTOR_NR*XRAN_MAX_ANT_ARRAY_ELM_NR];
int32_t srs_log_buffer_size[XRAN_MAX_SECTOR_NR*XRAN_MAX_ANT_ARRAY_ELM_NR];
int32_t srs_log_buffer_position[XRAN_MAX_SECTOR_NR*XRAN_MAX_ANT_ARRAY_ELM_NR];

int16_t *p_tx_buffer[MAX_ANT_CARRIER_SUPPORTED];
int32_t tx_buffer_size[MAX_ANT_CARRIER_SUPPORTED];

int16_t *p_rx_buffer[MAX_ANT_CARRIER_SUPPORTED];
int32_t rx_buffer_size[MAX_ANT_CARRIER_SUPPORTED];

/* beamforming weights for UL (O-DU) */
int16_t *p_tx_dl_bfw_buffer[MAX_ANT_CARRIER_SUPPORTED];
int32_t tx_dl_bfw_buffer_size[MAX_ANT_CARRIER_SUPPORTED];
int32_t tx_dl_bfw_buffer_position[MAX_ANT_CARRIER_SUPPORTED];

/* beamforming weights for UL (O-DU) */
int16_t *p_tx_ul_bfw_buffer[MAX_ANT_CARRIER_SUPPORTED];
int32_t tx_ul_bfw_buffer_size[MAX_ANT_CARRIER_SUPPORTED];
int32_t tx_ul_bfw_buffer_position[MAX_ANT_CARRIER_SUPPORTED];

/* beamforming weights for UL (O-RU) */
int16_t *p_rx_dl_bfw_buffer[MAX_ANT_CARRIER_SUPPORTED];
int32_t rx_dl_bfw_buffer_size[MAX_ANT_CARRIER_SUPPORTED];
int32_t rx_dl_bfw_buffer_position[MAX_ANT_CARRIER_SUPPORTED];

/* beamforming weights for UL (O-RU) */
int16_t *p_rx_ul_bfw_buffer[MAX_ANT_CARRIER_SUPPORTED];
int32_t rx_ul_bfw_buffer_size[MAX_ANT_CARRIER_SUPPORTED];
int32_t rx_ul_bfw_buffer_position[MAX_ANT_CARRIER_SUPPORTED];

// F1 Tables 38.101-1 Table 5.3.2-1. Maximum transmission bandwidth configuration NRB
uint16_t nNumRbsPerSymF1[3][13] =
{
    //  5MHz    10MHz   15MHz   20 MHz  25 MHz  30 MHz  40 MHz  50MHz   60 MHz  70 MHz  80 MHz   90 MHz  100 MHz
        {25,    52,     79,     106,    133,    160,    216,    270,    0,         0,      0,      0,      0},         // Numerology 0 (15KHz)
        {11,    24,     38,     51,     65,     78,     106,    133,    162,       0,    217,    245,    273},         // Numerology 1 (30KHz)
        {0,     11,     18,     24,     31,     38,     51,     65,     79,        0,    107,    121,    135}          // Numerology 2 (60KHz)
};

// F2 Tables 38.101-2 Table 5.3.2-1. Maximum transmission bandwidth configuration NRB
uint16_t nNumRbsPerSymF2[2][4] =
{
    //  50Mhz  100MHz  200MHz   400MHz
        {66,    132,    264,     0},        // Numerology 2 (60KHz)
        {32,    66,     132,     264}       // Numerology 3 (120KHz)
};

// 38.211 - Table 4.2.1
uint16_t nSubCarrierSpacing[5] =
{
    15,     // mu = 0
    30,     // mu = 1
    60,     // mu = 2
    120,    // mu = 3
    240     // mu = 4
};

// TTI interval in us (slot duration)
uint16_t nTtiInterval[4] =
{
    1000,     // mu = 0
    500,     // mu = 1
    250,     // mu = 2
    125,     // mu = 3
};


// F1 Tables 38.101-1 Table F.5.3. Window length for normal CP
uint16_t nCpSizeF1[3][13][2] =
{
    //    5MHz      10MHz      15MHz       20 MHz      25 MHz     30 MHz      40 MHz       50MHz       60 MHz      70 MHz     80 MHz     90 MHz     100 MHz
        {{40, 36}, {80, 72}, {120, 108}, {160, 144}, {160, 144}, {240, 216}, {320, 288}, {320, 288},     {0, 0},     {0, 0},     {0, 0},     {0, 0},     {0, 0}},        // Numerology 0 (15KHz)
        {{22, 18}, {44, 36},   {66, 54},   {88, 72},   {88, 72}, {132, 108}, {176, 144}, {176, 144}, {264, 216}, {264, 216}, {352, 288}, {352, 288}, {352, 288}},       // Numerology 1 (30KHz)
        {  {0, 0}, {26, 18},   {39, 27},   {52, 36},   {52, 36},   {78, 54},  {104, 72},  {104, 72}, {156, 108}, {156, 108}, {208, 144}, {208, 144}, {208, 144}},       // Numerology 2 (60KHz)
};

// F2 Tables 38.101-2 Table F.5.3. Window length for normal CP
int16_t nCpSizeF2[2][4][2] =
{
    //    50Mhz    100MHz      200MHz     400MHz
        {  {0, 0}, {104, 72}, {208, 144}, {416, 288}}, // Numerology 2 (60KHz)
        {{68, 36}, {136, 72}, {272, 144}, {544, 288}}, // Numerology 3 (120KHz)
};

uint32_t gMaxSlotNum;
uint32_t gNumDLCtx;
uint32_t gNumULCtx;
uint32_t gDLResetAdvance;
uint32_t gDLProcAdvance;
uint32_t gULProcAdvance;

static uint16_t g_NumSlotTDDLoop[XRAN_MAX_SECTOR_NR] = { XRAN_NUM_OF_SLOT_IN_TDD_LOOP };
static uint16_t g_NumDLSymSp[XRAN_MAX_SECTOR_NR][XRAN_NUM_OF_SLOT_IN_TDD_LOOP] = {0};
static uint16_t g_NumULSymSp[XRAN_MAX_SECTOR_NR][XRAN_NUM_OF_SLOT_IN_TDD_LOOP] = {0};
static uint8_t g_SlotType[XRAN_MAX_SECTOR_NR][XRAN_NUM_OF_SLOT_IN_TDD_LOOP] = {{XRAN_SLOT_TYPE_INVALID}};
float g_UlRate[XRAN_MAX_SECTOR_NR] = {0.0};
float g_DlRate[XRAN_MAX_SECTOR_NR] = {0.0};

uint32_t app_xran_get_tti_interval(uint8_t nMu)
{
    if (nMu < 4)
    {
        return nTtiInterval[nMu];
    }
    else
    {
        printf("ERROR: %s Mu[%d] is not valid\n",__FUNCTION__, nMu);
    }

    return 0;
}

uint32_t app_xran_get_scs(uint8_t nMu)
{
    if (nMu <= 3)
    {
        return nSubCarrierSpacing[nMu];
    }
    else
    {
        printf("ERROR: %s Mu[%d] is not valid\n",__FUNCTION__, nMu);
    }

    return 0;
}




//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------
uint16_t app_xran_get_num_rbs(uint32_t nNumerology, uint32_t nBandwidth, uint32_t nAbsFrePointA)
{
    uint32_t error = 1;
    uint16_t numRBs = 0;

    if (nAbsFrePointA <= 6000000)
    {
        // F1 Tables 38.101-1 Table 5.3.2-1. Maximum transmission bandwidth configuration NRB
        if (nNumerology < 3)
        {
            switch(nBandwidth)
            {
                case PHY_BW_5_0_MHZ:
                    numRBs = nNumRbsPerSymF1[nNumerology][0];
                    error = 0;
                break;
                case PHY_BW_10_0_MHZ:
                    numRBs = nNumRbsPerSymF1[nNumerology][1];
                    error = 0;
                break;
                case PHY_BW_15_0_MHZ:
                    numRBs = nNumRbsPerSymF1[nNumerology][2];
                    error = 0;
                break;
                case PHY_BW_20_0_MHZ:
                    numRBs = nNumRbsPerSymF1[nNumerology][3];
                    error = 0;
                break;
                case PHY_BW_25_0_MHZ:
                    numRBs = nNumRbsPerSymF1[nNumerology][4];
                    error = 0;
                break;
                case PHY_BW_30_0_MHZ:
                    numRBs = nNumRbsPerSymF1[nNumerology][5];
                    error = 0;
                break;
                case PHY_BW_40_0_MHZ:
                    numRBs = nNumRbsPerSymF1[nNumerology][6];
                    error = 0;
                break;
                case PHY_BW_50_0_MHZ:
                    numRBs = nNumRbsPerSymF1[nNumerology][7];
                    error = 0;
                break;
                case PHY_BW_60_0_MHZ:
                    numRBs = nNumRbsPerSymF1[nNumerology][8];
                    error = 0;
                break;
                case PHY_BW_70_0_MHZ:
                    numRBs = nNumRbsPerSymF1[nNumerology][9];
                    error = 0;
                break;
                case PHY_BW_80_0_MHZ:
                    numRBs = nNumRbsPerSymF1[nNumerology][10];
                    error = 0;
                break;
                case PHY_BW_90_0_MHZ:
                    numRBs = nNumRbsPerSymF1[nNumerology][11];
                    error = 0;
                break;
                case PHY_BW_100_0_MHZ:
                    numRBs = nNumRbsPerSymF1[nNumerology][12];
                    error = 0;
                break;
                default:
                    error = 1;
                break;
            }
        }
    }
    else
    {
        if ((nNumerology >= 2) && (nNumerology <= 3))
        {
            // F2 Tables 38.101-2 Table 5.3.2-1. Maximum transmission bandwidth configuration NRB
            switch(nBandwidth)
            {
                case PHY_BW_50_0_MHZ:
                    numRBs = nNumRbsPerSymF2[nNumerology-2][0];
                    error = 0;
                break;
                case PHY_BW_100_0_MHZ:
                    numRBs = nNumRbsPerSymF2[nNumerology-2][1];
                    error = 0;
                break;
                case PHY_BW_200_0_MHZ:
                    numRBs = nNumRbsPerSymF2[nNumerology-2][2];
                    error = 0;
                break;
                case PHY_BW_400_0_MHZ:
                    numRBs = nNumRbsPerSymF2[nNumerology-2][3];
                    error = 0;
                break;
                default:
                    error = 1;
                break;
            }
        }
    }


    if (error)
    {
        printf("ERROR: %s: nNumerology[%d] nBandwidth[%d] nAbsFrePointA[%d]\n",__FUNCTION__, nNumerology, nBandwidth, nAbsFrePointA);
    }
    else
    {
        printf("%s: nNumerology[%d] nBandwidth[%d] nAbsFrePointA[%d] numRBs[%d]\n",__FUNCTION__, nNumerology, nBandwidth, nAbsFrePointA, numRBs);
    }

    return numRBs;
}

//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------
uint32_t app_xran_cal_nrarfcn(uint32_t nCenterFreq)
{
    uint32_t nDeltaFglobal,nFoffs,nNoffs;
    uint32_t nNRARFCN = 0;

    if(nCenterFreq > 0 && nCenterFreq < 3000*1000)
    {
        nDeltaFglobal = 5;
        nFoffs = 0;
        nNoffs = 0;
    }
    else if(nCenterFreq >= 3000*1000 && nCenterFreq < 24250*1000)
    {
        nDeltaFglobal = 15;
        nFoffs = 3000*1000;
        nNoffs = 600000;
    }
    else if(nCenterFreq >= 24250*1000 && nCenterFreq <= 100000*1000)
    {
        nDeltaFglobal = 60;
        nFoffs = 24250080;
        nNoffs = 2016667;
    }
    else
    {
         printf("@@@@ incorrect center frerquency %d\n",nCenterFreq);
         return (0);
    }

    nNRARFCN = ((nCenterFreq - nFoffs)/nDeltaFglobal) + nNoffs;

    printf("%s: nCenterFreq[%d] nDeltaFglobal[%d] nFoffs[%d] nNoffs[%d] nNRARFCN[%d]\n", __FUNCTION__, nCenterFreq, nDeltaFglobal, nFoffs, nNoffs, nNRARFCN);
    return (nNRARFCN);
}

int32_t app_xran_slot_limit(int32_t nSfIdx)
{
    while (nSfIdx < 0) {
        nSfIdx += gMaxSlotNum;
    }

    while (nSfIdx >= gMaxSlotNum) {
        nSfIdx -= gMaxSlotNum;
    }

    return nSfIdx;
}

void app_xran_clear_slot_type(uint32_t nPhyInstanceId)
{
    g_UlRate[nPhyInstanceId] = 0.0;
    g_DlRate[nPhyInstanceId] = 0.0;
    g_NumSlotTDDLoop[nPhyInstanceId] = 1;
}

int32_t app_xran_set_slot_type(uint32_t nPhyInstanceId, uint32_t nFrameDuplexType, uint32_t nTddPeriod, struct xran_slot_config *psSlotConfig)
{
    uint32_t nSlotNum, nSymNum, nVal, i;
    uint32_t numDlSym, numUlSym, numGuardSym;
    uint32_t numDlSlots = 0, numUlSlots = 0, numSpDlSlots = 0, numSpUlSlots = 0, numSpSlots = 0;
    char sSlotPattern[XRAN_SLOT_TYPE_LAST][10] = {"IN\0", "DL\0", "UL\0", "SP\0", "FD\0"};

    // nPhyInstanceId    Carrier ID
    // nFrameDuplexType  0 = FDD 1 = TDD
    // nTddPeriod        Tdd Periodicity
    // psSlotConfig[80]  Slot Config Structure for nTddPeriod Slots

    g_UlRate[nPhyInstanceId] = 0.0;
    g_DlRate[nPhyInstanceId] = 0.0;
    g_NumSlotTDDLoop[nPhyInstanceId] = nTddPeriod;

    for (i = 0; i < XRAN_NUM_OF_SLOT_IN_TDD_LOOP; i++)
    {
        g_SlotType[nPhyInstanceId][i] = XRAN_SLOT_TYPE_INVALID;
        g_NumDLSymSp[nPhyInstanceId][i] = 0;
        g_NumULSymSp[nPhyInstanceId][i] = 0;
    }

    if (nFrameDuplexType == XRAN_FDD)
    {
        for (i = 0; i < XRAN_NUM_OF_SLOT_IN_TDD_LOOP; i++)
        {
            g_SlotType[nPhyInstanceId][i] = XRAN_SLOT_TYPE_FDD;
        }
        g_NumSlotTDDLoop[nPhyInstanceId] = 1;
        g_DlRate[nPhyInstanceId] = 1.0;
        g_UlRate[nPhyInstanceId] = 1.0;
    }
    else
    {
        for (nSlotNum = 0; nSlotNum < nTddPeriod; nSlotNum++)
        {
            numDlSym = 0;
            numUlSym = 0;
            numGuardSym = 0;
            for (nSymNum = 0; nSymNum < XRAN_NUM_OF_SYMBOL_PER_SLOT; nSymNum++)
            {
                switch(psSlotConfig[nSlotNum].nSymbolType[nSymNum])
                {
                    case XRAN_SYMBOL_TYPE_DL:
                        numDlSym++;
                    break;
                    case XRAN_SYMBOL_TYPE_GUARD:
                        numGuardSym++;
                    break;
                    default:
                        numUlSym++;
                    break;
                }
            }

            // printf("nSlotNum[%d] : numDlSym[%d] numGuardSym[%d] numUlSym[%d]\n", nSlotNum, numDlSym, numGuardSym, numUlSym);

            if ((numUlSym == 0) && (numGuardSym == 0))
            {
                g_SlotType[nPhyInstanceId][nSlotNum] = XRAN_SLOT_TYPE_DL;
                numDlSlots++;
            }
            else if ((numDlSym == 0) && (numGuardSym == 0))
            {
                g_SlotType[nPhyInstanceId][nSlotNum] = XRAN_SLOT_TYPE_UL;
                numUlSlots++;
            }
            else
            {
                g_SlotType[nPhyInstanceId][nSlotNum] = XRAN_SLOT_TYPE_SP;
                numSpSlots++;

                if (numDlSym)
                {
                    numSpDlSlots++;
                    g_NumDLSymSp[nPhyInstanceId][nSlotNum] = numDlSym;
                }
                if (numUlSym)
                {
                    numSpUlSlots++;
                    g_NumULSymSp[nPhyInstanceId][nSlotNum] = numUlSym;
                }
            }

            // printf("            numDlSlots[%d] numUlSlots[%d] numSpSlots[%d] numSpDlSlots[%d] numSpUlSlots[%d]\n", numDlSlots, numUlSlots, numSpSlots, numSpDlSlots, numSpUlSlots);
        }

        g_DlRate[nPhyInstanceId] = (float)(numDlSlots + numSpDlSlots) / (float)nTddPeriod;
        g_UlRate[nPhyInstanceId] = (float)(numUlSlots + numSpUlSlots) / (float)nTddPeriod;
    }

    printf("set_slot_type: nPhyInstanceId[%d] nFrameDuplexType[%d], nTddPeriod[%d]\n",
        nPhyInstanceId, nFrameDuplexType, nTddPeriod);

    printf("DLRate[%f] ULRate[%f]\n", g_DlRate[nPhyInstanceId], g_UlRate[nPhyInstanceId]);

    nVal = (g_NumSlotTDDLoop[nPhyInstanceId] < 10) ? g_NumSlotTDDLoop[nPhyInstanceId] : 10;

    printf("SlotPattern:\n");
    printf("Slot:   ");
    for (nSlotNum = 0; nSlotNum < nVal; nSlotNum++)
    {
        printf("%d    ", nSlotNum);
    }
    printf("\n");

    printf("  %3d   ", 0);
    for (nSlotNum = 0, i = 0; nSlotNum < g_NumSlotTDDLoop[nPhyInstanceId]; nSlotNum++)
    {
        printf("%s   ", sSlotPattern[g_SlotType[nPhyInstanceId][nSlotNum]]);
        i++;
        if ((i == 10) && ((nSlotNum+1) < g_NumSlotTDDLoop[nPhyInstanceId]))
        {
            printf("\n");
            printf("  %3d   ", nSlotNum);
            i = 0;
        }
    }
    printf("\n\n");

    return 0;
}

int32_t app_xran_get_slot_type(int32_t nCellIdx, int32_t nSlotdx, int32_t nType)
{
    int32_t nSfIdxMod, nSfType, ret = 0;

    nSfIdxMod = app_xran_slot_limit(nSlotdx) % ((g_NumSlotTDDLoop[nCellIdx] > 0) ? g_NumSlotTDDLoop[nCellIdx]: 1);
    nSfType = g_SlotType[nCellIdx][nSfIdxMod];

    if (nSfType == nType)
    {
        ret = 1;
    }
    else if (nSfType == XRAN_SLOT_TYPE_SP)
    {
        if ((nType == XRAN_SLOT_TYPE_DL) && g_NumDLSymSp[nCellIdx][nSfIdxMod])
        {
            ret = 1;
        }

        if ((nType == XRAN_SLOT_TYPE_UL) && g_NumULSymSp[nCellIdx][nSfIdxMod])
        {
            ret = 1;
        }
    }
    else if (nSfType == XRAN_SLOT_TYPE_FDD)
    {
        ret = 1;
    }

    return ret;
}



void sys_save_buf_to_file(char *filename, char *bufname, unsigned char *pBuffer, unsigned int size, unsigned int buffers_num)
{
    if (size)
    {
        if (filename && bufname)
        {
            FILE           *file;
            printf("Storing %s to file %s: ", bufname, filename);
            file = fopen(filename, "wb");
            if (file == NULL)
            {
                printf("can't open file %s!!!", filename);
            }
            else
            {
                uint32_t             num;
                num = fwrite(pBuffer, buffers_num, size, file);
                fflush(file);
                fclose(file);
                printf("from addr (0x%lx) size (%d) bytes num (%d)", (uint64_t)pBuffer, size, num);
            }
            printf(" \n");
        }
        else
        {
            printf(" the file name, buffer name are not set!!!");
        }
    }
    else
    {
        printf(" the %s is free: size = %d bytes!!!", bufname, size);
    }
}

int sys_load_file_to_buff(char *filename, char *bufname, unsigned char *pBuffer, unsigned int size, unsigned int buffers_num)
{
    unsigned int  file_size = 0;
    int  num= 0;

    if (size)
    {
        if (filename && bufname)
        {
            FILE           *file;
            printf("Loading file %s to  %s: ", filename, bufname);
            file = fopen(filename, "rb");


            if (file == NULL)
            {
                printf("can't open file %s!!!", filename);
                exit(-1);
            }
            else
            {
                fseek(file, 0, SEEK_END);
                file_size = ftell(file);
                fseek(file, 0, SEEK_SET);

                if ((file_size > size) || (file_size == 0))
                    file_size = size;

                printf("Reading IQ samples from file: File Size: %d [Buffer Size: %d]\n", file_size, size);

                num = fread(pBuffer, buffers_num, size, file);
                fflush(file);
                fclose(file);
                printf("from addr (0x%lx) size (%d) bytes num (%d)", (uint64_t)pBuffer, file_size, num);
            }
            printf(" \n");

        }
        else
        {
            printf(" the file name, buffer name are not set!!!");
        }
    }
    else
    {
        printf(" the %s is free: size = %d bytes!!!", bufname, size);
    }
    return num;
}


void sys_save_buf_to_file_txt(char *filename, char *bufname, unsigned char *pBuffer, unsigned int size, unsigned int buffers_num)
{
    unsigned int i;
    int ret = 0;
    if (pBuffer == NULL)
        return;

    if (size)
    {
        if (filename && bufname)
        {
            FILE           *file;
            printf("Storing %s to file %s: ", bufname, filename);
            file = fopen(filename, "w");
            if (file == NULL)
            {
                printf("can't open file %s!!!", filename);
                exit(-1);
            }
            else
            {
                uint32_t num = 0;

                signed short *ptr = (signed short*)pBuffer;
                for (i = 0; i < (size/((unsigned int)sizeof(signed short) )); i = i + 2)
                {
#ifndef CSCOPE_DEBUG
                    ret = fprintf(file,"%d %d\n", ptr[i], ptr[i + 1]);
#else
                    ret = fprintf(file,"%d %d ", ptr[i], ptr[i + 1]);
                    /*      I data => Ramp data, from 1 to 792.
                            Q data => Contains time information of the current symbol:
                            Bits [15:14] = Antenna-ID
                            Bits [13:12] = “00”
                            Bits [11:8]  = Subframe-ID
                            Bits [7:4]   = Slot-ID
                            Bits [3:0]   = Symbol-ID */
                            fprintf(file, "0x%04x: ant %d Subframe-ID %d Slot-ID %d Symbol-ID %d\n",
                                        ptr[i + 1], (ptr[i + 1]>>14) & 0x3,  (ptr[i + 1]>>8) & 0xF,  (ptr[i + 1]>>4) & 0xF, (ptr[i + 1]>>0) & 0xF);
#endif
                    if (ret < 0)
                    {
                        printf("fprintf %d\n", ret);
                        fclose(file);
                        break;
                    }
                    num++;
                }
                fflush(file);
                fclose(file);
                printf("from addr (0x%lx) size (%d) IQ num (%d)", (uint64_t)pBuffer, size, num);
            }
            printf(" \n");
        }
        else
        {
            printf(" the file name, buffer name are not set!!!");
        }
    }
    else
    {
        printf(" the %s is free: size = %d bytes!!!", bufname, size);
    }
}