Модуль УШ извлекает из всех КИ, участвующих в приеме и/или передаче речевого трафика, данные длительностью по 10 мс (определяется из информации управления кодированием/декодированием). Если в управляющей информации кодирования/декодирования для КИ установлен бит необходимости распознавания DTMF и акустических сигналов, модуль УШ выполняет распознавание этих сигналов (цифра DTMF, сигнал ЗАНЯТО и т.д.).

При наличии в канальном интервале тонального сигнала, речевые данные игнорируются до тех пор, пока не будет обнаружен конец передачи тонального сигнала.

Модули УШ преобразовывают речевые данные в формат в соответствии с управляющей информацией кодирования и помещают результат в соответствующую область данных. Байты речевых данных упорядочиваются в сетевом порядке.

Информация о распознанных тональных сигналах также записывается в соответствующую область памяти КИ для данных. При распознании сигнала (например, цифра DTMF, сигнал ЗАНЯТО), модуль УШ записывает данные распознанного сигнала в предназначенную для этого область памяти и устанавливает признак данных тонального сигнала в служебной информации. Так как поле длительности сигнала имеет размер в 2 байта, то максимальное значение длительности сигнала в единицах временной метки будет равно 64K, что соответствует 8,192 секундам. Поэтому, в случае, если сигнал длится более 8 секунд, модуль УШ устанавливает в служебной информации признак нового сигнала и продолжает отсчет длительности сначала.

Данные, формируемые модулем протокола RTP

Задание

Разработать отдельные функции для класса интерфейса между модулем кодирования/декодирования речевых данных (УШ) и модулем протокола RTP. В частности:

— основную потоковую функцию;

— функцию считывания закодированных модулем УШ данных, и помещения их в циклический буфер накопления;

— функцию предоставления данных из циклического буфера накопления по запросу другого потока;

— функцию помещения другим потоком данных в циклический буфер воспроизведения для последующей записи их для декодирования в модуль УШ;

— функцию записи в модуль УШ данных из циклического буфера воспроизведения.

Рис.1. Схема взаимодействия между модулем УШ и модулем протокола RTP

Модуль УШ и модуль протокола RTP входят в состав комплекса программ шлюза доступа IP.

Рис.2. Схема шлюза доступа IP

Модуль УШ и модуль протокола RTP - программы, работающие в разных процессорах Модуль УШ - в DSP процессоре. Модуль протокола RTP - в процессоре ARM или промышленном компьютере. Взаимодействие между модулями осуществляется через память, которая находится в DSP модулей УШ, при помощи интерфейса HPI (параллельный интерфейс). Операции чтения/записи выполняются посредством разработанных функций драйвера.

Основное назначение модуля УШ - кодирование/декодирование речевых данных. Модуль УШ обрабатывает речевые данные одного ИКМ (32 канальных интервала). Каждые 10 мс он кодирует входящий речевой поток тех каналов, которые ему задает модуль протокола RTP, и декодирует в обратном направлении. Используемые кодеки - G711, G726-16, G729.

Основное назначение модуля протокола RTP - упаковка закодированных речевых данных принятых из модуля УШ в пакеты RTP и отправка их в сеть IP, и, в обратном направлении - распаковка пакетов RTP, принятых из сети IP и предоставление данных для декодировании модулю УШ. Прием и запись речевых данных выполняется каждые 10 мс.

Реализация главного потока

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <iostream>

#include <cstdlib>

#include <sys/mman.h>

#include <errno.h>

#include "UH_interface.h"

#include "servis.h"

#include "thread.h"

using namespace std;

t_UHInterface *pUHInterface[2];

// основная функция потока интерфейса УШ

void * main_UHInterface(void *arg)

{

unsigned char n=*(unsigned char*)arg;

pUHInterface[n]->run();

return NULL;

}

int main(int argc, char *argv[])

