基于内存缓冲区的流媒体数据缓存排序（二）

C++ 实验
基于内存缓冲区的流媒体数据缓存排序（二）

要求：

① 针对一个流媒体节目的单线程下载进行处理；
② 节目数据包无丢失、有乱序，假设乱序范围不超过10个数据包；
③ 将收到的数据包直接写入缓冲区，缓冲区长度无限定；

④排好序的数据如果超过一定长度，如30KB（可设定），则输出到文件；

实现要求

缓冲区类

定义基于动态内存分配的缓冲区类，包括如下

数据成员：

缓冲区，用于缓存数据（按偏移量写入，完成排序）；

记录缓冲区内收到的数据总量；

缓冲区中数据在节目（文件）中的偏移量（缺了这项信息，无法写入文件）；

其他必要信息。

成员函数：

构造函数、析构函数

数据接收函数

数据输出函数

测试程序

模拟网络流媒体的数据流到达：

设定数据来源多媒体文件（本地磁盘）；

从多媒体文件读取一块数据（长度不超多1500B），模拟网络数据包；

模拟的网络数据包：包括节目ID、数据包偏移量、数据包长度；

将数据包发送给排序缓存类。

将文件的所有数据按上述方式读入并发送给排序缓存类

最好用类实现（不要求）

提示：用随机数生成每个数据包的长度：256～1500 Bytes

</pre><pre name="code" class="cpp">/*StreamBuffer.h*/

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <ctime>

using namespace std;

class StreamBuffer
{
public:
 StreamBuffer();
    StreamBuffer(int iLen);
 int ReceiveData(unsigned int offset, unsigned int bytes, char *pData); //接收数据包。
 int ContinueBytes(unsigned int &iDataOffset, char* &pData); //统计缓冲区中排好序的数据的信息。
 int RemoveData(int iBytes); //释放缓冲区。
 ~StreamBuffer();

private:
    char m_pData[30*1500]; //存数据的buffer，也可以用指针。
 unsigned int m_PacketOffset[20]; //存传入数据包的偏移量。
 unsigned int m_PacketBytes[20]; //存传入数据包的数据量（长度）。
 char m_PacketData[20][1500]; //存传入数据包的数据。
 int inPacketOffset; //写入缓冲区的数据的偏移量（标记下次位置）。
 int m_iPacketsNum; //存储数据包的数组下标（每20个一循环）。
 int outPackerOffset; // 缓冲区中排好序的数据块中第一个字节的偏移量数值.
    int m_iBufferLen;  //缓冲区中排好序的数据的字节数（长度）。
};

/*StreamBuffer.cpp*/

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>

#include "StreamBuffer.h"

using namespace std;

StreamBuffer::StreamBuffer()
{
 m_iBufferLen = 0;
 m_iPacketsNum = 0;
    <span style="white-space:pre"> </span>m_iBufferLen = 0;
    <span style="white-space:pre"> </span>outPackerOffset = 0;
    <span style="white-space:pre"> </span>inPacketOffset = 0;
}

StreamBuffer::StreamBuffer(int iLen)
{
 m_iBufferLen = iLen;
 m_iPacketsNum = iLen;
    <span style="white-space:pre"> </span>m_iBufferLen = iLen;
    <span style="white-space:pre"> </span>outPackerOffset = iLen;
}

int StreamBuffer::ReceiveData(unsigned int offset, unsigned int bytes, char *pData)
{
 int iBytes, i, j;
 cout << "bytes = " << bytes << endl;


 m_PacketOffset[m_iPacketsNum] = offset; //记录传入的每个数据包的偏移量。
 m_PacketBytes[m_iPacketsNum] = bytes;  //记录传入的每个数据包的长度。

 // 存储每个数据包的数据。
 for(iBytes = 0; iBytes < abs(bytes); iBytes++)
 {
  m_PacketData[m_iPacketsNum][iBytes] = *(pData++);
 }

 m_iPacketsNum++;

    //遍历每个数据包的偏移量信息，如果符合排序要求，就进行排序（即写入缓冲区）。
 for(i = 0; i < m_iPacketsNum; i++)
 {
  if(m_PacketOffset[i] == abs(inPacketOffset))
  {
   inPacketOffset += m_PacketBytes[i];
   for(j = 0; j < abs(m_PacketBytes[i]); j++)
   {
    m_pData[m_iBufferLen++] = m_PacketData[i][j];
   }
   i = 0;
  }
 }

 if(m_iPacketsNum == 20) //当接收了20个数据包后，清零，开始下一次的接收。
 {
  m_iPacketsNum = 0;
 }
 return iBytes;
}

int StreamBuffer::ContinueBytes(unsigned int &iDataOffset, char* &pData)
{
 //返回缓冲区中，排好序的数据的长度（单位字节数）。并通过引用参数返回如下信息
 //iDataOffset: 排好序的数据块中第一个字节的偏移量数值
 //pData：数据指针
 int iContinueBytes = 0;

 pData = m_pData;
 iDataOffset = outPackerOffset;
 iContinueBytes = m_iBufferLen;

 return iContinueBytes;
}

int StreamBuffer::RemoveData(int iBytes)
{
 //从缓冲区中把数据"删除",返回删除的字节数
 int iBytesRemoved=0, i;

 outPackerOffset += iBytes;
 m_iBufferLen = 100;

 for(i = 0; i < 100; i++)
 {
  m_pData[i] = m_pData[iBytes+i];
 }

 return iBytesRemoved;
}

StreamBuffer::~StreamBuffer()
{
 if(NULL != m_pData)
 {
  delete []m_pData;
 }
}

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <ctime>

