S32 CNetObj::SndAvStream(S32 Times)
{
ADP::Msg_t Msg;
memset(&Msg, 0x00, sizeof(ADP::Msg_t));
Msg.Type = ADP::ADP_CMD_AV_FRAME;
Msg.RspId = m_MsgRspId++;
Msg.Body.pObj = m_pStream;
S32 rVal;
while (Times-- > 0 && m_bAvStreamSnd && m_bRuning)
{
rVal = SndMsg(Msg);
if (AV_STREAM_END_DATA == rVal)
{
Msg.Type = ADP::ADP_CMD_AV_EOF;
Msg.RspId = m_MsgRspId++;
Msg.Body.AvStreamEof.Token = m_Token;
SndMsg(Msg);
m_bAvStreamSnd = false;
break;
}
if (MW_SUCC != rVal )
{
break;
}
}
return Times;
}
ADP::RspStreamOpen_t CNetObj::Open(ADP::ReqStreamOpen_t Req, InitObjInfo_t Info, S32 mSec)
{
ADP::RspStreamOpen_t RspVal;
RspVal.rVal = m_Sock.SetClient(Req.URL);
if (RspVal.rVal != MW_SUCC)
{
DEBUG_ERROR("Connect err\n");
return RspVal;
}
m_ObjInitInfo = Info;
m_StrUrl = Req.URL;
m_bResetSock = false;
m_bRuning = true;
m_bSafeDelete = false;
m_tNetHandle = ::CreateNormalThread(NetThreadProc, this, 256 * 1024);
ADP::Msg_t Msg;
Msg.Type = ADP::ADP_CMD_REQ_STREAM_OPEN;
Msg.Body.ReqStreamOpen = Req;
Msg.RspId = m_MsgRspId++;
RspVal.rVal = SndMsg(Msg, mSec);
if (RspVal.rVal != MW_SUCC)
{
goto ERR_EXIT;
}
RspVal.rVal = RcvMsg(Msg, mSec);
if (RspVal.rVal != MW_SUCC)
{
RspVal.rVal = NET_MSG_TIME_OUT;
goto ERR_EXIT;
}
if (MW_SUCC != Msg.Body.RspStreamOpen.rVal)
{
Msg.Type = ADP::ADP_CMD_REQ_STREAM_OPEN;
Msg.Body.ReqStreamClose.Token = Msg.Body.RspStreamOpen.Token;
SndMsg(Msg, mSec);
RspVal.rVal = Msg.Body.RspStreamOpen.rVal;
goto ERR_EXIT;
}
return Msg.Body.RspStreamOpen;
ERR_EXIT:
m_Sock.ClearSock();
Stop();
return RspVal;
}
LRESULT CALLBACK ArgProc(HWND dlg,UINT msg,WPARAM wp,LPARAM lp){switch(msg){
case WM_INITDIALOG:
SndMsg(EDT_ARGS,WM_SETTEXT,0,itm[lp].arg);
SetFocus(GetDlgItem(dlg,EDT_ARGS));
break;
case WM_COMMAND:switch(HIWORD(wp)){
case BN_CLICKED:switch(LOWORD(wp)){
case BTN_OK:
arg=calloc(SndMsg(EDT_ARGS,WM_GETTEXTLENGTH,0,0),sizeof(char));
SndMsg(EDT_ARGS,WM_GETTEXT,0xFFFFFFFF,arg);
// free(arg); // Freed at the end of BtnProc:WM_LBUTTONUP
case BTN_CANCEL:EndDialog(dlg,LOWORD(wp));break;
}break;
}break;
}return 0;}
ADP::RspStreamClose_t CNetObj::Close(ADP::ReqStreamClose_t Req, S32 mSec)
{
m_bRuning = false;
m_bResetSock = false;
ADP::RspStreamClose_t RspVal;
ADP::Msg_t Msg;
Msg.Type = ADP::ADP_CMD_REQ_STREAM_CLOSE;
Msg.Body.ReqStreamClose = Req;
Msg.RspId = m_MsgRspId++;
RspVal.rVal = SndMsg(Msg, mSec);
if (RspVal.rVal != MW_SUCC)
{
DEBUG_ERROR("Snd msg err\n");
}
while (true)
{
if(m_bSafeDelete)
{
break;
}
Sleep(5);
}
//RspVal.rVal = RcvMsg(Msg, mSec);
//if (RspVal.rVal != MW_SUCC)
//{
// RspVal.rVal = NET_MSG_TIME_OUT;
// return RspVal;
//}
return RspVal;
}
ADP::RspStreamMode_t CNetObj::SetStreamMode(ADP::ReqStreamMode_t Req, S32 mSec)
{
ADP::RspStreamMode_t RspVal;
ADP::Msg_t Msg;
Msg.Type = ADP::ADP_CMD_REQ_STREAM_MODE;
Msg.Body.ReqStreamMode = Req;
Msg.RspId = m_MsgRspId++;
RspVal.rVal = SndMsg(Msg, mSec);
if (RspVal.rVal != MW_SUCC)
{
DEBUG_ERROR("Snd msg err\n");
return RspVal;
}
RspVal.rVal = RcvMsg(Msg, mSec);
if (RspVal.rVal != MW_SUCC)
{
RspVal.rVal = NET_MSG_TIME_OUT;
return RspVal;
}
return Msg.Body.RspStreamMode;
}
TInt CMessageQueue::RcvMsg(const RMessage2& aMessage)
{
long msgType = 0;
TPtr8 tptr((unsigned char*)&msgType, sizeof(long), sizeof(long));
aMessage.ReadL(1, tptr);
TBool msgFound = EFalse;
msg* tmsg = NULL;
msg* tprevMsg = NULL;
if ( !iMq_ds.msg_first )
{
//if there is no message in the Q
goto label1;
}
if ( !msgType )
{//return first message from Q;
//there will be at least one msg as we have
//checked for this in above if condition
//set tmsg to first msg
tmsg = iMq_ds.msg_first;
msgFound = ETrue;
}
else if ( msgType > 0 )
{// first message of msg type
tmsg = iMq_ds.msg_first;
msg* prev = NULL;
while (tmsg)
{
if ( tmsg->msg_type == msgType )
{
msgFound = ETrue;
tprevMsg = prev;
break;
}
prev = tmsg;
tmsg = tmsg->msg_next;
}
}
else
{//msgType is -ve
//smallet message which is of type< = |msgType|
msg* tmsg2 = iMq_ds.msg_first;
msg* prev = NULL;
// decrease it by one so that we can apply uniform
// algo, to find smallest type message which is less then this no
msgType--;
msgType = -msgType;
TInt lowestType = msgType;
while (tmsg2)
{
if ( tmsg2->msg_type < lowestType)
{
tprevMsg = prev;
tmsg = tmsg2;
lowestType = tmsg2->msg_type;
msgFound = ETrue;
}
prev = tmsg2;
tmsg2 = tmsg2->msg_next;
}
}
label1: if ( !msgFound )
{
if ( aMessage.Int2 ()& IPC_NOWAIT)
{
aMessage.Complete (ENOMSG);
return ETrue;
}
else
{
//put this request on the queue
if ( iExternal )
{
iReadWaitQ.Append (aMessage);
}
return EFalse;
}
}
else
{
TInt msgSize = aMessage.GetDesLengthL(1);
msgSize -= sizeof(long);
TInt asize = tmsg->msg_len;
if ( msgSize < tmsg->msg_len)
{
if ( aMessage.Int2() & MSG_NOERROR )
{//truncate to msgSize
tmsg->msg_len = msgSize;
}
else
{
aMessage.Complete(E2BIG);
return ETrue;
}
}
//update data struct
iMq_ds.msg_lrpid = IpcUtils::GetPid(aMessage);
iMq_ds.msg_qnum--;
iMq_ds.msg_rtime = IpcUtils::CurrentTimeL();
iMq_ds.msg_cbytes -= (asize + sizeof(long));
TPtr8 tptr( (unsigned char*)(tmsg->msg_data - sizeof(long)), tmsg->msg_len + sizeof(long), tmsg->msg_len + sizeof(long));
aMessage.WriteL (1, tptr);
aMessage.Complete (KErrNone);
if ( tprevMsg)
{
tprevMsg->msg_next = tmsg->msg_next;
// if this is last msg
if ( tmsg == iMq_ds.msg_last)
{
iMq_ds.msg_last = tprevMsg;
}
}
else
{//this is first msg
iMq_ds.msg_first = iMq_ds.msg_first->msg_next;
//if first is null them last must be null
if ( !iMq_ds.msg_first)
{
iMq_ds.msg_last = NULL;
}
}
delete tmsg;
//check if something is there on write Q
//complete requests as much as you can
TInt max = iWriteWaitQ.Count();
//todo if sndmsg is also succesful and it calls
//rcv again and that too successful then this for
//loop would be called again and this can go to a forever loop
//and we end up deleting a element many times
for (TInt i = 0; i < max; i++)
{
iExternal = EFalse;
if ( SndMsg(iWriteWaitQ[i]) )
{
iWriteWaitQ.Remove(i);
}
}
return ETrue;
}
}
S32 CNetObj::ParseData()
{
ADP::Msg_t Msg;
BOOL bGoOn = false;
//memset(&Msg, 0x00, sizeof(ADP::Msg_t));
Msg.Magic = ADP_MSG_MAGIC;
//DEBUG_INFO("parse socktag = %d func=%s line=%d\n", tag, __func__, __LINE__ );
do
{
bGoOn = m_pAdapter->Parser(Msg);
switch (Msg.Type)
{
case ADP::ADP_CMD_REQ_LOGIN:
Msg.Type = ADP::ADP_CMD_RSP_LOGIN;
Msg.Body.RspLogin.rVal = MW_SUCC;
Msg.Body.RspLogin.Token = GET_TICKS();
SndMsg(Msg);
break;
case ADP::ADP_CMD_RSP_LOGIN:
break;
case ADP::ADP_CMD_REQ_LOGOUT:
break;
case ADP::ADP_CMD_RSP_HEART_BEAT:
//
break;
case ADP::ADP_CMD_REQ_STREAM_OPEN:
m_StrUrl = Msg.Body.ReqStreamOpen.URL;
Msg.Body.RspStreamOpen.rVal = m_pStream->Open(GetUrl(m_StrUrl).c_str(), AV_STREAM_MODE);
if ( MW_SUCC != Msg.Body.RspStreamOpen.rVal )
{
m_pStream->Close();
Msg.Body.RspStreamOpen.rVal = NET_MSG_OPEN_FILE_ERR;
}
else
{
m_bAvStreamSnd = true;
// AudioHead_t a;
VideoHead_t v;
// m_pStream->GetAHead(a);
m_pStream->GetVHead(v);
// Msg.Body.RspStreamOpen.aSampleRate = a.SampleRate;
// Msg.Body.RspStreamOpen.aBitsPerSample = a.BitsPerSample;
Msg.Body.RspStreamOpen.vWidth = v.VWidth;
Msg.Body.RspStreamOpen.vHeight = v.VHeight;
Msg.Body.RspStreamOpen.vBitRate = v.VBitRate;
Msg.Body.RspStreamOpen.vFrameRate = v.VFrameRate;
Msg.Body.RspStreamOpen.Token = (m_Token = GET_TICKS());
Msg.Body.RspStreamOpen.Frames = m_pStream->GetFrames();
Msg.Body.RspStreamOpen.FrameIntValmSec = m_pStream->GetIntVal();
}
Msg.Type = ADP::ADP_CMD_RSP_STREAM_OPEN;
SndMsg(Msg);
break;
case ADP::ADP_CMD_REQ_STREAM_CLOSE:
m_bAvStreamSnd = false;
//Msg.Type = ADP::ADP_CMD_RSP_STREAM_CLOSE;
//Msg.Body.RspStreamClose.rVal = MW_SUCC;
//SndMsg(Msg);
m_pStream->Close();
Stop();
break;
case ADP::ADP_CMD_REQ_STREAM_SEEK:
Msg.Body.RspStreamSeek.rVal = m_pStream->Seek(Msg.Body.ReqStreamSeek.Offset);
Msg.Type = ADP::ADP_CMD_RSP_STREAM_SEEK;
SndMsg(Msg);
break;
case ADP::ADP_CMD_REQ_STREAM_MODE:
Msg.Body.RspStreamMode.rVal = m_pStream->SetRdMode(Msg.Body.ReqStreamMode.Mode);
Msg.Type = ADP::ADP_CMD_RSP_STREAM_MODE;
SndMsg(Msg);
break;
case ADP::ADP_CMD_AV_FRAME:
if (m_ObjInitInfo.AvFrameCb)
{
m_ObjInitInfo.AvFrameCb(Msg.Body.pFrame, m_ObjInitInfo.pAvFrameCbParam);
}
break;
case ADP::ADP_CMD_AV_EOF:
if (m_ObjInitInfo.MsgCb)
{
m_ObjInitInfo.MsgCb(Msg, m_ObjInitInfo.pMsgCbParam);
}
break;
case ADP::ADP_CMD_RSP_STREAM_OPEN:
case ADP::ADP_CMD_RSP_STREAM_CLOSE:
case ADP::ADP_CMD_RSP_STREAM_SEEK:
case ADP::ADP_CMD_RSP_STREAM_MODE:
PutMsg(Msg);
break;
default:
break;
}
m_RcvBuf.Update();
} while (bGoOn && m_bRuning);
return MW_SUCC;
}