{

int ierr, i,n;

// t_UHInterface *pUHInterface[2];

t_thread *pUHInterfaceThread[2];

timespec sleeptimer;

// ========= параметры вывода ============

// биты 7 6 5 4 3 2 1 0

// -----------------------

// |di|do| | | | | | |

// -----------------------

// di - данные, принимаемые из DSP2 модуля УШ

// do - данные, передаваемые в DSP2 модуля УШ

//параметры вывода на консоль по умолчанию

ParamPrint=0xc0;

// дополнительные параметры вывода

// для модуля УШ 0

ParamRtpPrint[DI]=0x00000001; // номеру бита установленному в 1 соответствует номер канала для вывода

ParamRtpPrint[DO]=0x00000001;

// для модуля УШ 1

ParamRtpPrint[DI+1]=0x00000001; // номеру бита установленному в 1 соответствует номер канала для вывода

ParamRtpPrint[DO+1]=0x00000001;

// это рекомендуется при использовании потоков реального времени

// locks all pages mapped into the address space of the calling

// process. This includes the pages of the code, data and stack segment,

// as well as shared libraries, user space kernel data, shared memory, and

// memory-mapped files. All mapped pages are guaranteed to be resident in

// RAM when the call returns successfully; the pages are guaranteed to

// stay in RAM until later unlocked.

if ((mlockall(MCL_CURRENT|MCL_FUTURE))==-1)

{

ierr=errno;

fprintf(stderr,"mlockall() error! :\n %s errno=%i\n",strerror(ierr),ierr);

}

// создать объекты интерфейсов c УШ

for (n=0;n<1;n++)

{

// 32 - тип ИКМ тракта подведенного к модулю УШ (на 32 канальных интервала, м.б. на 64)

pUHInterface[n]= new t_UHInterface(n,32);

if (!pUHInterface[n])

{

printf("t_RTPManager::Instance: Allocation memory error!\n");

exit(1);

}

}

// создать потоки интерфейсов c УШ

for (n=0;n<1;n++)

{

try

{

pUHInterface[n]->set_running(true);

i=n;

pUHInterfaceThread[n] = new t_thread(main_UHInterface,

(void*)&i,SCHED_FIFO,49);

// SCHED_FIFO - тип планировщика, обслуживание по очереди, среди имеющих один приоритет

// 49 -приоритет, приоритеты должны быть < 50, т.к. таймер имеет приоритет 50

}

catch (int err)

{

printf("!!UH Interface thread creating error, code = \n");

exit(1);

}

// сделать поток отсоединяемым.(он будет завершаться сам)

pUHInterfaceThread[n]->detach();

// задержать перед созданием следующего потока, чтобы предыдущий успел запуститься

sleeptimer.tv_sec = 0;

sleeptimer.tv_nsec = 500000000; // 500ms

nanosleep(&sleeptimer, NULL);

}

pUHInterface[0]->StartDataAccumulation(0);

char bc[5]={0};

while (1)

{

fgets(bc, sizeof(bc), stdin);

if (bc[0]=='*') break;

}

pUHInterface[0]->StopDataAccumulation(0);

for (n=0;n<1;n++)

{

pUHInterface[n]->stop();

delete(pUHInterfaceThread[n]);

delete(pUHInterface[n]);

}

munlockall();

return EXIT_SUCCESS;

}

Реализация класса для взаимодействия модуля протоколя RTP и модуля УШ

#include <stdlib.h>

#include <sys/time.h>

#include <iostream>

#include "api_6713b.h"

#include "UH_interface.h"

#include "servis.h"

#ifdef ___PC

#include "pcdata.h"

#endif

static const char cName[16]="/dev/drv6713b. ";

char * pcCodec []={"null","G.711","G.726-16","G729"};

const SLineCtrl t_UHInterface::m_vzeroLineCtrl[32] = { {{0},0,0,0},{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},

{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},

{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},

{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},

{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},{{0},0,0,0},

{{0},0,0,0},{{0},0,0,0},};

/**НАЗНАЧЕНИЕ : конструктор

* ВХОДНЫЕ ПАРАМЕТРЫ : ucUHNum - порядковый номер УШ (0-3),

* ucCINum - количество КИ в ИКМ

* ВЫХОДНЫЕ ПАРАМЕТРЫ: нет

*/

t_UHInterface::t_UHInterface(unsigned char ucUHNum, unsigned char ucCINum)