#include "StreamBuffer.cpp"

using namespace std;

void GenDisOrder(int iSendOrder[],int iPacketNum);

int main()
{
 //该部分用于打开读写文件。
 FILE* fpSrcFile = NULL;
 FILE* fpDstFile = NULL;

 char srcfileName[500] = "TestFile//song1.mp3";
 char dstfileName[500] = "TestFile//result.mp3";

 fpSrcFile = fopen(srcfileName, "rb");
 if( fpSrcFile == NULL )
 {
   cout<<"Cann't open file: "<<srcfileName<<endl;
   return 1;
 }

 fpDstFile = fopen(dstfileName, "wb");
 if( fpDstFile == NULL )
 {
   cout<<"Cann't create file: "<< dstfileName <<endl;
   return 2;
 }


 const int MTU =  1500; //最大传输单元，网络术语，表示一个数据包大最大尺寸，单位：字节
 int iReadBytes = 0;
 int iWantReadBytes;
    int iContinueBytes;
    int iUseBytes;
 unsigned int iOutDataOffset;
 char *pOutData;

 StreamBuffer MyBuffer; //用排序类创建对象。

 const int iMaxPacketNum = 20;  //每次读入20个数据包，然后以乱序的形式发给排序模块（StreamBuffer类）
 int iSendOrder[iMaxPacketNum]; //记录下发数据包的顺序
 unsigned int iPacketOffset[iMaxPacketNum]; //记录每个数据包中第一个字节数据的偏移量
 unsigned int iPacketLen[iMaxPacketNum]; //记录每个数据包中的数据长度
 char (*pDataBuf)[MTU]; //数据包缓冲区区。

 int iPacketNum;
 int i;
 int iPackNo;

    srand(100);//用固定值初始化，会生成固定的随机数序列，方便测试程序，否则用srand( (unsigned)time( NULL ) );
 pDataBuf = new char[iMaxPacketNum][MTU];

 iWantReadBytes = 1024;

    do
 {
        iPacketNum = 0;
        for(i = 0; i < iMaxPacketNum; i++) //初始化数据包长度为0，表示没有读入数据
        {
           iPacketLen[i] = 0;
   }

  do
  {
   iPacketOffset[iPacketNum] = ftell(fpSrcFile); //获取文件的偏移量。
   iReadBytes = fread(pDataBuf[iPacketNum], 1, iWantReadBytes, fpSrcFile);
            iPacketLen[iPacketNum] = iReadBytes; //当前数据包读取成功，记录数据包长度，否则依旧是0
            iWantReadBytes = (iPacketOffset[iPacketNum] + iPacketNum * iPacketNum) % 500 + 400; //下一个数据包读取长度
            iPacketNum++;

        }
        while((iReadBytes > 0) && (iPacketNum < iMaxPacketNum));
        //读入一组数据包，如果文件结束：iReadBytes<1

        GenDisOrder(iSendOrder, iMaxPacketNum); //利用函数GenDisOrder对已经产生的20个数据包打乱顺序。

        //把刚刚已经读入一组数据包，乱序下发给排序模块
        for(i = 0; i < iMaxPacketNum; i++) //只要长度不为0，就发给排序模块
        {
            iPackNo = iSendOrder[i];
            if(iPacketLen[iPackNo] > 0)//有数据，给给排序模块
            {
    MyBuffer.ReceiveData(iPacketOffset[iPackNo], iPacketLen[iPackNo], pDataBuf[iPackNo]);
                iContinueBytes = MyBuffer.ContinueBytes(iOutDataOffset, pOutData);
                iUseBytes = iContinueBytes - 100; //假设用了一部分

                if( iContinueBytes > (20*1024)) //缓冲区数据只要大于20 KB就写入到文件中。
                {
                   fseek(fpDstFile, iOutDataOffset, SEEK_SET);
                   fwrite(pOutData, iUseBytes, 1, fpDstFile);
                   MyBuffer.RemoveData(iUseBytes);
                }
            }
        }
    }
    while(iReadBytes > 0);//文件还没读取完。


 //输入结束，把缓冲区中剩余排好序的数据取出
    iContinueBytes = MyBuffer.ContinueBytes(iOutDataOffset, pOutData);
 if(iContinueBytes > 0)
 {
  fseek(fpDstFile, iOutDataOffset, SEEK_SET);
  fwrite(pOutData, iContinueBytes, 1, fpDstFile);
 }

    fclose(fpDstFile);
    fclose(fpSrcFile);

 delete []pDataBuf;

    return 0;
}


void GenDisOrder(int iSendOrder[], int iPacketNum)
{
    int i, j, k, n, temp;

    for(i = 0; i < iPacketNum; i++)//先产生顺序的序列：0，1,2，.....iPacketNum-1
    {
     iSendOrder[i] = i;
    }

 if(iPacketNum < 5)
 {
  return;
 }

    n = rand() % (iPacketNum / 5) + 1; //置乱的次数，最多20%*2个数据包

    for(i = 0; i < n; i++)
    {
     //交换j、k两个数据包的顺序
        j = rand() % (iPacketNum / 2) + 1;
        k = rand() % (iPacketNum - j);
        temp = iSendOrder[j];
        iSendOrder[j] = iSendOrder[k];
        iSendOrder[k] = temp;
    }
}

基于内存缓冲区的流媒体数据缓存排序（二）

C++ 实验 基于内存缓冲区的流媒体数据缓存排序（二）

要求：

实现要求

缓冲区类

测试程序

C++ 实验
基于内存缓冲区的流媒体数据缓存排序（二）