{

//unsigned char i;

int i;

#ifdef ___PC

m_ucI=0;

#endif

memcpy(m_cName, cName,sizeof(m_cName));

itoa(ucUHNum,(char*)(&m_cName[14]));

m_is_running=false;

m_bstop_running=false;

m_ucUHNum=ucUHNum;

m_ucCINum=ucCINum;

m_ucIndDI=DI+m_ucUHNum;

m_ucIndDO=DO+m_ucUHNum;

m_puiBaseAddress=(unsigned int*)(BASE_DATA_ADDRESS);

m_pvBaseDataCtrl=(SLineCtrl*)(m_puiBaseAddress+(CONF_SIZE>>2));

m_puiDumpNum=(unsigned int*)(m_pvBaseDataCtrl+64)+(sizeof(m_uiDumpNum)>>2);

m_puiBaseDataForRTP=m_puiDumpNum+(sizeof(m_uiDumpNum)>>2);

m_puiBaseDataForUH=m_puiBaseDataForRTP+(DUMP_SIZE*2>>2);

// глубина буфера воспроизведения

#ifdef ___PC

m_ucMaxPlayBackBufInd=JITTER_BUF_SIZE/10;

#else

m_ucMaxPlayBackBufInd=(JITTER_BUF_SIZE<<1)/10;// в два раза больше джиттер буфера

#endif

// буфер воспроизведения для записи

m_pvPlayBackBuf=new SData[m_ucMaxPlayBackBufInd<<5]; // буфер для всех 32 каналов

m_pvTmpPlayBackBuf=new SData[32];

// буфер для чтения данных речевого трафика из УШ

m_puiDataFromUH=new unsigned int[DUMP_SIZE>>2];

// буфер накопления данных речевого трафика, прочитанных из УШ для 32 КИ

m_pvAccumulatedData=new SData [ACCBUFF_DEPTH<<5];

if ( !m_pvPlayBackBuf || !m_pvAccumulatedData || !m_puiDataFromUH || !m_pvTmpPlayBackBuf )

{

printf("t_UHInterface::t_UHInterface: Allocation memory error!\n");

exit(1);

}

// проинициализировать буфер с управляющей информацией кодирования/декодирования

memset(m_vLineCtrl,0,sizeof(m_vLineCtrl));

// проинициализировать буфер с признаками изменения управляющей информации

// кодирования/декодирования

memset(m_uiChangeLineCtrl,0,sizeof(m_uiChangeLineCtrl));

// проинициализировать буфер с данными для УШ как отсутствие пакетов для всех КИ

// (тишина)

i=0;

while(i<=31)

{

ClearDataInPlayBackBuf(i++);

}

// обнулить буфер накопления данных речевого трафика

memset(m_pvAccumulatedData,0,ACCBUFF_DEPTH*32*sizeof(SData));

memset(m_iAccGetInd,0,sizeof(m_iAccGetInd));

memset(m_iAccPutInd,0,sizeof(m_iAccPutInd));

memset(m_iAccIndDelta,0,sizeof(m_iAccIndDelta));

// обнулить массив с признаками необходимости накопления данных речевого трафика для 32 КИ

memset(m_IsAccumulating,0,sizeof(m_IsAccumulating));

#ifndef ___PC

// дескриптор устройства

m_devd=dsp6713b_open(m_cName);

if (m_devd <0)

{

printf("!!t_UHInterface::run %i DSP2_open error, Res=%i, name=%s\n", m_ucUHNum,m_devd,m_cName);

exit(1);

}

#endif

}

/**НАЗНАЧЕНИЕ : деструктор

* ВХОДНЫЕ ПАРАМЕТРЫ : нет

* ВЫХОДНЫЕ ПАРАМЕТРЫ: нет

*/

t_UHInterface::~t_UHInterface()

{

delete [] m_puiDataFromUH;

delete [] m_pvAccumulatedData;

delete [] m_pvPlayBackBuf;

delete [] m_pvTmpPlayBackBuf;

}

/**НАЗНАЧЕНИЕ : установить признак выполнения потока агента УШ

* ВХОДНЫЕ ПАРАМЕТРЫ : brunnung - значение признака выполнения потока

* ВЫХОДНЫЕ ПАРАМЕТРЫ: нет

*/

void t_UHInterface::set_running(bool brunning)

{

m_is_running=brunning;

}

/**НАЗНАЧЕНИЕ : остановить поток агента УШ

* ВХОДНЫЕ ПАРАМЕТРЫ : нет

* ВЫХОДНЫЕ ПАРАМЕТРЫ: нет

*/

void t_UHInterface::stop(void)

{

timespec sleeptimer;

m_bstop_running=true;

while(m_is_running)

{

sleeptimer.tv_sec = 0;

sleeptimer.tv_nsec = 10000000; // 10 мс

nanosleep(&sleeptimer, NULL);

}

}

/**НАЗНАЧЕНИЕ: записать во внутреннюю память УШ данные конфигурации

* ВХОДНЫЕ ПАРАМЕТРЫ : ucCINum - количество КИ в ИКМ

* ВЫХОДНЫЕ ПАРАМЕТРЫ: нет

*/

void t_UHInterface::WriteConfToUH(unsigned char ucCINum)

{

unsigned int uiConf;

#ifndef ___PC

int ires;

#endif

uiConf=ucCINum;

uiConf<<=8;

uiConf|=m_ucUHNum;

if (p_DOUT)

{

printf("\n<<ConfToUH %i\n %08x < %08x\n\n",

m_ucUHNum, (unsigned int)m_puiBaseAddress,uiConf);

}

#ifndef ___PC

// записать данные в память УШ при помощи интерфейса HPI

if ((ires=(dsp6713b_write(m_devd,(unsigned int)m_puiBaseAddress, uiConf))))

{

dsp6713b_reset(m_devd);

dsp6713b_close(m_devd);

printf("\n!!t_UHInterface::WriteConfToUH %i: DSP2_write error!\n Addr=%08x Res=%i \n", m_ucUHNum,

(unsigned int)m_puiBaseAddress,ires);

exit(1);

}

#endif

}

/**НАЗНАЧЕНИЕ: задать накопление данных речевого трафика для КИ в буфере накопления

* ВХОДНЫЕ ПАРАМЕТРЫ : ucCI - номер канального интервала [0-31],

* ВЫХОДНЫЕ ПАРАМЕТРЫ: true - успешно

* false - ошибка: номер КИ > 31

*/

bool t_UHInterface::StartDataAccumulation(unsigned char ucCI)

{

if (ucCI >31) return (false);

mtx_AccumulatedData.lock();

m_IsAccumulating[ucCI]=true;

mtx_AccumulatedData.unlock();

return(true);

}

/**НАЗНАЧЕНИЕ : прекратить накопление данных речевого трафика для КИ в буфере

* накопления

* ВХОДНЫЕ ПАРАМЕТРЫ : ucCI - номер канального интервала [0-31],

* ВЫХОДНЫЕ ПАРАМЕТРЫ: true - успешно

* false - ошибка: номер КИ > 31

*/

bool t_UHInterface::StopDataAccumulation(unsigned char ucCI)

{

if (ucCI >31) return (false);

mtx_AccumulatedData.lock();

m_IsAccumulating[ucCI]=false;

// обнулить все индексы для циклических буферов

m_iAccGetInd[ucCI]=m_iAccPutInd[ucCI]=m_iAccIndDelta[ucCI]=

m_iPlayBackGetInd[ucCI]=m_iPlayBackPutInd[ucCI]=m_iPlayBackIndDelta[ucCI] = 0;

mtx_AccumulatedData.unlock();

return (true);

}

/**НАЗНАЧЕНИЕ: прочитать данные из внутренней памяти УШ и при необходимости

* поместить их в буфер накопления

* ВХОДНЫЕ ПАРАМЕТРЫ : нет

* ВЫХОДНЫЕ ПАРАМЕТРЫ: true - данные прочитаны,

* false - данные не прочитаны (в случае, если значение m_uiDumpNum

* некорректно)

*/

bool t_UHInterface::GetDataFromUH(void)

{

unsigned int *puiAddress;

unsigned int uiSize,k;

#ifndef ___PC

int ires;

#endif

int i,j,n,ii;

unsigned char * pucData;

char buf1 [400];

if (!(m_uiDumpNum&0x03)) return (false);

puiAddress=m_puiBaseDataForRTP;

if (m_uiDumpNum==2) puiAddress+=DUMP_SIZE>>2;

#ifdef ___PC

// имитируем прием данных

i=0;

j=4;

while(i<32)

{

if (m_IsAccumulating[i])

{

//CN-0,size-80

ucfromPCM0[j-4]=0x50;//20;

ucfromPCM0[j-1]=0;

k=0;

while (k<80)

{

ucfromPCM0[j+k++]= m_ucI;

}

}

j=(++i)*84+4;

}

if (m_ucI<255) m_ucI++; else m_ucI=0;

memcpy(m_puiDataFromUH,(unsigned int*)ucfromPCM0,DUMP_SIZE);

#else

// прочитать данные при помощи интерфейса HPI

if((ires=(dsp6713b_read_IS(m_devd, (unsigned int)puiAddress, m_puiDataFromUH, DUMP_SIZE))))

{

dsp6713b_reset(m_devd);

dsp6713b_close(m_devd);

printf("\n!!t_UHInterface::GetDataFromUH %i: DSP2_read_IS error!\n Addr=%08x Res=%i \n", m_ucUHNum,

(unsigned int)puiAddress,ires);

exit(1);

}

#endif

for(i=31; i>=0; i--)

{

mtx_AccumulatedData.lock();

if (m_IsAccumulating[i])

{

n=m_iAccPutInd[i]<<5;

// помещаем данные в буфер накопления

m_pvAccumulatedData[i+n]= *((SData*)(m_puiDataFromUH)+i);

m_iAccPutInd[i]++; // увеличиваем значение индекса для следующего помещения данных

if (m_iAccPutInd[i]==ACCBUFF_DEPTH) m_iAccPutInd[i]=0; // циклический переход в начало

m_iAccIndDelta[i]++; // увеличиваем расстояние по отношению к индексу для извлечения

if (m_iAccIndDelta[i] > ACCBUFF_DEPTH)

{

// фиксируем состояние переполнения буфера накопления

printf("Acc buf overflow for %i \n",i);

}

}

mtx_AccumulatedData.unlock();

}

if ((p_DIN) && (ParamRtpPrint[m_ucIndDI]))

{

snprintf(buf1,400,">>UH %i: %08x (%i)\n",m_ucUHNum,(unsigned int)puiAddress, m_uiDumpNum);

k=0x80000000;

for(i=31; i>=0; i--)

{

if (ParamRtpPrint[m_ucIndDI] & k)

{

uiSize=((SData*)(m_puiDataFromUH)+i)->m_vSDataCtrl.SpeachSize;

pucData=((SData*)(m_puiDataFromUH)+i)->m_ucData;

snprintf(buf1,400," [%i] : CN-%01x, tone-%02x, size-%i\n",i,

((SData*)(m_puiDataFromUH)+i)->m_vSDataCtrl.CN,

((SData*)(m_puiDataFromUH)+i)->m_vSDataCtrl.Tone, uiSize);

printf(buf1);

if (uiSize)

{

buf1[0]='\0';

for (ii=0,j=0, n=0; (j<MAX_SPEECH_SIZE) && (j<uiSize); j++,n++) //!!

{

snprintf(&buf1[ii],400," %02X", pucData[j]);

ii+=3;

if ((ii<399) && (n==30)) {n=0; buf1[ii++]='\n';}

}

printf(buf1);

}

}

k>>=1;

}

}

return(true);

}

/**НАЗНАЧЕНИЕ : поместить данные из буфера воспроизведения во внутреннюю память УШ

* ВХОДНЫЕ ПАРАМЕТРЫ : нет

* ВЫХОДНЫЕ ПАРАМЕТРЫ: true - данные записаны,

* false - данные не записаны (в случае, если значение m_uiDumpNum

* некорректно )

*/

bool t_UHInterface::PutDataToUH(void)

{

unsigned int *puiAddress;

#ifndef ___PC

int ires;

#endif

int i, ii, j, n;

unsigned int uiSize,k;

unsigned char * pucData;

#ifdef ___PC

int Interval;

timeval MyTimeBegin, MyTimeEnd, MyDurTime;

#endif

char buf1 [400];

//printf("===RTP: PutDataToUH\n");

if (!(m_uiDumpNum&0x03)) return(false);

puiAddress=m_puiBaseDataForUH;

if (m_uiDumpNum==2) puiAddress+=DUMP_SIZE>>2;

for (i=31; i>=0; i--)

{

mtx_PlayBackBuf.lock();

if (m_iPlayBackIndDelta[i] > m_ucMaxPlayBackBufInd) // переполнение

{

while (m_iPlayBackGetInd[i] != m_iPlayBackPutInd[i])

{

n=m_iPlayBackGetInd[i]<<5;

m_iPlayBackGetInd[i]++;

m_iPlayBackIndDelta[i]--;

// циклический переход в начало буфера

if (m_iPlayBackGetInd[i] == m_ucMaxPlayBackBufInd) m_iPlayBackGetInd[i]=0;

}

}

else // нет данных

if (m_iPlayBackIndDelta[i] == 0)

{

m_pvTmpPlayBackBuf[i].m_vSDataCtrl.SpeachSize=0;

m_pvTmpPlayBackBuf[i].m_vSDataCtrl.Tone=0;

m_pvTmpPlayBackBuf[i].m_vSDataCtrl.CN=1;

mtx_PlayBackBuf.unlock();

continue;

}

n=m_iPlayBackGetInd[i]<<5;

m_pvTmpPlayBackBuf[i]=m_pvPlayBackBuf[i+n];

m_iPlayBackGetInd[i]++;

m_iPlayBackIndDelta[i]--;

// циклический переход в начало буфера

if (m_iPlayBackGetInd[i] == m_ucMaxPlayBackBufInd) m_iPlayBackGetInd[i]=0;

mtx_PlayBackBuf.unlock();

}

#ifndef ___PC

// записать данные при помощи интерфейса HPI

// пишем при помощи промежуточного буфера, чтобы не задерживать блокировку m_pvPlayBackBuf на время записи в DSP

if ((ires=(dsp6713b_write_IS(m_devd,(unsigned int)puiAddress, m_pvTmpPlayBackBuf, DUMP_SIZE))))

{

dsp6713b_reset(m_devd);

dsp6713b_close(m_devd);

printf("\n!!t_UHInterface::PutDataToUH %i: DSP2_write_IS error!\n Addr=%08x Res=%i \n", m_ucUHNum,

(unsigned int)puiAddress,ires);

exit(1);

}

#endif

if ((p_DOUT) && (ParamRtpPrint[m_ucIndDO]))

{

printf("<<toUH %i: %08x(%i)\n",m_ucUHNum, (unsigned int)puiAddress,m_uiDumpNum);

//k=1;

k=0x80000000;

for(i=31;i>=0; i--)

{

if (ParamRtpPrint[m_ucIndDO] & k)

{

uiSize=(m_pvTmpPlayBackBuf+i)->m_vSDataCtrl.SpeachSize;

pucData=(m_pvTmpPlayBackBuf+i)->m_ucData;

printf(" [%i] : CN-%01x, tone-%02x, size-%i, newCtrl-%i\n",i,

(m_pvTmpPlayBackBuf+i)->m_vSDataCtrl.CN,

(m_pvTmpPlayBackBuf+i)->m_vSDataCtrl.Tone, uiSize,(m_pvTmpPlayBackBuf+i)->m_vSDataCtrl.NewLineCtrl);

if (uiSize)

{

buf1[0]='\0';

for (ii=0,j=0, n=0; (j<MAX_SPEECH_SIZE) && (j<uiSize); j++,n++)

{

snprintf(&buf1[ii],400," %02X", pucData[j]);

ii+=3;

if ((ii<399) && (n==30)) {n=0; buf1[ii++]='\n';}

}

printf(buf1);

}

}

k>>=1;

}

}

return (true);

}

/**НАЗНАЧЕНИЕ : поместить данные КИ в буфер воспроизведения

* ВХОДНЫЕ ПАРАМЕТРЫ : ucCI - номер канального интервала [0-31],

* vSData - данные,

* ВЫХОДНЫЕ ПАРАМЕТРЫ: sizeof(Sdata) - успешное выполнение,

* 0 - данные не помещенны, т.к. буфер воспроизведения пустой

*-1 - номер КИ > 31

*/

int t_UHInterface::PutDataToPlayBackBuf(unsigned char ucCI, SData &vSData)

{

int n;

// printf("===RTP: PutDataToPlayBackBuf\n");

if (ucCI >31) return (-1);

mtx_PlayBackBuf.lock();

n=m_iPlayBackPutInd[ucCI]<<5;

// помещаем данные в буфер накопления

m_pvPlayBackBuf[ucCI+n]= vSData;

m_iPlayBackPutInd[ucCI]++; // увеличиваем значение индекса для следующего помещения данных

if (m_iPlayBackPutInd[ucCI]==m_ucMaxPlayBackBufInd) m_iPlayBackPutInd[ucCI]=0; // циклический переход в начало

m_iPlayBackIndDelta[ucCI]++; // увеличиваем расстояние по отношению к индексу для извлечения

if (m_iPlayBackIndDelta[ucCI] > m_ucMaxPlayBackBufInd)

{

// фиксируем состояние переполнения буфера воспроизведения

printf("PlayBack buf overflow for %i \n",ucCI);

}

mtx_PlayBackBuf.unlock();

return (sizeof(SData));

}

/**НАЗНАЧЕНИЕ : очистить буфер воспроизведения для КИ

* ВХОДНЫЕ ПАРАМЕТРЫ : ucCI - номер канального интервала [0-31],

* ВЫХОДНЫЕ ПАРАМЕТРЫ: true - успешно

* false - ошибка: номер КИ > 31

*/

bool t_UHInterface::ClearDataInPlayBackBuf(unsigned char ucCI)

{

if (ucCI >31) return (false);

mtx_PlayBackBuf.lock();

m_pvTmpPlayBackBuf[ucCI].m_vSDataCtrl.SpeachSize=0;

m_pvTmpPlayBackBuf[ucCI].m_vSDataCtrl.Tone=0;

m_pvTmpPlayBackBuf[ucCI].m_vSDataCtrl.CN=1;

m_pvTmpPlayBackBuf[ucCI].m_vSDataCtrl.NewLineCtrl=0;

m_iPlayBackGetInd[ucCI]=0;

m_iPlayBackPutInd[ucCI]=0;

m_iPlayBackIndDelta[ucCI]=0;

mtx_PlayBackBuf.unlock();

return (true);

}

/**НАЗНАЧЕНИЕ : получить порцию данных из буфера накопления

* ВХОДНЫЕ ПАРАМЕТРЫ : ucCI - номер канального интервала,

* vSData - структура для помещения данных,

* ВЫХОДНЫЕ ПАРАМЕТРЫ: true - данные извлечены из буфера накопления,

* false - в буфере накопления нет данных

*/

bool t_UHInterface::GetAccumulatedData(unsigned char ucCI, SData &vSdata)

{

int n;

mtx_AccumulatedData.lock();

if (m_iAccIndDelta[ucCI] > ACCBUFF_DEPTH) // переполнение

{

while (m_iAccGetInd[ucCI] != m_iAccPutInd[ucCI])

{

m_iAccGetInd[ucCI]++;

m_iAccIndDelta[ucCI]--;

// циклический переход в начало буфера

if (m_iAccGetInd[ucCI] == ACCBUFF_DEPTH) m_iAccGetInd[ucCI]=0;

}

}

else // нет данных

if (m_iAccIndDelta[ucCI] == 0)

{

mtx_AccumulatedData.unlock();

return (false);

}

n=m_iAccGetInd[ucCI]<<5;

vSdata=m_pvAccumulatedData[ucCI+n];

m_iAccGetInd[ucCI]++;

m_iAccIndDelta[ucCI]--;

// циклический переход в начало буфера

if (m_iAccGetInd[ucCI] == ACCBUFF_DEPTH) m_iAccGetInd[ucCI]=0;

mtx_AccumulatedData.unlock();

return (true);

}

/**НАЗНАЧЕНИЕ : записать управляющую информацию кодирования/декодирования во

* внутреннюю память модуля УШ для тех КИ, у которых она изменилась

* ВХОДНЫЕ ПАРАМЕТРЫ : нет

* ВЫХОДНЫЕ ПАРАМЕТРЫ: нет

*/

void t_UHInterface::WriteLineCtrlToUH(void)

{

//unsigned char i;

int i;

unsigned int k;

#ifndef ___PC

int ires;

#endif

SLineCtrl *pvDataCtrl;

// прочитать из внутренней памяти УШ номер области памяти для

// считывания и записи данных модулем протокола RTP

#ifdef ___PC

m_uiDumpNum=1;

#else

// прочитать номер области памяти

if ((ires=(dsp6713b_read(m_devd,(unsigned int)m_puiDumpNum, &m_uiDumpNum))))

{

dsp6713b_reset(m_devd);

dsp6713b_close(m_devd);

printf("\n!!t_UHInterface::GetDumpNum %i: DSP2_read error!\n Addr=%08x Res=%i \n", m_ucUHNum,

(unsigned int)m_puiDumpNum,ires);

exit(1);

}

#endif

// printf("%i\n",m_uiDumpNum);

if (!(m_uiDumpNum&0x03))

{

printf("\n!!>>UH %i: DumpNum %08x > %08x\n",m_ucUHNum, (unsigned int)m_puiDumpNum,m_uiDumpNum);

return;

}

// выполнить запись управляющей информации (не взодит в задание)

}

/**НАЗНАЧЕНИЕ : очистить управляющую информацию всех КИ во внутренней памяти

* модуля УШ

* ВХОДНЫЕ ПАРАМЕТРЫ :

* ВЫХОДНЫЕ ПАРАМЕТРЫ: нет

*/

void t_UHInterface::ClearLineCtrlInUH(void)

{

unsigned int uiAddress1, uiAddress2;

#ifndef ___PC

int ires;

#endif

uiAddress1=uiAddress2=(unsigned int)m_pvBaseDataCtrl;// адрес области памяти #1

uiAddress2+=sizeof(m_vLineCtrl); // адрес области памяти #1

mtx_LineCtrl.lock();

memset(m_vLineCtrl,0,sizeof(m_vLineCtrl));

mtx_LineCtrl.unlock();

#ifndef ___PC

// m_vzeroLineCtrl используем, чтобы не задерживать блокировку m_vLineCtrl на время записи в DSP

if ((ires=(dsp6713b_write_IS(m_devd,uiAddress1, (void*)m_vzeroLineCtrl, sizeof(m_vzeroLineCtrl)))) ||

(ires=(dsp6713b_write_IS(m_devd,uiAddress2, (void*)m_vzeroLineCtrl, sizeof(m_vzeroLineCtrl)))) )

{

dsp6713b_reset(m_devd);

dsp6713b_close(m_devd);

printf("\n!!t_UHInterface::ClearLineCtrlInUH %i: DSP2_write_IS error!\n Addr=%08x Res=%i \n", m_ucUHNum,uiAddress1,ires);

exit(1);

}

#endif

}

/**НАЗНАЧЕНИЕ : запуск модуля УШ (инициализация модуля УШ и запуск программы в DSP)

* ВХОДНЫЕ ПАРАМЕТРЫ : нет

* ВЫХОДНЫЕ ПАРАМЕТРЫ: нет

*/

void t_UHInterface::StartWorkDSP2(void)

{

unsigned int uiConf;

unsigned int ii;

int i,ires;

timespec SleepTime;

#ifndef ___PC

// сбросить DSP модуля УШ

if((ires=(dsp6713b_reset(m_devd))))

{

dsp6713b_close(m_devd);

printf("!!t_UHInterface::StartWorkDSP2 %i DSP2_reset error, Res=%i\n", m_ucUHNum,ires);

exit(1);

}

// записать в УШ данные конфигурации

WriteConfToUH(m_ucCINum);

ClearLineCtrlInUH(); // обнулить управляющую информацию в памяти модуля УШ по всем КИ

// проинициализировать в УШ области памяти для данных

m_uiDumpNum=1;

PutDataToUH();

m_uiDumpNum=2;

PutDataToUH();

if ((ires=(dsp6713b_start(m_devd))))

{

dsp6713b_close(m_devd);

printf("!!t_UHInterface::StartWorkDSP2 %i DSP2_start error, Res=%i\n", m_ucUHNum,ires);

exit(1);

}

//! ждать готовность УШ

for (i=MAX_WAIT_READY; i>0; i--) // 10 раз = 100 ms

{

if((ires=(dsp6713b_read(m_devd,(unsigned int)m_puiBaseAddress, &uiConf))))

{

dsp6713b_reset(m_devd);

dsp6713b_close(m_devd);

printf("!!t_UHInterface::StartWorkDSP2 %i: DSP2_read error!\n Addr=%08x Res=%i \n",

m_ucUHNum,(unsigned int)m_puiBaseAddress,ires);

exit(1);

}

if ((uiConf & 0xC0) == 0xC0)

{

printf("UH %i is READY!\n",m_ucUHNum);

break;

}

}

if (i<=0)

{

printf("UH %i is NOT READY!\n", m_ucUHNum);

dsp6713b_reset(m_devd);

dsp6713b_close(m_devd);

exit(1);

}

#else

printf("UH %i is READY!\n",m_ucUHNum);

#endif

}

/**НАЗНАЧЕНИЕ : исполнительный метод потока интерфейса УШ

* ВХОДНЫЕ ПАРАМЕТРЫ : нет

* ВЫХОДНЫЕ ПАРАМЕТРЫ: нет

*/

void t_UHInterface::run(void)

{

#ifndef ___PC

unsigned int ii;

int ires;

#endif

timespec SleepTime;

printf("UH_Interface %i is started\n",m_ucUHNum);

// сбросить DSP и загрузить программу модуля УШ

StartWorkDSP2();

#ifndef ___PC

ires=dsp6713b_getHPIC(m_devd,&ii);

// работа с управляющими регистрами DSP

// сбросить HINT и установить DSPINT, чтобы DSP начал выставлять прерывания

ires=dsp6713b_setHPIC(m_devd,ii|0x00000002);

#endif

do

{

if (m_bstop_running) break;

#ifndef ___PC

dsp6713b_sleep(m_devd); // выход из этой функции происходит каждые 10 мс по прерыванию от DSP

// обработчик прерываний находится в драйвере, драйвер инициирует этот выход

#endif

// записать управляющую информацию,во внутреннюю память модуля УШ для тех КИ, у которых она изменилась

// (упр.информация меняется по запросу другого потока)

// // здесь же определяется номер области памяти для

// считывания и записи данных модулем протокола RTP

WriteLineCtrlToUH();

// прочитать данные из внутренней памяти УШ и при необходимости

// поместить их в буфер накопления

// здесь же определяется номер области памяти для

// считывания и записи данных модулем протокола RTP

GetDataFromUH();

//поместить данные из буфера воспроизведения во внутреннюю память УШ

PutDataToUH();

#ifdef ___PC

SleepTime.tv_sec = 0;

SleepTime.tv_nsec = 5000000;//5 мс

nanosleep(&SleepTime, NULL);

#endif

} while(1);

#ifndef ___PC

// сбросить DSP

if((ires=(dsp6713b_reset(m_devd))))

{

dsp6713b_close(m_devd);

printf("!!t_UHInterface::run %i DSP2_reset error, Res=%i\n", m_ucUHNum,ires);

exit(1);

}

else dsp6713b_close(m_devd);

printf("\n RTP: DSP device is closed\n");

#endif

printf("Агент UH: UHInterface % is stopped\n",m_ucUHNum);

m_is_running=false;

}

Заключение

В ходе выполнения задания в период прохождения производственной практики было проведено ознакомление с принципами организации и работы IP-телефонии, а также передачи голосового сигнала.

Были реализованы отдельные функции для класса интерфейса между модулем кодирования/декодирования речевых данных (УШ) и модулем протокола RTP. В частности:

· основная потоковая функция;

· функция считывания закодированных модулем УШ данных, и помещения их в циклический буфер накопления;

· функция предоставления данных из циклического буфера накопления по запросу другого потока;

· функция помещения другим потоком данных в циклический буфер воспроизведения для последующей записи их для декодирования в модуль УШ;

· функция записи в модуль УШ данных из циклического буфера воспроизведения.

Программный код был успешно протестирован и включен в интерфейс, обеспечивающий взаимодействие между модулем кодирования/декодирования речевых данных (УШ) и модулем протокола RTP.