- make data member of the ast_frame struct a named union instead of a void
Recently the ast_queue_hangup function got a new parameter, the hangupcause
Feedback came in that this is no good and that instead a new function should be created.
This I did.
The hangupcause was stored in the seqno member of the ast_frame struct. This is not very
elegant, and since there's already a data member that one should be used.
Problem is, this member was a void *.
Now it's a named union so it can hold a pointer, an uint32 and there's a padding in case someone
wants to store another type in there in the future.
This commit is so massive, because all ast_frame.data uses have to be
altered to ast_frame.data.data
Thanks russellb and kpfleming for the feedback.
(closes issue #12674)
Reported by: mvanbaak
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@117802
65c4cc65-6c06-0410-ace0-
fbb531ad65f3
76 files changed:
wf.subclass = AST_FORMAT_ULAW;
wf.offset = AST_FRIENDLY_OFFSET;
wf.mallocd = 0;
wf.subclass = AST_FORMAT_ULAW;
wf.offset = AST_FRIENDLY_OFFSET;
wf.mallocd = 0;
- wf.data = tone_block.buf;
+ wf.data.ptr = tone_block.buf;
wf.datalen = f->datalen;
wf.samples = wf.datalen;
wf.datalen = f->datalen;
wf.samples = wf.datalen;
/* If they hung up, leave */
if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP)) {
/* If they hung up, leave */
if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP)) {
- if (f->seqno) {
- chan->hangupcause = f->seqno;
+ if (f->data.uint32) {
+ chan->hangupcause = f->data.uint32;
}
ast_frfree(f);
res = -1;
}
ast_frfree(f);
res = -1;
- write(csth->fd, f->data, f->datalen);
+ write(csth->fd, f->data.ptr, f->datalen);
}
break;
case AST_FRAME_HTML:
}
break;
case AST_FRAME_HTML:
- if (!ast_test_flag64(outgoing, DIAL_NOFORWARDHTML) && ast_channel_sendhtml(in, f->subclass, f->data, f->datalen) == -1) {
+ if (!ast_test_flag64(outgoing, DIAL_NOFORWARDHTML) && ast_channel_sendhtml(in, f->subclass, f->data.ptr, f->datalen) == -1) {
ast_log(LOG_WARNING, "Unable to send URL\n");
}
break;
ast_log(LOG_WARNING, "Unable to send URL\n");
}
break;
strcpy(pa->status, "CANCEL");
ast_cdr_noanswer(in->cdr);
if (f) {
strcpy(pa->status, "CANCEL");
ast_cdr_noanswer(in->cdr);
if (f) {
- if (f->seqno)
- in->hangupcause = f->seqno;
+ if (f->data.uint32) {
+ in->hangupcause = f->data.uint32;
+ }
ast_frfree(f);
}
return NULL;
ast_frfree(f);
}
return NULL;
/* Forward HTML stuff */
if (single && (f->frametype == AST_FRAME_HTML) && !ast_test_flag64(outgoing, DIAL_NOFORWARDHTML))
/* Forward HTML stuff */
if (single && (f->frametype == AST_FRAME_HTML) && !ast_test_flag64(outgoing, DIAL_NOFORWARDHTML))
- if (ast_channel_sendhtml(outgoing->chan, f->subclass, f->data, f->datalen) == -1)
+ if (ast_channel_sendhtml(outgoing->chan, f->subclass, f->data.ptr, f->datalen) == -1)
ast_log(LOG_WARNING, "Unable to send URL\n");
if (single && ((f->frametype == AST_FRAME_VOICE) || (f->frametype == AST_FRAME_DTMF_BEGIN) || (f->frametype == AST_FRAME_DTMF_END))) {
ast_log(LOG_WARNING, "Unable to send URL\n");
if (single && ((f->frametype == AST_FRAME_VOICE) || (f->frametype == AST_FRAME_DTMF_BEGIN) || (f->frametype == AST_FRAME_DTMF_END))) {
(f->subclass == AST_CONTROL_VIDUPDATE) ||
(f->subclass == AST_CONTROL_SRCUPDATE))) {
ast_verb(3, "%s requested special control %d, passing it to %s\n", in->name, f->subclass, outgoing->chan->name);
(f->subclass == AST_CONTROL_VIDUPDATE) ||
(f->subclass == AST_CONTROL_SRCUPDATE))) {
ast_verb(3, "%s requested special control %d, passing it to %s\n", in->name, f->subclass, outgoing->chan->name);
- ast_indicate_data(outgoing->chan, f->subclass, f->data, f->datalen);
+ ast_indicate_data(outgoing->chan, f->subclass, f->data.ptr, f->datalen);
}
if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP)) {
}
if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP)) {
- if (f->seqno)
- chan->hangupcause = f->seqno;
+ if (f->data.uint32)
+ chan->hangupcause = f->data.uint32;
ast_frfree(f);
ast_clear_flag(chan, AST_FLAG_END_DTMF_ONLY);
return -1;
ast_frfree(f);
ast_clear_flag(chan, AST_FLAG_END_DTMF_ONLY);
return -1;
} else if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP)) {
ast_chan_log(LOG_NOTICE, chan, "Got AST_CONTROL_HANGUP\n");
send_eivr_event(eivr_events, 'H', NULL, chan);
} else if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP)) {
ast_chan_log(LOG_NOTICE, chan, "Got AST_CONTROL_HANGUP\n");
send_eivr_event(eivr_events, 'H', NULL, chan);
- if (f->seqno) {
- chan->hangupcause = f->seqno;
+ if (f->data.uint32) {
+ chan->hangupcause = f->data.uint32;
}
ast_frfree(f);
res = -1;
}
ast_frfree(f);
res = -1;
myf.f.samples = res / 2;
myf.f.offset = AST_FRIENDLY_OFFSET;
myf.f.src = __PRETTY_FUNCTION__;
myf.f.samples = res / 2;
myf.f.offset = AST_FRIENDLY_OFFSET;
myf.f.src = __PRETTY_FUNCTION__;
- myf.f.data = myf.frdata;
+ myf.f.data.ptr = myf.frdata;
if (ast_write(chan, &myf.f) < 0) {
res = -1;
ast_frfree(f);
if (ast_write(chan, &myf.f) < 0) {
res = -1;
ast_frfree(f);
switch(f->subclass) {
case AST_CONTROL_HANGUP:
ast_verb(3, "%s received a hangup frame.\n", winner->name);
switch(f->subclass) {
case AST_CONTROL_HANGUP:
ast_verb(3, "%s received a hangup frame.\n", winner->name);
- if (f->seqno) {
- winner->hangupcause = f->seqno;
+ if (f->data.uint32) {
+ winner->hangupcause = f->data.uint32;
}
if (dg == 0) {
ast_verb(3, "The calling channel hungup. Need to drop everyone else.\n");
}
if (dg == 0) {
ast_verb(3, "The calling channel hungup. Need to drop everyone else.\n");
break;
}
if (f->frametype == AST_FRAME_VOICE) {
break;
}
if (f->frametype == AST_FRAME_VOICE) {
- res = write(fds[1], f->data, f->datalen);
+ res = write(fds[1], f->data.ptr, f->datalen);
if (res < 0) {
if (errno != EAGAIN) {
ast_log(LOG_WARNING, "Write failed to pipe: %s\n", strerror(errno));
if (res < 0) {
if (errno != EAGAIN) {
ast_log(LOG_WARNING, "Write failed to pipe: %s\n", strerror(errno));
to write out all the samples.
*/
if (user->talking)
to write out all the samples.
*/
if (user->talking)
- careful_write(fd, f->data, f->datalen, 0);
+ careful_write(fd, f->data.ptr, f->datalen, 0);
}
} else if ((f->frametype == AST_FRAME_DTMF) && (confflags & CONFFLAG_EXIT_CONTEXT)) {
char tmp[2];
}
} else if ((f->frametype == AST_FRAME_DTMF) && (confflags & CONFFLAG_EXIT_CONTEXT)) {
char tmp[2];
fr.subclass = AST_FORMAT_SLINEAR;
fr.datalen = res;
fr.samples = res / 2;
fr.subclass = AST_FORMAT_SLINEAR;
fr.datalen = res;
fr.samples = res / 2;
fr.offset = AST_FRIENDLY_OFFSET;
if (!user->listen.actual &&
((confflags & CONFFLAG_MONITOR) ||
fr.offset = AST_FRIENDLY_OFFSET;
if (!user->listen.actual &&
((confflags & CONFFLAG_MONITOR) ||
.frametype = AST_FRAME_VOICE,
.subclass = AST_FORMAT_ULAW,
.offset = AST_FRIENDLY_OFFSET,
.frametype = AST_FRAME_VOICE,
.subclass = AST_FORMAT_ULAW,
.offset = AST_FRIENDLY_OFFSET,
- .data = buf + AST_FRIENDLY_OFFSET,
+ wf.data.ptr = buf + AST_FRIENDLY_OFFSET;
/* Instead of len, use samples, because channel.c generator_force
* generate(chan, tmp, 0, 160) ignores len. In any case, len is
/* Instead of len, use samples, because channel.c generator_force
* generate(chan, tmp, 0, 160) ignores len. In any case, len is
myf.f.src = __PRETTY_FUNCTION__;
myf.f.delivery.tv_sec = 0;
myf.f.delivery.tv_usec = 0;
myf.f.src = __PRETTY_FUNCTION__;
myf.f.delivery.tv_sec = 0;
myf.f.delivery.tv_usec = 0;
- myf.f.data = myf.frdata;
+ myf.f.data.ptr = myf.frdata;
if (ast_write(chan, &myf.f) < 0) {
res = -1;
break;
if (ast_write(chan, &myf.f) < 0) {
res = -1;
break;
myf.f.src = __PRETTY_FUNCTION__;
myf.f.delivery.tv_sec = 0;
myf.f.delivery.tv_usec = 0;
myf.f.src = __PRETTY_FUNCTION__;
myf.f.delivery.tv_sec = 0;
myf.f.delivery.tv_usec = 0;
- myf.f.data = myf.frdata;
+ myf.f.data.ptr = myf.frdata;
if (ast_write(chan, &myf.f) < 0) {
res = -1;
break;
if (ast_write(chan, &myf.f) < 0) {
res = -1;
break;
/* Got hung up */
*to = -1;
if (f) {
/* Got hung up */
*to = -1;
if (f) {
- if (f->seqno)
- in->hangupcause = f->seqno;
+ if (f->data.uint32) {
+ in->hangupcause = f->data.uint32;
+ }
ast_frfree(f);
}
return NULL;
ast_frfree(f);
}
return NULL;
f.datalen = samples * sizeof(*buf);
f.offset = AST_FRIENDLY_OFFSET;
f.mallocd = 0;
f.datalen = samples * sizeof(*buf);
f.offset = AST_FRIENDLY_OFFSET;
f.mallocd = 0;
f.samples = samples;
f.src = "app_sms";
/* create a buffer containing the digital sms pattern */
f.samples = samples;
f.src = "app_sms";
/* create a buffer containing the digital sms pattern */
break;
}
if (f->frametype == AST_FRAME_VOICE) {
break;
}
if (f->frametype == AST_FRAME_VOICE) {
- sms_process(&h, f->samples, f->data);
+ sms_process(&h, f->samples, f->data.ptr);
}
/* Write audio frame out to speech engine if no DTMF has been received */
if (!strlen(dtmf) && f != NULL && f->frametype == AST_FRAME_VOICE) {
}
/* Write audio frame out to speech engine if no DTMF has been received */
if (!strlen(dtmf) && f != NULL && f->frametype == AST_FRAME_VOICE) {
- ast_speech_write(speech, f->data, f->datalen);
+ ast_speech_write(speech, f->data.ptr, f->datalen);
}
break;
case AST_SPEECH_STATE_WAIT:
}
break;
case AST_SPEECH_STATE_WAIT:
break;
}
if ((f->frametype == AST_FRAME_VOICE) && (f->subclass == AST_FORMAT_SLINEAR)) {
break;
}
if ((f->frametype == AST_FRAME_VOICE) && (f->subclass == AST_FORMAT_SLINEAR)) {
- foo = (short *)f->data;
+ foo = (short *)f->data.ptr;
for (x=0;x<f->samples;x++) {
noise += abs(foo[x]);
samples++;
for (x=0;x<f->samples;x++) {
noise += abs(foo[x]);
samples++;
if (f->frametype == AST_FRAME_VOICE) {
if (f->subclass == AST_FORMAT_ULAW) {
/* Carefully write */
if (f->frametype == AST_FRAME_VOICE) {
if (f->subclass == AST_FORMAT_ULAW) {
/* Carefully write */
- careful_write(fd, f->data, f->datalen);
+ careful_write(fd, f->data.ptr, f->datalen);
} else
ast_log(LOG_WARNING, "Huh? Got a non-ulaw (%d) frame in the conference\n", f->subclass);
}
} else
ast_log(LOG_WARNING, "Huh? Got a non-ulaw (%d) frame in the conference\n", f->subclass);
}
fr.subclass = AST_FORMAT_ULAW;
fr.datalen = res;
fr.samples = res;
fr.subclass = AST_FORMAT_ULAW;
fr.datalen = res;
fr.samples = res;
fr.offset = AST_FRIENDLY_OFFSET;
if (ast_write(chan, &fr) < 0) {
ast_log(LOG_WARNING, "Unable to write frame to channel: %s\n", strerror(errno));
fr.offset = AST_FRIENDLY_OFFSET;
if (ast_write(chan, &fr) < 0) {
ast_log(LOG_WARNING, "Unable to write frame to channel: %s\n", strerror(errno));
if (f->frametype == AST_FRAME_VOICE) {
if (f->subclass == AST_FORMAT_ULAW) {
/* Carefully write */
if (f->frametype == AST_FRAME_VOICE) {
if (f->subclass == AST_FORMAT_ULAW) {
/* Carefully write */
- careful_write(fd, f->data, f->datalen);
+ careful_write(fd, f->data.ptr, f->datalen);
} else {
ast_log(LOG_WARNING, "Huh? Got a non-ulaw (%d) frame in the conference\n", f->subclass);
}
} else {
ast_log(LOG_WARNING, "Huh? Got a non-ulaw (%d) frame in the conference\n", f->subclass);
}
fr.subclass = AST_FORMAT_ULAW;
fr.datalen = res;
fr.samples = res;
fr.subclass = AST_FORMAT_ULAW;
fr.datalen = res;
fr.samples = res;
fr.offset = AST_FRIENDLY_OFFSET;
if (ast_write(chan, &fr) < 0) {
ast_log(LOG_WARNING, "Unable to write frame to channel: %s\n", strerror(errno));
fr.offset = AST_FRIENDLY_OFFSET;
if (ast_write(chan, &fr) < 0) {
ast_log(LOG_WARNING, "Unable to write frame to channel: %s\n", strerror(errno));
ast_log(LOG_WARNING, "Frame too large\n");
res = -1;
} else {
ast_log(LOG_WARNING, "Frame too large\n");
res = -1;
} else {
- memcpy(sizbuf + sizpos, f->data, f->datalen);
+ memcpy(sizbuf + sizpos, f->data.ptr, f->datalen);
len += f->datalen;
pos = 0;
state = snd_pcm_state(alsa.ocard);
len += f->datalen;
pos = 0;
state = snd_pcm_state(alsa.ocard);
f.subclass = 0;
f.samples = 0;
f.datalen = 0;
f.subclass = 0;
f.samples = 0;
f.datalen = 0;
f.offset = 0;
f.src = "Console";
f.mallocd = 0;
f.offset = 0;
f.src = "Console";
f.mallocd = 0;
f.subclass = AST_FORMAT_SLINEAR;
f.samples = FRAME_SIZE;
f.datalen = FRAME_SIZE * 2;
f.subclass = AST_FORMAT_SLINEAR;
f.samples = FRAME_SIZE;
f.datalen = FRAME_SIZE * 2;
f.offset = AST_FRIENDLY_OFFSET;
f.src = "Console";
f.mallocd = 0;
f.offset = AST_FRIENDLY_OFFSET;
f.src = "Console";
f.mallocd = 0;
}
text2send[strlen(text2send) - 1] = '\n';
}
text2send[strlen(text2send) - 1] = '\n';
+ f.data.ptr = text2send;
f.datalen = strlen(text2send) + 1;
grab_owner();
if (alsa.owner) {
ast_queue_frame(alsa.owner, &f);
f.frametype = AST_FRAME_CONTROL;
f.subclass = AST_CONTROL_ANSWER;
f.datalen = strlen(text2send) + 1;
grab_owner();
if (alsa.owner) {
ast_queue_frame(alsa.owner, &f);
f.frametype = AST_FRAME_CONTROL;
f.subclass = AST_CONTROL_ANSWER;
f.datalen = 0;
ast_queue_frame(alsa.owner, &f);
ast_channel_unlock(alsa.owner);
f.datalen = 0;
ast_queue_frame(alsa.owner, &f);
ast_channel_unlock(alsa.owner);
hookstate = 0;
grab_owner();
if (alsa.owner) {
hookstate = 0;
grab_owner();
if (alsa.owner) {
- ast_queue_hangup(alsa.owner, AST_CAUSE_NORMAL_CLEARING);
+ ast_queue_hangup_with_cause(alsa.owner, AST_CAUSE_NORMAL_CLEARING);
ast_channel_unlock(alsa.owner);
}
}
ast_channel_unlock(alsa.owner);
}
}
pvt->hookstate = 0;
if (pvt->owner)
pvt->hookstate = 0;
if (pvt->owner)
- ast_queue_hangup(pvt->owner, -1);
+ ast_queue_hangup(pvt->owner);
ast_getformatname_multiple(s2, BUFSIZ, tmp->peercapability),
ast_getformatname_multiple(s3, BUFSIZ, tmp->jointcapability));
/* close session if capabilities don't match */
ast_getformatname_multiple(s2, BUFSIZ, tmp->peercapability),
ast_getformatname_multiple(s3, BUFSIZ, tmp->jointcapability));
/* close session if capabilities don't match */
- ast_queue_hangup(tmp->owner, -1);
+ ast_queue_hangup(tmp->owner);
if (tmp) {
tmp->alreadygone = 1;
if (tmp->owner)
if (tmp) {
tmp->alreadygone = 1;
if (tmp->owner)
- ast_queue_hangup(tmp->owner, -1);
+ ast_queue_hangup(tmp->owner);
} else
ast_log(LOG_NOTICE, "Whoa, didn't find call!\n");
gtalk_response(client, from, pak, NULL, NULL);
} else
ast_log(LOG_NOTICE, "Whoa, didn't find call!\n");
gtalk_response(client, from, pak, NULL, NULL);
ast_debug(1, "Process pending hangup for %s\n", c->name);
c->_softhangup |= AST_SOFTHANGUP_DEV;
c->hangupcause = pvt->hangupcause;
ast_debug(1, "Process pending hangup for %s\n", c->name);
c->_softhangup |= AST_SOFTHANGUP_DEV;
c->hangupcause = pvt->hangupcause;
- ast_queue_hangup(c, pvt->hangupcause);
+ ast_queue_hangup_with_cause(c, pvt->hangupcause);
pvt->needhangup = 0;
pvt->newstate = pvt->newcontrol = pvt->newdigit = pvt->DTMFsched = -1;
}
pvt->needhangup = 0;
pvt->newstate = pvt->newcontrol = pvt->newdigit = pvt->DTMFsched = -1;
}
/* Send hangup */
if (pvt->owner) {
pvt->owner->_softhangup |= AST_SOFTHANGUP_DEV;
/* Send hangup */
if (pvt->owner) {
pvt->owner->_softhangup |= AST_SOFTHANGUP_DEV;
- ast_queue_hangup(pvt->owner, -1);
+ ast_queue_hangup(pvt->owner);
ast_channel_unlock(pvt->owner);
}
ast_mutex_unlock(&pvt->lock);
ast_channel_unlock(pvt->owner);
}
ast_mutex_unlock(&pvt->lock);
if (pvt->owner && !ast_channel_trylock(pvt->owner)) {
pvt->owner->_softhangup |= AST_SOFTHANGUP_DEV;
pvt->owner->hangupcause = pvt->hangupcause = cause;
if (pvt->owner && !ast_channel_trylock(pvt->owner)) {
pvt->owner->_softhangup |= AST_SOFTHANGUP_DEV;
pvt->owner->hangupcause = pvt->hangupcause = cause;
- ast_queue_hangup(pvt->owner, cause);
+ ast_queue_hangup_with_cause(pvt->owner, cause);
ast_channel_unlock(pvt->owner);
}
else {
ast_channel_unlock(pvt->owner);
}
else {
usleep(1);
ast_mutex_lock(&iaxsl[callno]);
} else {
usleep(1);
ast_mutex_lock(&iaxsl[callno]);
} else {
- ast_queue_hangup(iaxs[callno]->owner, -1);
+ ast_queue_hangup(iaxs[callno]->owner);
ast_channel_unlock(iaxs[callno]->owner);
break;
}
ast_channel_unlock(iaxs[callno]->owner);
break;
}
/* If there's an owner, prod it to give up */
/* It is ok to use ast_queue_hangup() here instead of iax2_queue_hangup()
* because we already hold the owner channel lock. */
/* If there's an owner, prod it to give up */
/* It is ok to use ast_queue_hangup() here instead of iax2_queue_hangup()
* because we already hold the owner channel lock. */
- ast_queue_hangup(owner, -1);
+ ast_queue_hangup(owner);
ast_log(LOG_WARNING, "Max retries exceeded to host %s on %s (type = %d, subclass = %d, ts=%d, seqno=%d)\n", ast_inet_ntoa(iaxs[f->callno]->addr.sin_addr),iaxs[f->callno]->owner->name , f->af.frametype, f->af.subclass, f->ts, f->oseqno);
iaxs[callno]->error = ETIMEDOUT;
if (iaxs[callno]->owner) {
ast_log(LOG_WARNING, "Max retries exceeded to host %s on %s (type = %d, subclass = %d, ts=%d, seqno=%d)\n", ast_inet_ntoa(iaxs[f->callno]->addr.sin_addr),iaxs[f->callno]->owner->name , f->af.frametype, f->af.subclass, f->ts, f->oseqno);
iaxs[callno]->error = ETIMEDOUT;
if (iaxs[callno]->owner) {
- struct ast_frame fr = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP, .seqno = AST_CAUSE_DESTINATION_OUT_OF_ORDER };
+ struct ast_frame fr = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP, .data.uint32 = AST_CAUSE_DESTINATION_OUT_OF_ORDER };
/* Hangup the fd */
iax2_queue_frame(callno, &fr); /* XXX */
/* Remember, owner could disappear */
/* Hangup the fd */
iax2_queue_frame(callno, &fr); /* XXX */
/* Remember, owner could disappear */
static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img)
{
static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img)
{
- return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_IMAGE, img->subclass, 0, img->data, img->datalen, -1);
+ return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_IMAGE, img->subclass, 0, img->data.ptr, img->datalen, -1);
}
static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen)
}
static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen)
tpeer->trunkdatalen += sizeof(struct ast_iax2_meta_trunk_entry);
}
/* Copy actual trunk data */
tpeer->trunkdatalen += sizeof(struct ast_iax2_meta_trunk_entry);
}
/* Copy actual trunk data */
- memcpy(ptr, f->data, f->datalen);
+ memcpy(ptr, f->data.ptr, f->datalen);
tpeer->trunkdatalen += f->datalen;
tpeer->calls++;
tpeer->trunkdatalen += f->datalen;
tpeer->calls++;
else
fr->oseqno = pvt->oseqno++;
fr->iseqno = pvt->iseqno;
else
fr->oseqno = pvt->oseqno++;
fr->iseqno = pvt->iseqno;
- fh = (struct ast_iax2_full_hdr *)(fr->af.data - sizeof(struct ast_iax2_full_hdr));
+ fh = (struct ast_iax2_full_hdr *)(fr->af.data.ptr - sizeof(struct ast_iax2_full_hdr));
fh->scallno = htons(fr->callno | IAX_FLAG_FULL);
fh->ts = htonl(fr->ts);
fh->oseqno = fr->oseqno;
fh->scallno = htons(fr->callno | IAX_FLAG_FULL);
fh->ts = htonl(fr->ts);
fh->oseqno = fr->oseqno;
/* Video frame have no sequence number */
fr->oseqno = -1;
fr->iseqno = -1;
/* Video frame have no sequence number */
fr->oseqno = -1;
fr->iseqno = -1;
- vh = (struct ast_iax2_video_hdr *)(fr->af.data - sizeof(struct ast_iax2_video_hdr));
+ vh = (struct ast_iax2_video_hdr *)(fr->af.data.ptr - sizeof(struct ast_iax2_video_hdr));
vh->zeros = 0;
vh->callno = htons(0x8000 | fr->callno);
vh->ts = htons((fr->ts & 0x7FFF) | (fr->af.subclass & 0x1 ? 0x8000 : 0));
vh->zeros = 0;
vh->callno = htons(0x8000 | fr->callno);
vh->ts = htons((fr->ts & 0x7FFF) | (fr->af.subclass & 0x1 ? 0x8000 : 0));
fr->oseqno = -1;
fr->iseqno = -1;
/* Mini frame will do */
fr->oseqno = -1;
fr->iseqno = -1;
/* Mini frame will do */
- mh = (struct ast_iax2_mini_hdr *)(fr->af.data - sizeof(struct ast_iax2_mini_hdr));
+ mh = (struct ast_iax2_mini_hdr *)(fr->af.data.ptr - sizeof(struct ast_iax2_mini_hdr));
mh->callno = htons(fr->callno);
mh->ts = htons(fr->ts & 0xFFFF);
fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_mini_hdr);
mh->callno = htons(fr->callno);
mh->ts = htons(fr->ts & 0xFFFF);
fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_mini_hdr);
f.subclass = command;
f.datalen = datalen;
f.src = __FUNCTION__;
f.subclass = command;
f.datalen = datalen;
f.src = __FUNCTION__;
- f.data = (void *) data;
+ f.data.ptr = (void *) data;
return iax2_send(i, &f, ts, seqno, now, transfer, final, media);
}
return iax2_send(i, &f, ts, seqno, now, transfer, final, media);
}
f.datalen = len;
if (f.datalen >= 0) {
if (f.datalen)
f.datalen = len;
if (f.datalen >= 0) {
if (f.datalen)
if (trunked_ts)
fr->ts = (iaxs[fr->callno]->last & 0xFFFF0000L) | (trunked_ts & 0xffff);
else
if (trunked_ts)
fr->ts = (iaxs[fr->callno]->last & 0xFFFF0000L) | (trunked_ts & 0xffff);
else
ast_mutex_unlock(&iaxsl[fr->callno]);
return 1;
}
ast_mutex_unlock(&iaxsl[fr->callno]);
return 1;
}
- f.data = thread->buf + sizeof(*fh);
+ f.data.ptr = thread->buf + sizeof(*fh);
} else {
if (f.frametype == AST_FRAME_IAX)
} else {
if (f.frametype == AST_FRAME_IAX)
memset(&ies, 0, sizeof(ies));
}
memset(&ies, 0, sizeof(ies));
}
}
f.datalen = res - sizeof(*vh);
if (f.datalen)
}
f.datalen = res - sizeof(*vh);
if (f.datalen)
- f.data = thread->buf + sizeof(*vh);
+ f.data.ptr = thread->buf + sizeof(*vh);
#ifdef IAXTESTS
if (test_resync) {
fr->ts = (iaxs[fr->callno]->last & 0xFFFF8000L) | ((ntohs(vh->ts) + test_resync) & 0x7fff);
#ifdef IAXTESTS
if (test_resync) {
fr->ts = (iaxs[fr->callno]->last & 0xFFFF8000L) | ((ntohs(vh->ts) + test_resync) & 0x7fff);
return 1;
}
if (f.datalen)
return 1;
}
if (f.datalen)
- f.data = thread->buf + sizeof(*mh);
+ f.data.ptr = thread->buf + sizeof(*mh);
#ifdef IAXTESTS
if (test_resync) {
fr->ts = (iaxs[fr->callno]->last & 0xFFFF0000L) | ((ntohs(mh->ts) + test_resync) & 0xffff);
#ifdef IAXTESTS
if (test_resync) {
fr->ts = (iaxs[fr->callno]->last & 0xFFFF0000L) | ((ntohs(mh->ts) + test_resync) & 0xffff);
if (tmp) {
tmp->alreadygone = 1;
if (tmp->owner)
if (tmp) {
tmp->alreadygone = 1;
if (tmp->owner)
- ast_queue_hangup(tmp->owner, -1);
+ ast_queue_hangup(tmp->owner);
} else
ast_log(LOG_NOTICE, "Whoa, didn't find call!\n");
jingle_response(client, pak, NULL, NULL);
} else
ast_log(LOG_NOTICE, "Whoa, didn't find call!\n");
jingle_response(client, pak, NULL, NULL);
ast_mutex_lock(&p->lock);
isoutbound = IS_OUTBOUND(ast, p);
f.subclass = condition;
ast_mutex_lock(&p->lock);
isoutbound = IS_OUTBOUND(ast, p);
f.subclass = condition;
+ f.data.ptr = (void*)data;
f.datalen = datalen;
if (!(res = local_queue_frame(p, isoutbound, &f, ast, 1)))
ast_mutex_unlock(&p->lock);
f.datalen = datalen;
if (!(res = local_queue_frame(p, isoutbound, &f, ast, 1)))
ast_mutex_unlock(&p->lock);
ast_mutex_lock(&p->lock);
isoutbound = IS_OUTBOUND(ast, p);
ast_mutex_lock(&p->lock);
isoutbound = IS_OUTBOUND(ast, p);
- f.data = (char *) text;
+ f.data.ptr = (char *) text;
f.datalen = strlen(text) + 1;
if (!(res = local_queue_frame(p, isoutbound, &f, ast, 0)))
ast_mutex_unlock(&p->lock);
f.datalen = strlen(text) + 1;
if (!(res = local_queue_frame(p, isoutbound, &f, ast, 0)))
ast_mutex_unlock(&p->lock);
ast_mutex_lock(&p->lock);
isoutbound = IS_OUTBOUND(ast, p);
f.subclass = subclass;
ast_mutex_lock(&p->lock);
isoutbound = IS_OUTBOUND(ast, p);
f.subclass = subclass;
+ f.data.ptr = (char *)data;
f.datalen = datalen;
if (!(res = local_queue_frame(p, isoutbound, &f, ast, 0)))
ast_mutex_unlock(&p->lock);
f.datalen = datalen;
if (!(res = local_queue_frame(p, isoutbound, &f, ast, 0)))
ast_mutex_unlock(&p->lock);
{
struct local_pvt *p = ast->tech_pvt;
int isoutbound;
{
struct local_pvt *p = ast->tech_pvt;
int isoutbound;
- struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP, .seqno = ast->hangupcause };
+ struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP, .data.uint32 = ast->hangupcause };
struct ast_channel *ochan = NULL;
int glaredetect = 0, res = 0;
struct ast_channel *ochan = NULL;
int glaredetect = 0, res = 0;
for(;;) {
if (sub->owner) {
if (!ast_channel_trylock(sub->owner)) {
for(;;) {
if (sub->owner) {
if (!ast_channel_trylock(sub->owner)) {
- ast_queue_hangup(sub->owner, -1);
+ ast_queue_hangup(sub->owner);
ast_channel_unlock(sub->owner);
break;
} else {
ast_channel_unlock(sub->owner);
break;
} else {
if (!p) {
ast_log(LOG_WARNING, " --> Channel not connected ??\n");
if (!p) {
ast_log(LOG_WARNING, " --> Channel not connected ??\n");
- ast_queue_hangup(ast, AST_CAUSE_NETWORK_OUT_OF_ORDER);
+ ast_queue_hangup_with_cause(ast, AST_CAUSE_NETWORK_OUT_OF_ORDER);
}
if (!p->bc) {
chan_misdn_log(1, 0, " --> Got Answer, but theres no bc obj ??\n");
}
if (!p->bc) {
chan_misdn_log(1, 0, " --> Got Answer, but theres no bc obj ??\n");
- ast_queue_hangup(ast, AST_CAUSE_PROTOCOL_ERROR);
+ ast_queue_hangup_with_cause(ast, AST_CAUSE_PROTOCOL_ERROR);
}
tmp = pbx_builtin_getvar_helper(p->ast, "CRYPT_KEY");
}
tmp = pbx_builtin_getvar_helper(p->ast, "CRYPT_KEY");
send_cause2ast(ch->ast, ch->bc, ch);
if (ch->ast)
send_cause2ast(ch->ast, ch->bc, ch);
if (ch->ast)
- ast_queue_hangup(ch->ast, ch->bc->cause);
+ ast_queue_hangup_with_cause(ch->ast, ch->bc->cause);
cb_log(2, port, " --> queue_hangup\n");
} else {
cb_log(1, port, "Cannot hangup chan, no ast\n");
cb_log(2, port, " --> queue_hangup\n");
} else {
cb_log(1, port, "Cannot hangup chan, no ast\n");
int l = sizeof(o->oss_write_buf) - o->oss_write_dst;
if (f->datalen - src >= l) { /* enough to fill a frame */
int l = sizeof(o->oss_write_buf) - o->oss_write_dst;
if (f->datalen - src >= l) { /* enough to fill a frame */
- memcpy(o->oss_write_buf + o->oss_write_dst, f->data + src, l);
+ memcpy(o->oss_write_buf + o->oss_write_dst, f->data.ptr + src, l);
soundcard_writeframe(o, (short *) o->oss_write_buf);
src += l;
o->oss_write_dst = 0;
} else { /* copy residue */
l = f->datalen - src;
soundcard_writeframe(o, (short *) o->oss_write_buf);
src += l;
o->oss_write_dst = 0;
} else { /* copy residue */
l = f->datalen - src;
- memcpy(o->oss_write_buf + o->oss_write_dst, f->data + src, l);
+ memcpy(o->oss_write_buf + o->oss_write_dst, f->data.ptr + src, l);
src += l; /* but really, we are done */
o->oss_write_dst += l;
}
src += l; /* but really, we are done */
o->oss_write_dst += l;
}
f->subclass = AST_FORMAT_SLINEAR;
f->samples = FRAME_SIZE;
f->datalen = FRAME_SIZE * 2;
f->subclass = AST_FORMAT_SLINEAR;
f->samples = FRAME_SIZE;
f->datalen = FRAME_SIZE * 2;
- f->data = o->oss_read_buf + AST_FRIENDLY_OFFSET;
+ f->data.ptr = o->oss_read_buf + AST_FRIENDLY_OFFSET;
if (o->boost != BOOST_SCALE) { /* scale and clip values */
int i, x;
if (o->boost != BOOST_SCALE) { /* scale and clip values */
int i, x;
- int16_t *p = (int16_t *) f->data;
+ int16_t *p = (int16_t *) f->data.ptr;
for (i = 0; i < f->samples; i++) {
x = (p[i] * o->boost) / BOOST_SCALE;
if (x > 32767)
for (i = 0; i < f->samples; i++) {
x = (p[i] * o->boost) / BOOST_SCALE;
if (x > 32767)
buf[i] = '\n';
f.frametype = AST_FRAME_TEXT;
f.subclass = 0;
buf[i] = '\n';
f.frametype = AST_FRAME_TEXT;
f.subclass = 0;
f.datalen = i + 1;
ast_queue_frame(o->owner, &f);
}
f.datalen = i + 1;
ast_queue_frame(o->owner, &f);
}
}
o->hookstate = 0;
if (o->owner)
}
o->hookstate = 0;
if (o->owner)
- ast_queue_hangup(o->owner, AST_CAUSE_NORMAL_CLEARING);
+ ast_queue_hangup_with_cause(o->owner, AST_CAUSE_NORMAL_CLEARING);
setformat(o, O_CLOSE);
return CLI_SUCCESS;
}
setformat(o, O_CLOSE);
return CLI_SUCCESS;
}
/* Some nice norms */
p->fr.datalen = 0;
p->fr.samples = 0;
/* Some nice norms */
p->fr.datalen = 0;
p->fr.samples = 0;
p->fr.src = "Phone";
p->fr.offset = 0;
p->fr.mallocd=0;
p->fr.src = "Phone";
p->fr.offset = 0;
p->fr.mallocd=0;
/* Some nice norms */
p->fr.datalen = 0;
p->fr.samples = 0;
/* Some nice norms */
p->fr.datalen = 0;
p->fr.samples = 0;
p->fr.src = "Phone";
p->fr.offset = 0;
p->fr.mallocd=0;
p->fr.src = "Phone";
p->fr.offset = 0;
p->fr.mallocd=0;
ast_log(LOG_WARNING, "Error reading: %s\n", strerror(errno));
return NULL;
}
ast_log(LOG_WARNING, "Error reading: %s\n", strerror(errno));
return NULL;
}
+ p->fr.data.ptr = p->buf;
if (p->mode != MODE_FXS)
switch(p->buf[0] & 0x3) {
case '0':
if (p->mode != MODE_FXS)
switch(p->buf[0] & 0x3) {
case '0':
}
/* If we get here, we have a frame of Appropriate data */
sofar = 0;
}
/* If we get here, we have a frame of Appropriate data */
sofar = 0;
while(sofar < frame->datalen) {
/* Write in no more than maxfr sized frames */
expected = frame->datalen - sofar;
while(sofar < frame->datalen) {
/* Write in no more than maxfr sized frames */
expected = frame->datalen - sofar;
if (frame->datalen == 4) {
if (p->silencesupression) {
memset(tmpbuf + 4, 0, sizeof(tmpbuf) - 4);
if (frame->datalen == 4) {
if (p->silencesupression) {
memset(tmpbuf + 4, 0, sizeof(tmpbuf) - 4);
- memcpy(tmpbuf, frame->data, 4);
+ memcpy(tmpbuf, frame->data.ptr, 4);
expected = 24;
res = phone_write_buf(p, tmpbuf, expected, maxfr, 0);
}
expected = 24;
res = phone_write_buf(p, tmpbuf, expected, maxfr, 0);
}
if (pkt->owner->owner) {
sip_alreadygone(pkt->owner);
ast_log(LOG_WARNING, "Hanging up call %s - no reply to our critical packet.\n", pkt->owner->callid);
if (pkt->owner->owner) {
sip_alreadygone(pkt->owner);
ast_log(LOG_WARNING, "Hanging up call %s - no reply to our critical packet.\n", pkt->owner->callid);
- ast_queue_hangup(pkt->owner->owner, AST_CAUSE_PROTOCOL_ERROR);
+ ast_queue_hangup_with_cause(pkt->owner->owner, AST_CAUSE_PROTOCOL_ERROR);
ast_channel_unlock(pkt->owner->owner);
} else {
/* If no channel owner, destroy now */
ast_channel_unlock(pkt->owner->owner);
} else {
/* If no channel owner, destroy now */
if (p->owner) {
ast_log(LOG_WARNING, "Autodestruct on dialog '%s' with owner in place (Method: %s)\n", p->callid, sip_methods[p->method].text);
if (p->owner) {
ast_log(LOG_WARNING, "Autodestruct on dialog '%s' with owner in place (Method: %s)\n", p->callid, sip_methods[p->method].text);
- ast_queue_hangup(p->owner, AST_CAUSE_PROTOCOL_ERROR);
+ ast_queue_hangup_with_cause(p->owner, AST_CAUSE_PROTOCOL_ERROR);
} else if (p->refer) {
ast_debug(3, "Finally hanging up channel after transfer: %s\n", p->callid);
transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, 1);
} else if (p->refer) {
ast_debug(3, "Finally hanging up channel after transfer: %s\n", p->callid);
transmit_request_with_auth(p, SIP_BYE, 0, XMIT_RELIABLE, 1);
f = ast_rtp_read(p->trtp); /* RTP Text */
if (sipdebug_text) {
int i;
f = ast_rtp_read(p->trtp); /* RTP Text */
if (sipdebug_text) {
int i;
- unsigned char* arr = f->data;
+ unsigned char* arr = f->data.ptr;
for (i=0; i < f->datalen; i++)
ast_verbose("%c", (arr[i] > ' ' && arr[i] < '}') ? arr[i] : '.');
ast_verbose(" -> ");
for (i=0; i < f->datalen; i++)
ast_verbose("%c", (arr[i] > ' ' && arr[i] < '}') ? arr[i] : '.');
ast_verbose(" -> ");
f.frametype = AST_FRAME_TEXT;
f.subclass = 0;
f.offset = 0;
f.frametype = AST_FRAME_TEXT;
f.subclass = 0;
f.offset = 0;
f.datalen = strlen(buf);
ast_queue_frame(p->owner, &f);
transmit_response(p, "202 Accepted", req); /* We respond 202 accepted, since we relay the message */
f.datalen = strlen(buf);
ast_queue_frame(p->owner, &f);
transmit_response(p, "202 Accepted", req); /* We respond 202 accepted, since we relay the message */
*/
xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
if (p->owner && !req->ignore) {
*/
xmitres = transmit_request(p, SIP_ACK, seqno, XMIT_UNRELIABLE, FALSE);
if (p->owner && !req->ignore) {
- ast_queue_hangup(p->owner, AST_CAUSE_NORMAL_CLEARING);
+ ast_queue_hangup_with_cause(p->owner, AST_CAUSE_NORMAL_CLEARING);
append_history(p, "Hangup", "Got 487 on CANCEL request from us. Queued AST hangup request");
} else if (!req->ignore) {
update_call_counter(p, DEC_CALL_LIMIT);
append_history(p, "Hangup", "Got 487 on CANCEL request from us. Queued AST hangup request");
} else if (!req->ignore) {
update_call_counter(p, DEC_CALL_LIMIT);
if (p->owner) {
if (!p->refer) {
ast_log(LOG_WARNING, "Notify answer on an owned channel? - %s\n", p->owner->name);
if (p->owner) {
if (!p->refer) {
ast_log(LOG_WARNING, "Notify answer on an owned channel? - %s\n", p->owner->name);
- ast_queue_hangup(p->owner, AST_CAUSE_NORMAL_UNSPECIFIED);
+ ast_queue_hangup_with_cause(p->owner, AST_CAUSE_NORMAL_UNSPECIFIED);
} else {
ast_debug(4, "Got OK on REFER Notify message\n");
}
} else {
ast_debug(4, "Got OK on REFER Notify message\n");
}
default:
/* Send hangup */
if (owner && sipmethod != SIP_MESSAGE && sipmethod != SIP_INFO && sipmethod != SIP_BYE)
default:
/* Send hangup */
if (owner && sipmethod != SIP_MESSAGE && sipmethod != SIP_INFO && sipmethod != SIP_BYE)
- ast_queue_hangup(p->owner, AST_CAUSE_PROTOCOL_ERROR);
+ ast_queue_hangup_with_cause(p->owner, AST_CAUSE_PROTOCOL_ERROR);
break;
}
/* ACK on invite */
break;
}
/* ACK on invite */
ast_debug(1, "Got 200 OK on NOTIFY for transfer\n");
} else
ast_log(LOG_WARNING, "Notify answer on an owned channel?\n");
ast_debug(1, "Got 200 OK on NOTIFY for transfer\n");
} else
ast_log(LOG_WARNING, "Notify answer on an owned channel?\n");
- /* ast_queue_hangup(p->owner, -1); Disabled */
+ /* ast_queue_hangup(p->owner); Disabled */
} else {
if (!p->subscribed && !p->refer)
p->needdestroy = 1;
} else {
if (!p->subscribed && !p->refer)
p->needdestroy = 1;
stop_media_flows(p); /* Immediately stop RTP, VRTP and UDPTL as applicable */
if (p->owner)
stop_media_flows(p); /* Immediately stop RTP, VRTP and UDPTL as applicable */
if (p->owner)
- ast_queue_hangup(p->owner, -1);
+ ast_queue_hangup(p->owner);
else
sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
if (p->initreq.len > 0) {
else
sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
if (p->initreq.len > 0) {
ast_queue_control(c, AST_CONTROL_UNHOLD);
ast_async_goto(bridged_to, p->context, p->refer->refer_to, 1);
} else
ast_queue_control(c, AST_CONTROL_UNHOLD);
ast_async_goto(bridged_to, p->context, p->refer->refer_to, 1);
} else
- ast_queue_hangup(p->owner, -1);
+ ast_queue_hangup(p->owner);
}
} else {
ast_log(LOG_WARNING, "Invalid transfer information from '%s'\n", ast_inet_ntoa(p->recv.sin_addr));
if (p->owner)
}
} else {
ast_log(LOG_WARNING, "Invalid transfer information from '%s'\n", ast_inet_ntoa(p->recv.sin_addr));
if (p->owner)
- ast_queue_hangup(p->owner, AST_CAUSE_PROTOCOL_ERROR);
+ ast_queue_hangup_with_cause(p->owner, AST_CAUSE_PROTOCOL_ERROR);
- ast_queue_hangup(p->owner, -1);
+ ast_queue_hangup(p->owner);
ast_debug(3, "Received bye, issuing owner hangup\n");
} else {
sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
ast_debug(3, "Received bye, issuing owner hangup\n");
} else {
sip_scheddestroy(p, DEFAULT_TRANS_TIMEOUT);
if ((res = attempt_transfer(p)) < 0) {
if (sub->next && sub->next->owner) {
sub->next->alreadygone = 1;
if ((res = attempt_transfer(p)) < 0) {
if (sub->next && sub->next->owner) {
sub->next->alreadygone = 1;
- ast_queue_hangup(sub->next->owner, -1);
+ ast_queue_hangup(sub->next->owner);
}
} else if (res) {
ast_log(LOG_WARNING, "Transfer attempt failed\n");
}
} else if (res) {
ast_log(LOG_WARNING, "Transfer attempt failed\n");
/* If there is another active call, skinny_hangup will ring the phone with the other call */
if (sub->owner) {
sub->alreadygone = 1;
/* If there is another active call, skinny_hangup will ring the phone with the other call */
if (sub->owner) {
sub->alreadygone = 1;
- ast_queue_hangup(sub->owner, -1);
+ ast_queue_hangup(sub->owner);
} else {
ast_log(LOG_WARNING, "Skinny(%s@%s-%d) channel already destroyed\n",
l->name, d->name, sub->callid);
} else {
ast_log(LOG_WARNING, "Skinny(%s@%s-%d) channel already destroyed\n",
l->name, d->name, sub->callid);
if ((res = attempt_transfer(p)) < 0) {
if (sub->next && sub->next->owner) {
sub->next->alreadygone = 1;
if ((res = attempt_transfer(p)) < 0) {
if (sub->next && sub->next->owner) {
sub->next->alreadygone = 1;
- ast_queue_hangup(sub->next->owner, -1);
+ ast_queue_hangup(sub->next->owner);
}
} else if (res) {
ast_log(LOG_WARNING, "Transfer attempt failed\n");
}
} else if (res) {
ast_log(LOG_WARNING, "Transfer attempt failed\n");
/* If there is another active call, skinny_hangup will ring the phone with the other call */
if (sub->owner) {
sub->alreadygone = 1;
/* If there is another active call, skinny_hangup will ring the phone with the other call */
if (sub->owner) {
sub->alreadygone = 1;
- ast_queue_hangup(sub->owner, -1);
+ ast_queue_hangup(sub->owner);
} else {
ast_log(LOG_WARNING, "Skinny(%s@%s-%d) channel already destroyed\n",
l->name, d->name, sub->callid);
} else {
ast_log(LOG_WARNING, "Skinny(%s@%s-%d) channel already destroyed\n",
l->name, d->name, sub->callid);
if (sub->owner) { /* Call in progress ? */
if (unistimdebug)
ast_verb(0, "Aborting call\n");
if (sub->owner) { /* Call in progress ? */
if (unistimdebug)
ast_verb(0, "Aborting call\n");
- ast_queue_hangup(sub->owner, AST_CAUSE_NETWORK_OUT_OF_ORDER);
+ ast_queue_hangup_with_cause(sub->owner, AST_CAUSE_NETWORK_OUT_OF_ORDER);
}
} else
ast_log(LOG_WARNING, "Freeing a client with no subchannel !\n");
}
} else
ast_log(LOG_WARNING, "Freeing a client with no subchannel !\n");
if (attempt_transfer(sub, l->subs[SUB_THREEWAY]) < 0)
ast_verb(0, "attempt_transfer failed.\n");
} else
if (attempt_transfer(sub, l->subs[SUB_THREEWAY]) < 0)
ast_verb(0, "attempt_transfer failed.\n");
} else
- ast_queue_hangup(sub->owner, -1);
+ ast_queue_hangup(sub->owner);
} else {
if (l->subs[SUB_THREEWAY]) {
if (l->subs[SUB_THREEWAY]->owner)
} else {
if (l->subs[SUB_THREEWAY]) {
if (l->subs[SUB_THREEWAY]->owner)
- ast_queue_hangup(l->subs[SUB_THREEWAY]->owner, AST_CAUSE_NORMAL_CLEARING);
+ ast_queue_hangup_with_cause(l->subs[SUB_THREEWAY]->owner, AST_CAUSE_NORMAL_CLEARING);
else
ast_log(LOG_WARNING, "threeway sub without owner\n");
} else
else
ast_log(LOG_WARNING, "threeway sub without owner\n");
} else
if (unistimdebug)
ast_verb(0, "Transfer canceled, hangup our threeway channel\n");
if (p->subs[SUB_THREEWAY]->owner)
if (unistimdebug)
ast_verb(0, "Transfer canceled, hangup our threeway channel\n");
if (p->subs[SUB_THREEWAY]->owner)
- ast_queue_hangup(p->subs[SUB_THREEWAY]->owner, AST_CAUSE_NORMAL_CLEARING);
+ ast_queue_hangup_with_cause(p->subs[SUB_THREEWAY]->owner, AST_CAUSE_NORMAL_CLEARING);
else
ast_log(LOG_WARNING, "Canceling a threeway channel without owner\n");
return;
else
ast_log(LOG_WARNING, "Canceling a threeway channel without owner\n");
return;
/* start switch */
if (ast_pthread_create(&t, NULL, unistim_ss, c)) {
display_last_error("Unable to create switch thread");
/* start switch */
if (ast_pthread_create(&t, NULL, unistim_ss, c)) {
display_last_error("Unable to create switch thread");
- ast_queue_hangup(c, AST_CAUSE_SWITCH_CONGESTION);
+ ast_queue_hangup_with_cause(c, AST_CAUSE_SWITCH_CONGESTION);
}
} else
ast_log(LOG_WARNING, "Unable to create channel for %s@%s\n",
}
} else
ast_log(LOG_WARNING, "Unable to create channel for %s@%s\n",
p->subs[index].f.mallocd = 0;
p->subs[index].f.offset = 0;
p->subs[index].f.src = "zt_handle_event";
p->subs[index].f.mallocd = 0;
p->subs[index].f.offset = 0;
p->subs[index].f.src = "zt_handle_event";
- p->subs[index].f.data = NULL;
+ p->subs[index].f.data.ptr = NULL;
f = &p->subs[index].f;
if (index < 0)
f = &p->subs[index].f;
if (index < 0)
/* It hasn't been long enough since the last flashook. This is probably a bounce on
hanging up. Hangup both channels now */
if (p->subs[SUB_THREEWAY].owner)
/* It hasn't been long enough since the last flashook. This is probably a bounce on
hanging up. Hangup both channels now */
if (p->subs[SUB_THREEWAY].owner)
- ast_queue_hangup(p->subs[SUB_THREEWAY].owner, AST_CAUSE_NO_ANSWER);
+ ast_queue_hangup_with_cause(p->subs[SUB_THREEWAY].owner, AST_CAUSE_NO_ANSWER);
p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV;
ast_debug(1, "Looks like a bounced flash, hanging up both calls on %d\n", p->channel);
ast_channel_unlock(p->subs[SUB_THREEWAY].owner);
p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV;
ast_debug(1, "Looks like a bounced flash, hanging up both calls on %d\n", p->channel);
ast_channel_unlock(p->subs[SUB_THREEWAY].owner);
p->subs[index].f.subclass = 0;
p->subs[index].f.delivery = ast_tv(0,0);
p->subs[index].f.src = "zt_exception";
p->subs[index].f.subclass = 0;
p->subs[index].f.delivery = ast_tv(0,0);
p->subs[index].f.src = "zt_exception";
- p->subs[index].f.data = NULL;
+ p->subs[index].f.data.ptr = NULL;
if ((!p->owner) && (!(p->radio || (p->oprmode < 0)))) {
if ((!p->owner) && (!(p->radio || (p->oprmode < 0)))) {
p->subs[index].f.subclass = 0;
p->subs[index].f.delivery = ast_tv(0,0);
p->subs[index].f.src = "zt_read";
p->subs[index].f.subclass = 0;
p->subs[index].f.delivery = ast_tv(0,0);
p->subs[index].f.src = "zt_read";
- p->subs[index].f.data = NULL;
+ p->subs[index].f.data.ptr = NULL;
/* make sure it sends initial key state as first frame */
if ((p->radio || (p->oprmode < 0)) && (!p->firstradio))
/* make sure it sends initial key state as first frame */
if ((p->radio || (p->oprmode < 0)) && (!p->firstradio))
p->subs[index].f.frametype = AST_FRAME_TEXT;
p->subs[index].f.mallocd = 0;
p->subs[index].f.offset = AST_FRIENDLY_OFFSET;
p->subs[index].f.frametype = AST_FRAME_TEXT;
p->subs[index].f.mallocd = 0;
p->subs[index].f.offset = AST_FRIENDLY_OFFSET;
- p->subs[index].f.data = p->subs[index].buffer + AST_FRIENDLY_OFFSET;
+ p->subs[index].f.data.ptr = p->subs[index].buffer + AST_FRIENDLY_OFFSET;
p->subs[index].f.datalen = 1;
p->subs[index].f.datalen = 1;
- *((char *) p->subs[index].f.data) = c;
+ *((char *) p->subs[index].f.data.ptr) = c;
ast_mutex_unlock(&p->lock);
return &p->subs[index].f;
}
ast_mutex_unlock(&p->lock);
return &p->subs[index].f;
}
p->subs[index].f.samples = READ_SIZE;
p->subs[index].f.mallocd = 0;
p->subs[index].f.offset = AST_FRIENDLY_OFFSET;
p->subs[index].f.samples = READ_SIZE;
p->subs[index].f.mallocd = 0;
p->subs[index].f.offset = AST_FRIENDLY_OFFSET;
- p->subs[index].f.data = p->subs[index].buffer + AST_FRIENDLY_OFFSET / sizeof(p->subs[index].buffer[0]);
+ p->subs[index].f.data.ptr = p->subs[index].buffer + AST_FRIENDLY_OFFSET / sizeof(p->subs[index].buffer[0]);
#if 0
ast_debug(1, "Read %d of voice on %s\n", p->subs[index].f.datalen, ast->name);
#endif
#if 0
ast_debug(1, "Read %d of voice on %s\n", p->subs[index].f.datalen, ast->name);
#endif
p->subs[index].f.samples = 0;
p->subs[index].f.mallocd = 0;
p->subs[index].f.offset = 0;
p->subs[index].f.samples = 0;
p->subs[index].f.mallocd = 0;
p->subs[index].f.offset = 0;
- p->subs[index].f.data = NULL;
+ p->subs[index].f.data.ptr = NULL;
p->subs[index].f.datalen= 0;
}
if (p->dsp && (!p->ignoredtmf || p->callwaitcas || p->busydetect || p->callprogress) && !index) {
p->subs[index].f.datalen= 0;
}
if (p->dsp && (!p->ignoredtmf || p->callwaitcas || p->busydetect || p->callprogress) && !index) {
return 0;
}
/* Return if it's not valid data */
return 0;
}
/* Return if it's not valid data */
- if (!frame->data || !frame->datalen)
+ if (!frame->data.ptr || !frame->datalen)
return 0;
if (frame->subclass == AST_FORMAT_SLINEAR) {
return 0;
if (frame->subclass == AST_FORMAT_SLINEAR) {
if (res)
ast_log(LOG_WARNING, "Unable to set linear mode on channel %d\n", p->channel);
}
if (res)
ast_log(LOG_WARNING, "Unable to set linear mode on channel %d\n", p->channel);
}
- res = my_zt_write(p, (unsigned char *)frame->data, frame->datalen, index, 1);
+ res = my_zt_write(p, (unsigned char *)frame->data.ptr, frame->datalen, index, 1);
} else {
/* x-law already */
if (p->subs[index].linear) {
} else {
/* x-law already */
if (p->subs[index].linear) {
if (res)
ast_log(LOG_WARNING, "Unable to set companded mode on channel %d\n", p->channel);
}
if (res)
ast_log(LOG_WARNING, "Unable to set companded mode on channel %d\n", p->channel);
}
- res = my_zt_write(p, (unsigned char *)frame->data, frame->datalen, index, 0);
+ res = my_zt_write(p, (unsigned char *)frame->data.ptr, frame->datalen, index, 0);
}
if (res < 0) {
ast_log(LOG_WARNING, "write failed: %s\n", strerror(errno));
}
if (res < 0) {
ast_log(LOG_WARNING, "write failed: %s\n", strerror(errno));
ast_mutex_lock(&p->lock);
}
if (p->subs[x].owner) {
ast_mutex_lock(&p->lock);
}
if (p->subs[x].owner) {
- ast_queue_hangup(p->subs[x].owner, AST_CAUSE_PRE_EMPTED);
+ ast_queue_hangup_with_cause(p->subs[x].owner, AST_CAUSE_PRE_EMPTED);
ast_channel_unlock(p->subs[x].owner);
}
}
ast_channel_unlock(p->subs[x].owner);
}
}
fr->af.src = f->src;
fr->af.delivery.tv_sec = 0;
fr->af.delivery.tv_usec = 0;
fr->af.src = f->src;
fr->af.delivery.tv_sec = 0;
fr->af.delivery.tv_usec = 0;
- fr->af.data = fr->afdata;
+ fr->af.data.ptr = fr->afdata;
fr->af.len = f->len;
if (fr->af.datalen) {
size_t copy_len = fr->af.datalen;
fr->af.len = f->len;
if (fr->af.datalen) {
size_t copy_len = fr->af.datalen;
/* We need to byte-swap slinear samples from network byte order */
if ((fr->af.frametype == AST_FRAME_VOICE) && (fr->af.subclass == AST_FORMAT_SLINEAR)) {
/* 2 bytes / sample for SLINEAR */
/* We need to byte-swap slinear samples from network byte order */
if ((fr->af.frametype == AST_FRAME_VOICE) && (fr->af.subclass == AST_FORMAT_SLINEAR)) {
/* 2 bytes / sample for SLINEAR */
- ast_swapcopy_samples(fr->af.data, f->data, copy_len / 2);
+ ast_swapcopy_samples(fr->af.data.ptr, f->data.ptr, copy_len / 2);
- memcpy(fr->af.data, f->data, copy_len);
+ memcpy(fr->af.data.ptr, f->data.ptr, copy_len);
static int alawtoulaw_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
int x = f->samples;
static int alawtoulaw_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
int x = f->samples;
- unsigned char *src = f->data;
+ unsigned char *src = f->data.ptr;
unsigned char *dst = (unsigned char *)pvt->outbuf + pvt->samples;
pvt->samples += x;
unsigned char *dst = (unsigned char *)pvt->outbuf + pvt->samples;
pvt->samples += x;
static int ulawtoalaw_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
int x = f->samples;
static int ulawtoalaw_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
int x = f->samples;
- unsigned char *src = f->data;
+ unsigned char *src = f->data.ptr;
unsigned char *dst = (unsigned char *)pvt->outbuf + pvt->samples;
pvt->samples += x;
unsigned char *dst = (unsigned char *)pvt->outbuf + pvt->samples;
pvt->samples += x;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
- f.data = ulaw_slin_ex; /* XXX what ? */
+ f.data.ptr = ulaw_slin_ex; /* XXX what ? */
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
+ f.data.ptr = ulaw_slin_ex;
{
struct adpcm_decoder_pvt *tmp = pvt->pvt;
int x = f->datalen;
{
struct adpcm_decoder_pvt *tmp = pvt->pvt;
int x = f->datalen;
- unsigned char *src = f->data;
+ unsigned char *src = f->data.ptr;
int16_t *dst = (int16_t *)pvt->outbuf + pvt->samples;
while (x--) {
int16_t *dst = (int16_t *)pvt->outbuf + pvt->samples;
while (x--) {
{
struct adpcm_encoder_pvt *tmp = pvt->pvt;
{
struct adpcm_encoder_pvt *tmp = pvt->pvt;
- memcpy(&tmp->inbuf[pvt->samples], f->data, f->datalen);
+ memcpy(&tmp->inbuf[pvt->samples], f->data.ptr, f->datalen);
pvt->samples += f->samples;
return 0;
}
pvt->samples += f->samples;
return 0;
}
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
- f.data = adpcm_slin_ex;
+ f.data.ptr = adpcm_slin_ex;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
- f.data = slin_adpcm_ex;
+ f.data.ptr = slin_adpcm_ex;
static int alawtolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
int i = f->samples;
static int alawtolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
int i = f->samples;
- unsigned char *src = f->data;
+ unsigned char *src = f->data.ptr;
int16_t *dst = (int16_t *)pvt->outbuf + pvt->samples;
pvt->samples += i;
int16_t *dst = (int16_t *)pvt->outbuf + pvt->samples;
pvt->samples += i;
{
int i = f->samples;
char *dst = pvt->outbuf + pvt->samples;
{
int i = f->samples;
char *dst = pvt->outbuf + pvt->samples;
- int16_t *src = f->data;
+ int16_t *src = f->data.ptr;
pvt->samples += i;
pvt->datalen += i; /* 1 byte/sample */
pvt->samples += i;
pvt->datalen += i; /* 1 byte/sample */
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
+ f.data.ptr = ulaw_slin_ex;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
+ f.data.ptr = slin_ulaw_ex;
in_samples = f->samples / 2;
out_samples = g722_decode(&tmp->g722, (int16_t *) &pvt->outbuf[pvt->samples * sizeof(int16_t)],
in_samples = f->samples / 2;
out_samples = g722_decode(&tmp->g722, (int16_t *) &pvt->outbuf[pvt->samples * sizeof(int16_t)],
- (uint8_t *) f->data, in_samples);
+ (uint8_t *) f->data.ptr, in_samples);
pvt->samples += out_samples;
pvt->samples += out_samples;
int outlen;
outlen = g722_encode(&tmp->g722, (uint8_t *) (&pvt->outbuf[pvt->datalen]),
int outlen;
outlen = g722_encode(&tmp->g722, (uint8_t *) (&pvt->outbuf[pvt->datalen]),
- (int16_t *) f->data, f->samples);
+ (int16_t *) f->data.ptr, f->samples);
pvt->samples += outlen * 2;
pvt->samples += outlen * 2;
.datalen = sizeof(g722_slin_ex),
.samples = sizeof(g722_slin_ex) * 2,
.src = __PRETTY_FUNCTION__,
.datalen = sizeof(g722_slin_ex),
.samples = sizeof(g722_slin_ex) * 2,
.src = __PRETTY_FUNCTION__,
+ .data.ptr = g722_slin_ex,
.datalen = sizeof(g722_slin_ex),
.samples = sizeof(g722_slin_ex) * 2,
.src = __PRETTY_FUNCTION__,
.datalen = sizeof(g722_slin_ex),
.samples = sizeof(g722_slin_ex) * 2,
.src = __PRETTY_FUNCTION__,
+ .data.ptr = g722_slin_ex,
.datalen = sizeof(slin_g722_ex),
.samples = sizeof(slin_g722_ex) / sizeof(slin_g722_ex[0]),
.src = __PRETTY_FUNCTION__,
.datalen = sizeof(slin_g722_ex),
.samples = sizeof(slin_g722_ex) / sizeof(slin_g722_ex[0]),
.src = __PRETTY_FUNCTION__,
+ .data.ptr = slin_g722_ex,
.datalen = sizeof(slin_g722_ex),
.samples = sizeof(slin_g722_ex) / sizeof(slin_g722_ex[0]),
.src = __PRETTY_FUNCTION__,
.datalen = sizeof(slin_g722_ex),
.samples = sizeof(slin_g722_ex) / sizeof(slin_g722_ex[0]),
.src = __PRETTY_FUNCTION__,
+ .data.ptr = slin_g722_ex,
static int g726aal2tolin_framein (struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct g726_coder_pvt *tmp = pvt->pvt;
static int g726aal2tolin_framein (struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct g726_coder_pvt *tmp = pvt->pvt;
- unsigned char *src = f->data;
+ unsigned char *src = f->data.ptr;
int16_t *dst = (int16_t *) pvt->outbuf + pvt->samples;
unsigned int i;
int16_t *dst = (int16_t *) pvt->outbuf + pvt->samples;
unsigned int i;
static int lintog726aal2_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct g726_coder_pvt *tmp = pvt->pvt;
static int lintog726aal2_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct g726_coder_pvt *tmp = pvt->pvt;
- int16_t *src = f->data;
+ int16_t *src = f->data.ptr;
unsigned int i;
for (i = 0; i < f->samples; i++) {
unsigned int i;
for (i = 0; i < f->samples; i++) {
static int g726tolin_framein (struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct g726_coder_pvt *tmp = pvt->pvt;
static int g726tolin_framein (struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct g726_coder_pvt *tmp = pvt->pvt;
- unsigned char *src = f->data;
+ unsigned char *src = f->data.ptr;
int16_t *dst = (int16_t *) pvt->outbuf + pvt->samples;
unsigned int i;
int16_t *dst = (int16_t *) pvt->outbuf + pvt->samples;
unsigned int i;
static int lintog726_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct g726_coder_pvt *tmp = pvt->pvt;
static int lintog726_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
struct g726_coder_pvt *tmp = pvt->pvt;
- int16_t *src = f->data;
+ int16_t *src = f->data.ptr;
unsigned int i;
for (i = 0; i < f->samples; i++) {
unsigned int i;
for (i = 0; i < f->samples; i++) {
/*! \brief convert G726-32 RFC3551 packed data into AAL2 packed data (or vice-versa) */
static int g726tog726aal2_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
/*! \brief convert G726-32 RFC3551 packed data into AAL2 packed data (or vice-versa) */
static int g726tog726aal2_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
- unsigned char *src = f->data;
+ unsigned char *src = f->data.ptr;
unsigned char *dst = (unsigned char *) pvt->outbuf + pvt->samples;
unsigned int i;
unsigned char *dst = (unsigned char *) pvt->outbuf + pvt->samples;
unsigned int i;
.datalen = sizeof(g726_slin_ex),
.samples = sizeof(g726_slin_ex) * 2, /* 2 samples per byte */
.src = __PRETTY_FUNCTION__,
.datalen = sizeof(g726_slin_ex),
.samples = sizeof(g726_slin_ex) * 2, /* 2 samples per byte */
.src = __PRETTY_FUNCTION__,
+ .data.ptr = g726_slin_ex,
.datalen = sizeof(slin_g726_ex),
.samples = sizeof(slin_g726_ex) / 2, /* 1 sample per 2 bytes */
.src = __PRETTY_FUNCTION__,
.datalen = sizeof(slin_g726_ex),
.samples = sizeof(slin_g726_ex) / 2, /* 1 sample per 2 bytes */
.src = __PRETTY_FUNCTION__,
+ .data.ptr = slin_g726_ex,
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
+ f.data.ptr = slin_gsm_ex;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
+ f.data.ptr = gsm_slin_ex;
/* XXX what's the point here! we should just work
* on the full format.
*/
/* XXX what's the point here! we should just work
* on the full format.
*/
- conv65(f->data + x, data);
+ conv65(f->data.ptr + x, data);
} else {
len = GSM_SAMPLES;
} else {
len = GSM_SAMPLES;
}
/* XXX maybe we don't need to check */
if (pvt->samples + len > BUFFER_SAMPLES) {
}
/* XXX maybe we don't need to check */
if (pvt->samples + len > BUFFER_SAMPLES) {
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
- memcpy(tmp->buf + pvt->samples, f->data, f->datalen);
+ memcpy(tmp->buf + pvt->samples, f->data.ptr, f->datalen);
pvt->samples += f->samples;
return 0;
}
pvt->samples += f->samples;
return 0;
}
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
- f.data = slin_lpc10_ex;
+ f.data.ptr = slin_lpc10_ex;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
- f.data = lpc10_slin_ex;
+ f.data.ptr = lpc10_slin_ex;
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
- extract_bits(bits, f->data + len);
+ extract_bits(bits, f->data.ptr + len);
if (lpc10_decode(bits, tmpbuf, tmp->lpc10.dec)) {
ast_log(LOG_WARNING, "Invalid lpc10 data\n");
return -1;
if (lpc10_decode(bits, tmpbuf, tmp->lpc10.dec)) {
ast_log(LOG_WARNING, "Invalid lpc10 data\n");
return -1;
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
ast_log(LOG_WARNING, "Out of buffer space\n");
return -1;
}
- memcpy(tmp->buf + pvt->samples, f->data, f->datalen);
+ memcpy(tmp->buf + pvt->samples, f->data.ptr, f->datalen);
pvt->samples += f->samples;
return 0;
}
pvt->samples += f->samples;
return 0;
}
{
int total_in_buf_used = 0;
int total_out_buf_used = 0;
{
int total_in_buf_used = 0;
int total_out_buf_used = 0;
- int16_t *in_buf = (int16_t *) f->data;
+ int16_t *in_buf = (int16_t *) f->data.ptr;
int16_t *out_buf = (int16_t *) pvt->outbuf + pvt->samples;
float in_buf_f[f->samples];
float out_buf_f[2048];
int16_t *out_buf = (int16_t *) pvt->outbuf + pvt->samples;
float in_buf_f[f->samples];
float out_buf_f[2048];
.datalen = sizeof(slin16_slin8_ex),
.samples = sizeof(slin16_slin8_ex) / sizeof(slin16_slin8_ex[0]),
.src = __PRETTY_FUNCTION__,
.datalen = sizeof(slin16_slin8_ex),
.samples = sizeof(slin16_slin8_ex) / sizeof(slin16_slin8_ex[0]),
.src = __PRETTY_FUNCTION__,
- .data = slin16_slin8_ex,
+ .data.ptr = slin16_slin8_ex,
.datalen = sizeof(slin8_slin16_ex),
.samples = sizeof(slin8_slin16_ex) / sizeof(slin8_slin16_ex[0]),
.src = __PRETTY_FUNCTION__,
.datalen = sizeof(slin8_slin16_ex),
.samples = sizeof(slin8_slin16_ex) / sizeof(slin8_slin16_ex[0]),
.src = __PRETTY_FUNCTION__,
- .data = slin8_slin16_ex,
+ .data.ptr = slin8_slin16_ex,
static int ulawtolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
int i = f->samples;
static int ulawtolin_framein(struct ast_trans_pvt *pvt, struct ast_frame *f)
{
int i = f->samples;
- unsigned char *src = f->data;
+ unsigned char *src = f->data.ptr;
int16_t *dst = (int16_t *)pvt->outbuf + pvt->samples;
pvt->samples += i;
int16_t *dst = (int16_t *)pvt->outbuf + pvt->samples;
pvt->samples += i;
{
int i = f->samples;
char *dst = pvt->outbuf + pvt->samples;
{
int i = f->samples;
char *dst = pvt->outbuf + pvt->samples;
- int16_t *src = f->data;
+ int16_t *src = f->data.ptr;
pvt->samples += i;
pvt->datalen += i; /* 1 byte/sample */
pvt->samples += i;
pvt->datalen += i; /* 1 byte/sample */
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
+ f.data.ptr = ulaw_slin_ex;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
f.mallocd = 0;
f.offset = 0;
f.src = __PRETTY_FUNCTION__;
+ f.data.ptr = slin_ulaw_ex;
- memcpy(hdr->srcdata + hdr->srcoffset + hdr->srclen, f->data, f->datalen);
+ memcpy(hdr->srcdata + hdr->srcoffset + hdr->srclen, f->data.ptr, f->datalen);
hdr->srclen += f->datalen;
pvt->samples += f->samples;
hdr->srclen += f->datalen;
pvt->samples += f->samples;
pvt->f.frametype = AST_FRAME_VOICE;
pvt->f.subclass = 0;
pvt->f.samples = 160;
pvt->f.frametype = AST_FRAME_VOICE;
pvt->f.subclass = 0;
pvt->f.samples = 160;
+ pvt->f.data.ptr = NULL;
pvt->f.offset = 0;
pvt->f.datalen = 0;
pvt->f.mallocd = 0;
pvt->f.offset = 0;
pvt->f.datalen = 0;
pvt->f.mallocd = 0;
pvt->f.frametype = AST_FRAME_VOICE;
pvt->f.subclass = hdr->dstfmt;
pvt->f.samples = hdr->dstsamples;
pvt->f.frametype = AST_FRAME_VOICE;
pvt->f.subclass = hdr->dstfmt;
pvt->f.samples = hdr->dstsamples;
- pvt->f.data = hdr->dstdata + hdr->dstoffset;
+ pvt->f.data.ptr = hdr->dstdata + hdr->dstoffset;
pvt->f.offset = hdr->dstoffset;
pvt->f.datalen = hdr->dstlen;
pvt->f.mallocd = 0;
pvt->f.offset = hdr->dstoffset;
pvt->f.datalen = hdr->dstlen;
pvt->f.mallocd = 0;
s->fr.subclass = AST_FORMAT_G723_1;
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, size);
s->fr.subclass = AST_FORMAT_G723_1;
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, size);
- if ((res = fread(s->fr.data, 1, s->fr.datalen, s->f)) != size) {
+ if ((res = fread(s->fr.data.ptr, 1, s->fr.datalen, s->f)) != size) {
ast_log(LOG_WARNING, "Short read (%d of %d bytes) (%s)!\n", res, size, strerror(errno));
return NULL;
}
ast_log(LOG_WARNING, "Short read (%d of %d bytes) (%s)!\n", res, size, strerror(errno));
return NULL;
}
ast_log(LOG_WARNING, "Unable to write size: res=%d (%s)\n", res, strerror(errno));
return -1;
}
ast_log(LOG_WARNING, "Unable to write size: res=%d (%s)\n", res, strerror(errno));
return -1;
}
- if ((res = fwrite(f->data, 1, f->datalen, s->f)) != f->datalen) {
+ if ((res = fwrite(f->data.ptr, 1, f->datalen, s->f)) != f->datalen) {
ast_log(LOG_WARNING, "Unable to write frame: res=%d (%s)\n", res, strerror(errno));
return -1;
}
ast_log(LOG_WARNING, "Unable to write frame: res=%d (%s)\n", res, strerror(errno));
return -1;
}
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, frame_size[fs->rate]);
s->fr.samples = 8 * FRAME_TIME;
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, frame_size[fs->rate]);
s->fr.samples = 8 * FRAME_TIME;
- if ((res = fread(s->fr.data, 1, s->fr.datalen, s->f)) != s->fr.datalen) {
+ if ((res = fread(s->fr.data.ptr, 1, s->fr.datalen, s->f)) != s->fr.datalen) {
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
f->datalen, frame_size[fs->rate]);
return -1;
}
f->datalen, frame_size[fs->rate]);
return -1;
}
- if ((res = fwrite(f->data, 1, f->datalen, s->f)) != f->datalen) {
+ if ((res = fwrite(f->data.ptr, 1, f->datalen, s->f)) != f->datalen) {
ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n",
res, frame_size[fs->rate], strerror(errno));
return -1;
ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n",
res, frame_size[fs->rate], strerror(errno));
return -1;
s->fr.mallocd = 0;
s->fr.samples = G729A_SAMPLES;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, BUF_SIZE);
s->fr.mallocd = 0;
s->fr.samples = G729A_SAMPLES;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, BUF_SIZE);
- if ((res = fread(s->fr.data, 1, s->fr.datalen, s->f)) != s->fr.datalen) {
+ if ((res = fread(s->fr.data.ptr, 1, s->fr.datalen, s->f)) != s->fr.datalen) {
if (res && (res != 10)) /* XXX what for ? */
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
if (res && (res != 10)) /* XXX what for ? */
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
ast_log(LOG_WARNING, "Invalid data length, %d, should be multiple of 10\n", f->datalen);
return -1;
}
ast_log(LOG_WARNING, "Invalid data length, %d, should be multiple of 10\n", f->datalen);
return -1;
}
- if ((res = fwrite(f->data, 1, f->datalen, fs->f)) != f->datalen) {
+ if ((res = fwrite(f->data.ptr, 1, f->datalen, fs->f)) != f->datalen) {
ast_log(LOG_WARNING, "Bad write (%d/10): %s\n", res, strerror(errno));
return -1;
}
ast_log(LOG_WARNING, "Bad write (%d/10): %s\n", res, strerror(errno));
return -1;
}
s->fr.subclass = AST_FORMAT_GSM;
AST_FRAME_SET_BUFFER(&(s->fr), s->buf, AST_FRIENDLY_OFFSET, GSM_FRAME_SIZE)
s->fr.mallocd = 0;
s->fr.subclass = AST_FORMAT_GSM;
AST_FRAME_SET_BUFFER(&(s->fr), s->buf, AST_FRIENDLY_OFFSET, GSM_FRAME_SIZE)
s->fr.mallocd = 0;
- if ((res = fread(s->fr.data, 1, GSM_FRAME_SIZE, s->f)) != GSM_FRAME_SIZE) {
+ if ((res = fread(s->fr.data.ptr, 1, GSM_FRAME_SIZE, s->f)) != GSM_FRAME_SIZE) {
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
/* This is in MSGSM format, need to be converted */
int len=0;
while(len < f->datalen) {
/* This is in MSGSM format, need to be converted */
int len=0;
while(len < f->datalen) {
- conv65(f->data + len, gsm);
+ conv65(f->data.ptr + len, gsm);
if ((res = fwrite(gsm, 1, 2*GSM_FRAME_SIZE, fs->f)) != 2*GSM_FRAME_SIZE) {
ast_log(LOG_WARNING, "Bad write (%d/66): %s\n", res, strerror(errno));
return -1;
if ((res = fwrite(gsm, 1, 2*GSM_FRAME_SIZE, fs->f)) != 2*GSM_FRAME_SIZE) {
ast_log(LOG_WARNING, "Bad write (%d/66): %s\n", res, strerror(errno));
return -1;
ast_log(LOG_WARNING, "Invalid data length, %d, should be multiple of 33\n", f->datalen);
return -1;
}
ast_log(LOG_WARNING, "Invalid data length, %d, should be multiple of 33\n", f->datalen);
return -1;
}
- if ((res = fwrite(f->data, 1, f->datalen, fs->f)) != f->datalen) {
+ if ((res = fwrite(f->data.ptr, 1, f->datalen, fs->f)) != f->datalen) {
ast_log(LOG_WARNING, "Bad write (%d/33): %s\n", res, strerror(errno));
return -1;
}
ast_log(LOG_WARNING, "Bad write (%d/33): %s\n", res, strerror(errno));
return -1;
}
s->fr.subclass = AST_FORMAT_H263;
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, len);
s->fr.subclass = AST_FORMAT_H263;
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, len);
- if ((res = fread(s->fr.data, 1, s->fr.datalen, s->f)) != s->fr.datalen) {
+ if ((res = fread(s->fr.data.ptr, 1, s->fr.datalen, s->f)) != s->fr.datalen) {
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
ast_log(LOG_WARNING, "Bad write (%d/2): %s\n", res, strerror(errno));
return -1;
}
ast_log(LOG_WARNING, "Bad write (%d/2): %s\n", res, strerror(errno));
return -1;
}
- if ((res = fwrite(f->data, 1, f->datalen, fs->f)) != f->datalen) {
+ if ((res = fwrite(f->data.ptr, 1, f->datalen, fs->f)) != f->datalen) {
ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno));
return -1;
}
ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno));
return -1;
}
s->fr.subclass = AST_FORMAT_H264;
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, len);
s->fr.subclass = AST_FORMAT_H264;
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, len);
- if ((res = fread(s->fr.data, 1, s->fr.datalen, s->f)) != s->fr.datalen) {
+ if ((res = fread(s->fr.data.ptr, 1, s->fr.datalen, s->f)) != s->fr.datalen) {
if (res)
ast_log(LOG_WARNING, "Short read (%d of %d) (%s)!\n", res, len, strerror(errno));
return NULL;
if (res)
ast_log(LOG_WARNING, "Short read (%d of %d) (%s)!\n", res, len, strerror(errno));
return NULL;
ast_log(LOG_WARNING, "Bad write (%d/2): %s\n", res, strerror(errno));
return -1;
}
ast_log(LOG_WARNING, "Bad write (%d/2): %s\n", res, strerror(errno));
return -1;
}
- if ((res = fwrite(f->data, 1, f->datalen, s->f)) != f->datalen) {
+ if ((res = fwrite(f->data.ptr, 1, f->datalen, s->f)) != f->datalen) {
ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno));
return -1;
}
ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno));
return -1;
}
s->fr.subclass = AST_FORMAT_ILBC;
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, ILBC_BUF_SIZE);
s->fr.subclass = AST_FORMAT_ILBC;
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, ILBC_BUF_SIZE);
- if ((res = fread(s->fr.data, 1, s->fr.datalen, s->f)) != s->fr.datalen) {
+ if ((res = fread(s->fr.data.ptr, 1, s->fr.datalen, s->f)) != s->fr.datalen) {
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
ast_log(LOG_WARNING, "Invalid data length, %d, should be multiple of 50\n", f->datalen);
return -1;
}
ast_log(LOG_WARNING, "Invalid data length, %d, should be multiple of 50\n", f->datalen);
return -1;
}
- if ((res = fwrite(f->data, 1, f->datalen, fs->f)) != f->datalen) {
+ if ((res = fwrite(f->data.ptr, 1, f->datalen, fs->f)) != f->datalen) {
ast_log(LOG_WARNING, "Bad write (%d/50): %s\n", res, strerror(errno));
return -1;
}
ast_log(LOG_WARNING, "Bad write (%d/50): %s\n", res, strerror(errno));
return -1;
}
memset(&fr, 0, sizeof(fr));
fr.frametype = AST_FRAME_IMAGE;
fr.subclass = AST_FORMAT_JPEG;
memset(&fr, 0, sizeof(fr));
fr.frametype = AST_FRAME_IMAGE;
fr.subclass = AST_FORMAT_JPEG;
fr.src = "JPEG Read";
fr.datalen = len;
return ast_frisolate(&fr);
fr.src = "JPEG Read";
fr.datalen = len;
return ast_frisolate(&fr);
return -1;
}
if (fr->datalen) {
return -1;
}
if (fr->datalen) {
- res = write(fd, fr->data, fr->datalen);
+ res = write(fd, fr->data.ptr, fr->datalen);
if (res != fr->datalen) {
ast_log(LOG_WARNING, "Only wrote %d of %d bytes: %s\n", res, fr->datalen, strerror(errno));
return -1;
if (res != fr->datalen) {
ast_log(LOG_WARNING, "Only wrote %d of %d bytes: %s\n", res, fr->datalen, strerror(errno));
return -1;
s->fr.subclass = s->fmt->format;
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, BUF_SIZE);
s->fr.subclass = s->fmt->format;
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, BUF_SIZE);
- if ((res = fread(s->fr.data, 1, s->fr.datalen, s->f)) < 1) {
+ if ((res = fread(s->fr.data.ptr, 1, s->fr.datalen, s->f)) < 1) {
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
}
#endif /* REALTIME_WRITE */
}
#endif /* REALTIME_WRITE */
- if ((res = fwrite(f->data, 1, f->datalen, fs->f)) != f->datalen) {
+ if ((res = fwrite(f->data.ptr, 1, f->datalen, fs->f)) != f->datalen) {
ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno));
return -1;
}
ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno));
return -1;
}
s->fr.subclass = AST_FORMAT_SLINEAR;
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, BUF_SIZE);
s->fr.subclass = AST_FORMAT_SLINEAR;
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, BUF_SIZE);
- if ((res = fread(s->fr.data, 1, s->fr.datalen, s->f)) < 1) {
+ if ((res = fread(s->fr.data.ptr, 1, s->fr.datalen, s->f)) < 1) {
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
ast_log(LOG_WARNING, "Asked to write non-slinear frame (%d)!\n", f->subclass);
return -1;
}
ast_log(LOG_WARNING, "Asked to write non-slinear frame (%d)!\n", f->subclass);
return -1;
}
- if ((res = fwrite(f->data, 1, f->datalen, fs->f)) != f->datalen) {
+ if ((res = fwrite(f->data.ptr, 1, f->datalen, fs->f)) != f->datalen) {
ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno));
return -1;
}
ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno));
return -1;
}
s->fr.subclass = AST_FORMAT_SLINEAR16;
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, BUF_SIZE);
s->fr.subclass = AST_FORMAT_SLINEAR16;
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, BUF_SIZE);
- if ((res = fread(s->fr.data, 1, s->fr.datalen, s->f)) < 1) {
+ if ((res = fread(s->fr.data.ptr, 1, s->fr.datalen, s->f)) < 1) {
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
ast_log(LOG_WARNING, "Asked to write non-slinear16 frame (%d)!\n", f->subclass);
return -1;
}
ast_log(LOG_WARNING, "Asked to write non-slinear16 frame (%d)!\n", f->subclass);
return -1;
}
- if ((res = fwrite(f->data, 1, f->datalen, fs->f)) != f->datalen) {
+ if ((res = fwrite(f->data.ptr, 1, f->datalen, fs->f)) != f->datalen) {
ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno));
return -1;
}
ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno));
return -1;
}
s->fr.subclass = AST_FORMAT_ADPCM;
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, BUF_SIZE);
s->fr.subclass = AST_FORMAT_ADPCM;
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, BUF_SIZE);
- if ((res = fread(s->fr.data, 1, s->fr.datalen, s->f)) < 1) {
+ if ((res = fread(s->fr.data.ptr, 1, s->fr.datalen, s->f)) < 1) {
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
ast_log(LOG_WARNING, "Asked to write non-ADPCM frame (%d)!\n", f->subclass);
return -1;
}
ast_log(LOG_WARNING, "Asked to write non-ADPCM frame (%d)!\n", f->subclass);
return -1;
}
- if ((res = fwrite(f->data, 1, f->datalen, s->f)) != f->datalen) {
+ if ((res = fwrite(f->data.ptr, 1, f->datalen, s->f)) != f->datalen) {
ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno));
return -1;
}
ast_log(LOG_WARNING, "Bad write (%d/%d): %s\n", res, f->datalen, strerror(errno));
return -1;
}
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, bytes);
s->fr.mallocd = 0;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, bytes);
- if ( (res = fread(s->fr.data, 1, s->fr.datalen, s->f)) <= 0 ) {
+ if ( (res = fread(s->fr.data.ptr, 1, s->fr.datalen, s->f)) <= 0 ) {
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
if (res)
ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", res, strerror(errno));
return NULL;
s->fr.datalen = res;
s->fr.samples = samples = res / 2;
s->fr.datalen = res;
s->fr.samples = samples = res / 2;
- tmp = (short *)(s->fr.data);
+ tmp = (short *)(s->fr.data.ptr);
#if __BYTE_ORDER == __BIG_ENDIAN
/* file format is little endian so we need to swap */
for( x = 0; x < samples; x++)
#if __BYTE_ORDER == __BIG_ENDIAN
/* file format is little endian so we need to swap */
for( x = 0; x < samples; x++)
ast_log(LOG_WARNING, "Data length is too long\n");
return -1;
}
ast_log(LOG_WARNING, "Data length is too long\n");
return -1;
}
for (x=0; x < f->datalen/2; x++)
tmp[x] = (tmpi[x] << 8) | ((tmpi[x] & 0xff00) >> 8);
if ((res = fwrite(tmp, 1, f->datalen, fs->f)) != f->datalen ) {
#else
/* just write */
for (x=0; x < f->datalen/2; x++)
tmp[x] = (tmpi[x] << 8) | ((tmpi[x] & 0xff00) >> 8);
if ((res = fwrite(tmp, 1, f->datalen, fs->f)) != f->datalen ) {
#else
/* just write */
- if ((res = fwrite(f->data, 1, f->datalen, fs->f)) != f->datalen ) {
+ if ((res = fwrite(f->data.ptr, 1, f->datalen, fs->f)) != f->datalen ) {
#endif
ast_log(LOG_WARNING, "Bad write (%d): %s\n", res, strerror(errno));
return -1;
#endif
ast_log(LOG_WARNING, "Bad write (%d): %s\n", res, strerror(errno));
return -1;
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, GSM_FRAME_SIZE);
if (fs->secondhalf) {
/* Just return a frame based on the second GSM frame */
AST_FRAME_SET_BUFFER(&s->fr, s->buf, AST_FRIENDLY_OFFSET, GSM_FRAME_SIZE);
if (fs->secondhalf) {
/* Just return a frame based on the second GSM frame */
- s->fr.data = (char *)s->fr.data + GSM_FRAME_SIZE;
+ s->fr.data.ptr = (char *)s->fr.data.ptr + GSM_FRAME_SIZE;
s->fr.offset += GSM_FRAME_SIZE;
} else {
/* read and convert */
s->fr.offset += GSM_FRAME_SIZE;
} else {
/* read and convert */
return NULL;
}
/* Convert from MS format to two real GSM frames */
return NULL;
}
/* Convert from MS format to two real GSM frames */
- conv65(msdata, s->fr.data);
+ conv65(msdata, s->fr.data.ptr);
}
fs->secondhalf = !fs->secondhalf;
*whennext = GSM_SAMPLES;
}
fs->secondhalf = !fs->secondhalf;
*whennext = GSM_SAMPLES;
int res;
unsigned char *src, msdata[MSGSM_FRAME_SIZE];
if (fs->secondhalf) { /* second half of raw gsm to be converted */
int res;
unsigned char *src, msdata[MSGSM_FRAME_SIZE];
if (fs->secondhalf) { /* second half of raw gsm to be converted */
- memcpy(s->buf + GSM_FRAME_SIZE, f->data + len, GSM_FRAME_SIZE);
+ memcpy(s->buf + GSM_FRAME_SIZE, f->data.ptr + len, GSM_FRAME_SIZE);
conv66((unsigned char *) s->buf, msdata);
src = msdata;
fs->secondhalf = 0;
} else if (size == GSM_FRAME_SIZE) { /* first half of raw gsm */
conv66((unsigned char *) s->buf, msdata);
src = msdata;
fs->secondhalf = 0;
} else if (size == GSM_FRAME_SIZE) { /* first half of raw gsm */
- memcpy(s->buf, f->data + len, GSM_FRAME_SIZE);
+ memcpy(s->buf, f->data.ptr + len, GSM_FRAME_SIZE);
src = NULL; /* nothing to write */
fs->secondhalf = 1;
} else { /* raw msgsm data */
src = NULL; /* nothing to write */
fs->secondhalf = 1;
} else { /* raw msgsm data */
+ src = f->data.ptr + len;
}
if (src && (res = fwrite(src, 1, MSGSM_FRAME_SIZE, s->f)) != MSGSM_FRAME_SIZE) {
ast_log(LOG_WARNING, "Bad write (%d/65): %s\n", res, strerror(errno));
}
if (src && (res = fwrite(src, 1, MSGSM_FRAME_SIZE, s->f)) != MSGSM_FRAME_SIZE) {
ast_log(LOG_WARNING, "Bad write (%d/65): %s\n", res, strerror(errno));
*
* \note The channel does not need to be locked before calling this function.
*/
*
* \note The channel does not need to be locked before calling this function.
*/
-int ast_queue_hangup(struct ast_channel *chan, int cause);
+int ast_queue_hangup(struct ast_channel *chan);
+
+/*!
+ * \brief Queue a hangup frame with hangupcause set
+ *
+ * \note The channel does not need to be locked before calling this function.
+ * \param chan channel to queue frame onto
+ * \param cause the hangup cause
+ */
+int ast_queue_hangup_with_cause(struct ast_channel *chan, int cause);
/*!
* \brief Queue a control frame with payload
/*!
* \brief Queue a control frame with payload
/*! Optional source of frame for debugging */
const char *src;
/*! Pointer to actual data */
/*! Optional source of frame for debugging */
const char *src;
/*! Pointer to actual data */
+ union { void *ptr; uint32_t uint32; char pad[8]; } data;
/*! Global delivery time */
struct timeval delivery;
/*! For placing in a linked list */
/*! Global delivery time */
struct timeval delivery;
/*! For placing in a linked list */
*/
#define AST_FRAME_SET_BUFFER(fr, _base, _ofs, _datalen) \
{ \
*/
#define AST_FRAME_SET_BUFFER(fr, _base, _ofs, _datalen) \
{ \
- (fr)->data = (char *)_base + (_ofs); \
+ (fr)->data.ptr = (char *)_base + (_ofs); \
(fr)->offset = (_ofs); \
(fr)->datalen = (_datalen); \
}
(fr)->offset = (_ofs); \
(fr)->datalen = (_datalen); \
}
little-endian and big-endian. */
#if __BYTE_ORDER == __LITTLE_ENDIAN
#define ast_frame_byteswap_le(fr) do { ; } while(0)
little-endian and big-endian. */
#if __BYTE_ORDER == __LITTLE_ENDIAN
#define ast_frame_byteswap_le(fr) do { ; } while(0)
-#define ast_frame_byteswap_be(fr) do { struct ast_frame *__f = (fr); ast_swapcopy_samples(__f->data, __f->data, __f->samples); } while(0)
+#define ast_frame_byteswap_be(fr) do { struct ast_frame *__f = (fr); ast_swapcopy_samples(__f->data.ptr, __f->data.ptr, __f->samples); } while(0)
-#define ast_frame_byteswap_le(fr) do { struct ast_frame *__f = (fr); ast_swapcopy_samples(__f->data, __f->data, __f->samples); } while(0)
+#define ast_frame_byteswap_le(fr) do { struct ast_frame *__f = (fr); ast_swapcopy_samples(__f->data.ptr, __f->data.ptr, __f->samples); } while(0)
#define ast_frame_byteswap_be(fr) do { ; } while(0)
#endif
#define ast_frame_byteswap_be(fr) do { ; } while(0)
#endif
f->samples = interpolation_len * 8;
f->mallocd = 0;
f->src = "JB interpolation";
f->samples = interpolation_len * 8;
f->mallocd = 0;
f->src = "JB interpolation";
f->delivery = ast_tvadd(jb->timebase, ast_samp2tv(jb->next, 1000));
f->offset = AST_FRIENDLY_OFFSET;
/* deliver the interpolated frame */
f->delivery = ast_tvadd(jb->timebase, ast_samp2tv(jb->next, 1000));
f->offset = AST_FRIENDLY_OFFSET;
/* deliver the interpolated frame */
struct ast_frame f = {
.frametype = AST_FRAME_VOICE,
.subclass = AST_FORMAT_SLINEAR,
struct ast_frame f = {
.frametype = AST_FRAME_VOICE,
.subclass = AST_FORMAT_SLINEAR,
- .data = buf + AST_FRIENDLY_OFFSET / 2,
+ .data.ptr = buf + AST_FRIENDLY_OFFSET / 2,
.offset = AST_FRIENDLY_OFFSET,
};
int res;
.offset = AST_FRIENDLY_OFFSET,
};
int res;
struct ast_frame frame = {
.frametype = AST_FRAME_VOICE,
.subclass = AST_FORMAT_SLINEAR,
struct ast_frame frame = {
.frametype = AST_FRAME_VOICE,
.subclass = AST_FORMAT_SLINEAR,
.datalen = sizeof(buf),
.samples = samples,
};
.datalen = sizeof(buf),
.samples = samples,
};
struct ast_frame frame = {
.frametype = AST_FRAME_VOICE,
.subclass = AST_FORMAT_SLINEAR,
struct ast_frame frame = {
.frametype = AST_FRAME_VOICE,
.subclass = AST_FORMAT_SLINEAR,
.datalen = sizeof(buf1),
.samples = samples,
};
.datalen = sizeof(buf1),
.samples = samples,
};
final_buf = buf2;
/* Make the final buffer part of the frame, so it gets duplicated fine */
final_buf = buf2;
/* Make the final buffer part of the frame, so it gets duplicated fine */
- frame.data = final_buf;
+ frame.data.ptr = final_buf;
/* Yahoo, a combined copy of the audio! */
return ast_frdup(&frame);
/* Yahoo, a combined copy of the audio! */
return ast_frdup(&frame);
}
AST_LIST_TRAVERSE_SAFE_END
/* We take all of the combined whisper sources and combine them into the audio being written out */
}
AST_LIST_TRAVERSE_SAFE_END
/* We take all of the combined whisper sources and combine them into the audio being written out */
- for (i = 0, data1 = middle_frame->data, data2 = combine_buf; i < samples; i++, data1++, data2++)
+ for (i = 0, data1 = middle_frame->data.ptr, data2 = combine_buf; i < samples; i++, data1++, data2++)
ast_slinear_saturated_add(data1, data2);
end_frame = middle_frame;
}
ast_slinear_saturated_add(data1, data2);
end_frame = middle_frame;
}
}
/*! \brief Queue a hangup frame for channel */
}
/*! \brief Queue a hangup frame for channel */
-int ast_queue_hangup(struct ast_channel *chan, int cause)
+int ast_queue_hangup(struct ast_channel *chan)
+{
+ struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
+ /* Yeah, let's not change a lock-critical value without locking */
+ if (!ast_channel_trylock(chan)) {
+ chan->_softhangup |= AST_SOFTHANGUP_DEV;
+ ast_channel_unlock(chan);
+ }
+ return ast_queue_frame(chan, &f);
+}
+
+/*! \brief Queue a hangup frame for channel */
+int ast_queue_hangup_with_cause(struct ast_channel *chan, int cause)
{
struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
if (cause >= 0)
{
struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
if (cause >= 0)
/* Yeah, let's not change a lock-critical value without locking */
if (!ast_channel_trylock(chan)) {
chan->_softhangup |= AST_SOFTHANGUP_DEV;
if (cause < 0)
/* Yeah, let's not change a lock-critical value without locking */
if (!ast_channel_trylock(chan)) {
chan->_softhangup |= AST_SOFTHANGUP_DEV;
if (cause < 0)
- f.seqno = chan->hangupcause;
+ f.data.uint32 = chan->hangupcause;
ast_channel_unlock(chan);
}
ast_channel_unlock(chan);
}
struct ast_frame f = { AST_FRAME_CONTROL, };
f.subclass = control;
struct ast_frame f = { AST_FRAME_CONTROL, };
f.subclass = control;
- f.data = (void *) data;
+ f.data.ptr = (void *) data;
f.datalen = datalen;
return ast_queue_frame(chan, &f);
f.datalen = datalen;
return ast_queue_frame(chan, &f);
case AST_FRAME_VOICE:
/* Write audio if appropriate */
if (audiofd > -1)
case AST_FRAME_VOICE:
/* Write audio if appropriate */
if (audiofd > -1)
- write(audiofd, f->data, f->datalen);
+ write(audiofd, f->data.ptr, f->datalen);
default:
/* Ignore */
break;
default:
/* Ignore */
break;
/* Interpret hangup and return NULL */
/* XXX why not the same for frames from the channel ? */
if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP) {
/* Interpret hangup and return NULL */
/* XXX why not the same for frames from the channel ? */
if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP) {
+ cause = f->data.uint32;
ast_frfree(f);
f = NULL;
}
ast_frfree(f);
f = NULL;
}
if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP)
done = 1; /* force a break */
else if (f->frametype == AST_FRAME_TEXT) { /* what we want */
if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP)
done = 1; /* force a break */
else if (f->frametype == AST_FRAME_TEXT) { /* what we want */
- buf = ast_strndup((char *) f->data, f->datalen); /* dup and break */
+ buf = ast_strndup((char *) f->data.ptr, f->datalen); /* dup and break */
done = 1;
}
ast_frfree(f);
done = 1;
}
ast_frfree(f);
if (chan->_state != AST_STATE_UP) {
ast_debug(1, "Prodding channel '%s'\n", chan->name);
a.subclass = chan->rawwriteformat;
if (chan->_state != AST_STATE_UP) {
ast_debug(1, "Prodding channel '%s'\n", chan->name);
a.subclass = chan->rawwriteformat;
- a.data = nothing + AST_FRIENDLY_OFFSET;
+ a.data.ptr = nothing + AST_FRIENDLY_OFFSET;
a.src = "ast_prod";
if (ast_write(chan, &a))
ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", chan->name);
a.src = "ast_prod";
if (ast_write(chan, &a))
ast_log(LOG_WARNING, "Prodding channel '%s' failed\n", chan->name);
} else if (fr->frametype == AST_FRAME_CONTROL && fr->subclass == AST_CONTROL_UNHOLD) {
/* This is a side case where Echo is basically being called and the person put themselves on hold and took themselves off hold */
res = (chan->tech->indicate == NULL) ? 0 :
} else if (fr->frametype == AST_FRAME_CONTROL && fr->subclass == AST_CONTROL_UNHOLD) {
/* This is a side case where Echo is basically being called and the person put themselves on hold and took themselves off hold */
res = (chan->tech->indicate == NULL) ? 0 :
- chan->tech->indicate(chan, fr->subclass, fr->data, fr->datalen);
+ chan->tech->indicate(chan, fr->subclass, fr->data.ptr, fr->datalen);
}
res = 0; /* XXX explain, why 0 ? */
goto done;
}
res = 0; /* XXX explain, why 0 ? */
goto done;
switch (fr->frametype) {
case AST_FRAME_CONTROL:
res = (chan->tech->indicate == NULL) ? 0 :
switch (fr->frametype) {
case AST_FRAME_CONTROL:
res = (chan->tech->indicate == NULL) ? 0 :
- chan->tech->indicate(chan, fr->subclass, fr->data, fr->datalen);
+ chan->tech->indicate(chan, fr->subclass, fr->data.ptr, fr->datalen);
break;
case AST_FRAME_DTMF_BEGIN:
if (chan->audiohooks) {
break;
case AST_FRAME_DTMF_BEGIN:
if (chan->audiohooks) {
chan->tech->write_text(chan, fr);
} else {
res = (chan->tech->send_text == NULL) ? 0 :
chan->tech->write_text(chan, fr);
} else {
res = (chan->tech->send_text == NULL) ? 0 :
- chan->tech->send_text(chan, (char *) fr->data);
+ chan->tech->send_text(chan, (char *) fr->data.ptr);
}
break;
case AST_FRAME_HTML:
res = (chan->tech->send_html == NULL) ? 0 :
}
break;
case AST_FRAME_HTML:
res = (chan->tech->send_html == NULL) ? 0 :
- chan->tech->send_html(chan, fr->subclass, (char *) fr->data, fr->datalen);
+ chan->tech->send_html(chan, fr->subclass, (char *) fr->data.ptr, fr->datalen);
break;
case AST_FRAME_VIDEO:
/* XXX Handle translation of video codecs one day XXX */
break;
case AST_FRAME_VIDEO:
/* XXX Handle translation of video codecs one day XXX */
case AST_CONTROL_UNHOLD:
case AST_CONTROL_VIDUPDATE:
case AST_CONTROL_SRCUPDATE:
case AST_CONTROL_UNHOLD:
case AST_CONTROL_VIDUPDATE:
case AST_CONTROL_SRCUPDATE:
- ast_indicate_data(other, f->subclass, f->data, f->datalen);
+ ast_indicate_data(other, f->subclass, f->data.ptr, f->datalen);
ts->f.datalen = len;
ts->f.samples = samples;
ts->f.offset = AST_FRIENDLY_OFFSET;
ts->f.datalen = len;
ts->f.samples = samples;
ts->f.offset = AST_FRIENDLY_OFFSET;
+ ts->f.data.ptr = ts->data;
ast_write(chan, &ts->f);
ts->pos += x;
if (ts->duration > 0) {
ast_write(chan, &ts->f);
ts->pos += x;
if (ts->duration > 0) {
struct ast_frame frame = {
.frametype = AST_FRAME_VOICE,
.subclass = AST_FORMAT_SLINEAR,
struct ast_frame frame = {
.frametype = AST_FRAME_VOICE,
.subclass = AST_FORMAT_SLINEAR,
.samples = samples,
.datalen = sizeof(buf),
};
.samples = samples,
.datalen = sizeof(buf),
};
ast_log(LOG_WARNING, "Can only check call progress in signed-linear frames\n");
return 0;
}
ast_log(LOG_WARNING, "Can only check call progress in signed-linear frames\n");
return 0;
}
- return __ast_dsp_call_progress(dsp, inf->data, inf->datalen / 2);
+ return __ast_dsp_call_progress(dsp, inf->data.ptr, inf->datalen / 2);
}
static int __ast_dsp_silence_noise(struct ast_dsp *dsp, short *s, int len, int *totalsilence, int *totalnoise)
}
static int __ast_dsp_silence_noise(struct ast_dsp *dsp, short *s, int len, int *totalsilence, int *totalnoise)
ast_log(LOG_WARNING, "Can only calculate silence on signed-linear frames :(\n");
return 0;
}
ast_log(LOG_WARNING, "Can only calculate silence on signed-linear frames :(\n");
return 0;
}
len = f->datalen/2;
return __ast_dsp_silence_noise(dsp, s, len, totalsilence, NULL);
}
len = f->datalen/2;
return __ast_dsp_silence_noise(dsp, s, len, totalsilence, NULL);
}
ast_log(LOG_WARNING, "Can only calculate noise on signed-linear frames :(\n");
return 0;
}
ast_log(LOG_WARNING, "Can only calculate noise on signed-linear frames :(\n");
return 0;
}
len = f->datalen/2;
return __ast_dsp_silence_noise(dsp, s, len, NULL, totalnoise);
}
len = f->datalen/2;
return __ast_dsp_silence_noise(dsp, s, len, NULL, totalnoise);
}
if (af->frametype != AST_FRAME_VOICE)
return af;
if (af->frametype != AST_FRAME_VOICE)
return af;
len = af->datalen;
/* Make sure we have short data */
switch (af->subclass) {
case AST_FORMAT_SLINEAR:
len = af->datalen;
/* Make sure we have short data */
switch (af->subclass) {
case AST_FORMAT_SLINEAR:
+ shortdata = af->data.ptr;
len = af->datalen / 2;
break;
case AST_FORMAT_ULAW:
len = af->datalen / 2;
break;
case AST_FORMAT_ULAW:
break;
case AST_CONTROL_HOLD:
case AST_CONTROL_UNHOLD:
break;
case AST_CONTROL_HOLD:
case AST_CONTROL_UNHOLD:
- ast_indicate_data(other, f->subclass, f->data, f->datalen);
+ ast_indicate_data(other, f->subclass, f->data.ptr, f->datalen);
break;
case AST_CONTROL_OPTION:
break;
case AST_CONTROL_OPTION:
/* Forward option Requests */
if (aoh && aoh->flag == AST_OPTION_FLAG_REQUEST) {
ast_channel_setoption(other, ntohs(aoh->option), aoh->data,
/* Forward option Requests */
if (aoh && aoh->flag == AST_OPTION_FLAG_REQUEST) {
ast_channel_setoption(other, ntohs(aoh->option), aoh->data,
case AST_FRAME_VOICE:
/* Write audio if appropriate */
if (audiofd > -1)
case AST_FRAME_VOICE:
/* Write audio if appropriate */
if (audiofd > -1)
- write(audiofd, fr->data, fr->datalen);
+ write(audiofd, fr->data.ptr, fr->datalen);
default:
/* Ignore all others */
break;
default:
/* Ignore all others */
break;
on the next read, thus eliminating the douple
copy */
if (swap)
on the next read, thus eliminating the douple
copy */
if (swap)
- ast_swapcopy_samples(f->data, f->data, f->samples);
+ ast_swapcopy_samples(f->data.ptr, f->data.ptr, f->samples);
- ast_swapcopy_samples(s->data+s->len, f->data, f->samples);
+ ast_swapcopy_samples(s->data+s->len, f->data.ptr, f->samples);
- memcpy(s->data + s->len, f->data, f->datalen);
+ memcpy(s->data + s->len, f->data.ptr, f->datalen);
/* If either side is empty, reset the delivery time */
if (!s->len || ast_tvzero(f->delivery) || ast_tvzero(s->delivery)) /* XXX really ? */
s->delivery = f->delivery;
/* If either side is empty, reset the delivery time */
if (!s->len || ast_tvzero(f->delivery) || ast_tvzero(s->delivery)) /* XXX really ? */
s->delivery = f->delivery;
/* Make frame */
s->f.frametype = AST_FRAME_VOICE;
s->f.subclass = s->format;
/* Make frame */
s->f.frametype = AST_FRAME_VOICE;
s->f.subclass = s->format;
- s->f.data = s->framedata + AST_FRIENDLY_OFFSET;
+ s->f.data.ptr = s->framedata + AST_FRIENDLY_OFFSET;
s->f.offset = AST_FRIENDLY_OFFSET;
s->f.datalen = len;
/* Samples will be improper given VAD, but with VAD the concept really doesn't even exist */
s->f.samples = len * s->samplesperbyte; /* XXX rounding */
s->f.delivery = s->delivery;
/* Fill Data */
s->f.offset = AST_FRIENDLY_OFFSET;
s->f.datalen = len;
/* Samples will be improper given VAD, but with VAD the concept really doesn't even exist */
s->f.samples = len * s->samplesperbyte; /* XXX rounding */
s->f.delivery = s->delivery;
/* Fill Data */
- memcpy(s->f.data, s->data, len);
+ memcpy(s->f.data.ptr, s->data, len);
s->len -= len;
/* Move remaining data to the front if applicable */
if (s->len) {
s->len -= len;
/* Move remaining data to the front if applicable */
if (s->len) {
#endif
if (fr->mallocd & AST_MALLOCD_DATA) {
#endif
if (fr->mallocd & AST_MALLOCD_DATA) {
- if (fr->data)
- ast_free(fr->data - fr->offset);
+ if (fr->data.ptr)
+ ast_free(fr->data.ptr - fr->offset);
}
if (fr->mallocd & AST_MALLOCD_SRC) {
if (fr->src)
}
if (fr->mallocd & AST_MALLOCD_SRC) {
if (fr->src)
newdata += AST_FRIENDLY_OFFSET;
out->offset = AST_FRIENDLY_OFFSET;
out->datalen = fr->datalen;
newdata += AST_FRIENDLY_OFFSET;
out->offset = AST_FRIENDLY_OFFSET;
out->datalen = fr->datalen;
- memcpy(newdata, fr->data, fr->datalen);
- out->data = newdata;
+ memcpy(newdata, fr->data.ptr, fr->datalen);
+ out->data.ptr = newdata;
}
out->mallocd = AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA;
}
out->mallocd = AST_MALLOCD_HDR | AST_MALLOCD_SRC | AST_MALLOCD_DATA;
out->mallocd = AST_MALLOCD_HDR;
out->offset = AST_FRIENDLY_OFFSET;
if (out->datalen) {
out->mallocd = AST_MALLOCD_HDR;
out->offset = AST_FRIENDLY_OFFSET;
if (out->datalen) {
- out->data = buf + sizeof(*out) + AST_FRIENDLY_OFFSET;
- memcpy(out->data, f->data, out->datalen);
+ out->data.ptr = buf + sizeof(*out) + AST_FRIENDLY_OFFSET;
+ memcpy(out->data.ptr, f->data.ptr, out->datalen);
}
if (srclen > 0) {
out->src = buf + sizeof(*out) + AST_FRIENDLY_OFFSET + f->datalen;
}
if (srclen > 0) {
out->src = buf + sizeof(*out) + AST_FRIENDLY_OFFSET + f->datalen;
if (f->datalen != sizeof(enum ast_control_t38)) {
message = "Invalid";
} else {
if (f->datalen != sizeof(enum ast_control_t38)) {
message = "Invalid";
} else {
- enum ast_control_t38 state = *((enum ast_control_t38 *) f->data);
+ enum ast_control_t38 state = *((enum ast_control_t38 *) f->data.ptr);
if (state == AST_T38_REQUEST_NEGOTIATE)
message = "Negotiation Requested";
else if (state == AST_T38_REQUEST_TERMINATE)
if (state == AST_T38_REQUEST_NEGOTIATE)
message = "Negotiation Requested";
else if (state == AST_T38_REQUEST_TERMINATE)
case AST_FRAME_TEXT:
strcpy(ftype, "Text");
strcpy(subclass, "N/A");
case AST_FRAME_TEXT:
strcpy(ftype, "Text");
strcpy(subclass, "N/A");
- ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
+ ast_copy_string(moreinfo, f->data.ptr, sizeof(moreinfo));
break;
case AST_FRAME_IMAGE:
strcpy(ftype, "Image");
break;
case AST_FRAME_IMAGE:
strcpy(ftype, "Image");
switch(f->subclass) {
case AST_HTML_URL:
strcpy(subclass, "URL");
switch(f->subclass) {
case AST_HTML_URL:
strcpy(subclass, "URL");
- ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
+ ast_copy_string(moreinfo, f->data.ptr, sizeof(moreinfo));
break;
case AST_HTML_DATA:
strcpy(subclass, "Data");
break;
case AST_HTML_DATA:
strcpy(subclass, "Data");
break;
case AST_HTML_LINKURL:
strcpy(subclass, "Link URL");
break;
case AST_HTML_LINKURL:
strcpy(subclass, "Link URL");
- ast_copy_string(moreinfo, f->data, sizeof(moreinfo));
+ ast_copy_string(moreinfo, f->data.ptr, sizeof(moreinfo));
break;
case AST_HTML_UNLINK:
strcpy(subclass, "Unlink");
break;
case AST_HTML_UNLINK:
strcpy(subclass, "Unlink");
int samples=0;
switch(f->subclass) {
case AST_FORMAT_SPEEX:
int samples=0;
switch(f->subclass) {
case AST_FORMAT_SPEEX:
- samples = speex_samples(f->data, f->datalen);
+ samples = speex_samples(f->data.ptr, f->datalen);
break;
case AST_FORMAT_G723_1:
break;
case AST_FORMAT_G723_1:
- samples = g723_samples(f->data, f->datalen);
+ samples = g723_samples(f->data.ptr, f->datalen);
break;
case AST_FORMAT_ILBC:
samples = 240 * (f->datalen / 50);
break;
case AST_FORMAT_ILBC:
samples = 240 * (f->datalen / 50);
case AST_FORMAT_LPC10:
/* assumes that the RTP packet contains one LPC10 frame */
samples = 22 * 8;
case AST_FORMAT_LPC10:
/* assumes that the RTP packet contains one LPC10 frame */
samples = 22 * 8;
- samples += (((char *)(f->data))[7] & 0x1) * 8;
+ samples += (((char *)(f->data.ptr))[7] & 0x1) * 8;
break;
case AST_FORMAT_ULAW:
case AST_FORMAT_ALAW:
break;
case AST_FORMAT_ULAW:
case AST_FORMAT_ALAW:
int ast_frame_adjust_volume(struct ast_frame *f, int adjustment)
{
int count;
int ast_frame_adjust_volume(struct ast_frame *f, int adjustment)
{
int count;
- short *fdata = f->data;
+ short *fdata = f->data.ptr;
short adjust_value = abs(adjustment);
if ((f->frametype != AST_FRAME_VOICE) || (f->subclass != AST_FORMAT_SLINEAR))
short adjust_value = abs(adjustment);
if ((f->frametype != AST_FRAME_VOICE) || (f->subclass != AST_FORMAT_SLINEAR))
if (f1->samples != f2->samples)
return -1;
if (f1->samples != f2->samples)
return -1;
- for (count = 0, data1 = f1->data, data2 = f2->data;
+ for (count = 0, data1 = f1->data.ptr, data2 = f2->data.ptr;
count < f1->samples;
count++, data1++, data2++)
ast_slinear_saturated_add(data1, data2);
count < f1->samples;
count++, data1++, data2++)
ast_slinear_saturated_add(data1, data2);
ps->f.datalen = len;
ps->f.samples = samples;
ps->f.offset = AST_FRIENDLY_OFFSET;
ps->f.datalen = len;
ps->f.samples = samples;
ps->f.offset = AST_FRIENDLY_OFFSET;
+ ps->f.data.ptr = ps->data;
ps->f.delivery.tv_sec = 0;
ps->f.delivery.tv_usec = 0;
ast_write(chan, &ps->f);
ps->f.delivery.tv_sec = 0;
ps->f.delivery.tv_usec = 0;
ast_write(chan, &ps->f);
if (!len)
return NULL;
if (len < 24) {
if (!len)
return NULL;
if (len < 24) {
- rtp->f.data = rtp->rawdata + AST_FRIENDLY_OFFSET;
+ rtp->f.data.ptr = rtp->rawdata + AST_FRIENDLY_OFFSET;
rtp->f.datalen = len - 1;
rtp->f.offset = AST_FRIENDLY_OFFSET;
rtp->f.datalen = len - 1;
rtp->f.offset = AST_FRIENDLY_OFFSET;
- memcpy(rtp->f.data, data + 1, len - 1);
+ memcpy(rtp->f.data.ptr, data + 1, len - 1);
+ rtp->f.data.ptr = NULL;
rtp->f.offset = 0;
rtp->f.datalen = 0;
}
rtp->f.offset = 0;
rtp->f.datalen = 0;
}
rtp->f.mallocd = 0;
rtp->f.datalen = res - hdrlen;
rtp->f.mallocd = 0;
rtp->f.datalen = res - hdrlen;
- rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
+ rtp->f.data.ptr = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
rtp->f.seqno = seqno;
if (rtp->f.subclass == AST_FORMAT_T140 && (int)seqno - (prev_seqno+1) > 0 && (int)seqno - (prev_seqno+1) < 10) {
rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
rtp->f.seqno = seqno;
if (rtp->f.subclass == AST_FORMAT_T140 && (int)seqno - (prev_seqno+1) > 0 && (int)seqno - (prev_seqno+1) < 10) {
- unsigned char *data = rtp->f.data;
+ unsigned char *data = rtp->f.data.ptr;
- memmove(rtp->f.data+3, rtp->f.data, rtp->f.datalen);
+ memmove(rtp->f.data.ptr+3, rtp->f.data.ptr, rtp->f.datalen);
rtp->f.datalen +=3;
*data++ = 0xEF;
*data++ = 0xBF;
rtp->f.datalen +=3;
*data++ = 0xEF;
*data++ = 0xBF;
}
if (rtp->f.subclass == AST_FORMAT_T140RED) {
}
if (rtp->f.subclass == AST_FORMAT_T140RED) {
- unsigned char *data = rtp->f.data;
+ unsigned char *data = rtp->f.data.ptr;
unsigned char *header_end;
int num_generations;
int header_length;
unsigned char *header_end;
int num_generations;
int header_length;
if (!(rtp->f.datalen - len))
return &ast_null_frame;
if (!(rtp->f.datalen - len))
return &ast_null_frame;
+ rtp->f.data.ptr += len;
rtp->f.datalen -= len;
} else if (diff > num_generations && diff < 10) {
len -= 3;
rtp->f.datalen -= len;
} else if (diff > num_generations && diff < 10) {
len -= 3;
+ rtp->f.data.ptr += len;
+ data = rtp->f.data.ptr;
*data++ = 0xEF;
*data++ = 0xBF;
*data = 0xBD;
*data++ = 0xEF;
*data++ = 0xBF;
*data = 0xBD;
for ( x = 0; x < num_generations - diff; x++)
len += data[x * 4 + 3];
for ( x = 0; x < num_generations - diff; x++)
len += data[x * 4 + 3];
+ rtp->f.data.ptr += len;
rtp->f.datalen -= len;
}
}
rtp->f.datalen -= len;
}
}
rtp->lastts = f->ts * 8;
/* Get a pointer to the header */
rtp->lastts = f->ts * 8;
/* Get a pointer to the header */
- rtpheader = (unsigned char *)(f->data - hdrlen);
+ rtpheader = (unsigned char *)(f->data.ptr - hdrlen);
put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
ast_smoother_feed(rtp->smoother, _f);
}
ast_smoother_feed(rtp->smoother, _f);
}
- while ((f = ast_smoother_read(rtp->smoother)) && (f->data)) {
+ while ((f = ast_smoother_read(rtp->smoother)) && (f->data.ptr)) {
if (f->subclass == AST_FORMAT_G722) {
/* G.722 is silllllllllllllly */
f->samples /= 2;
if (f->subclass == AST_FORMAT_G722) {
/* G.722 is silllllllllllllly */
f->samples /= 2;
f = ast_frdup(_f); /*! \bug XXX this might never be free'd. Why do we do this? */
else
f = _f;
f = ast_frdup(_f); /*! \bug XXX this might never be free'd. Why do we do this? */
else
f = _f;
ast_rtp_raw_write(rtp, f, codec);
if (f != _f)
ast_frfree(f);
ast_rtp_raw_write(rtp, f, codec);
if (f != _f)
ast_frfree(f);
oldcodec0 = codec0 = pr0->get_codec(c0);
if (pr1->get_codec && c1->tech_pvt)
oldcodec1 = codec1 = pr1->get_codec(c1);
oldcodec0 = codec0 = pr0->get_codec(c0);
if (pr1->get_codec && c1->tech_pvt)
oldcodec1 = codec1 = pr1->get_codec(c1);
- ast_indicate_data(other, fr->subclass, fr->data, fr->datalen);
+ ast_indicate_data(other, fr->subclass, fr->data.ptr, fr->datalen);
ast_frfree(fr);
} else {
*fo = fr;
ast_frfree(fr);
} else {
*fo = fr;
p0_callback = p2p_callback_enable(c0, p0, &p0_iod[0]);
p1_callback = p2p_callback_enable(c1, p1, &p1_iod[0]);
}
p0_callback = p2p_callback_enable(c0, p0, &p0_iod[0]);
p1_callback = p2p_callback_enable(c1, p1, &p1_iod[0]);
}
- ast_indicate_data(other, fr->subclass, fr->data, fr->datalen);
+ ast_indicate_data(other, fr->subclass, fr->data.ptr, fr->datalen);
ast_frfree(fr);
} else {
*fo = fr;
ast_frfree(fr);
} else {
*fo = fr;
* \param red redundant data structure
*/
static struct ast_frame *red_t140_to_red(struct rtp_red *red) {
* \param red redundant data structure
*/
static struct ast_frame *red_t140_to_red(struct rtp_red *red) {
- unsigned char *data = red->t140red.data;
+ unsigned char *data = red->t140red.data.ptr;
len += data[i*4+3] = red->len[i];
/* add primary data to buffer */
len += data[i*4+3] = red->len[i];
/* add primary data to buffer */
- memcpy(&data[len], red->t140.data, red->t140.datalen);
+ memcpy(&data[len], red->t140.data.ptr, red->t140.datalen);
red->t140red.datalen = len + red->t140.datalen;
/* no primary data and no generations to send */
red->t140red.datalen = len + red->t140.datalen;
/* no primary data and no generations to send */
r->t140.frametype = AST_FRAME_TEXT;
r->t140.subclass = AST_FORMAT_T140RED;
r->t140.frametype = AST_FRAME_TEXT;
r->t140.subclass = AST_FORMAT_T140RED;
- r->t140.data = &r->buf_data;
+ r->t140.data.ptr = &r->buf_data;
r->t140.ts = 0;
r->t140red = r->t140;
r->t140.ts = 0;
r->t140red = r->t140;
- r->t140red.data = &r->t140red_data;
+ r->t140red.data.ptr = &r->t140red_data;
r->t140red.datalen = 0;
r->ti = ti;
r->num_gen = num_gen;
r->t140red.datalen = 0;
r->ti = ti;
r->num_gen = num_gen;
{
if( f->datalen > -1 ) {
struct rtp_red *red = rtp->red;
{
if( f->datalen > -1 ) {
struct rtp_red *red = rtp->red;
- memcpy(&red->buf_data[red->t140.datalen], f->data, f->datalen);
+ memcpy(&red->buf_data[red->t140.datalen], f->data.ptr, f->datalen);
red->t140.datalen += f->datalen;
red->t140.ts = f->ts;
}
red->t140.datalen += f->datalen;
red->t140.ts = f->ts;
}
}
if ((frame_ptr = AST_LIST_REMOVE_HEAD(&sf->queue, frame_list))) {
}
if ((frame_ptr = AST_LIST_REMOVE_HEAD(&sf->queue, frame_list))) {
- frame_data = frame_ptr->data;
+ frame_data = frame_ptr->data.ptr;
if (frame_ptr->samples <= ineed) {
memcpy(offset, frame_data, frame_ptr->samples * sizeof(*offset));
if (frame_ptr->samples <= ineed) {
memcpy(offset, frame_data, frame_ptr->samples * sizeof(*offset));
f->mallocd = 0;
f->offset = AST_FRIENDLY_OFFSET;
f->src = pvt->t->name;
f->mallocd = 0;
f->offset = AST_FRIENDLY_OFFSET;
f->src = pvt->t->name;
+ f->data.ptr = pvt->outbuf;
ast_set_flag(f, AST_FRFLAG_FROM_TRANSLATOR);
ast_set_flag(f, AST_FRFLAG_FROM_TRANSLATOR);
s->f[ifp_no].mallocd = 0;
s->f[ifp_no].seqno = seq_no - i;
s->f[ifp_no].datalen = lengths[i - 1];
s->f[ifp_no].mallocd = 0;
s->f[ifp_no].seqno = seq_no - i;
s->f[ifp_no].datalen = lengths[i - 1];
- s->f[ifp_no].data = (uint8_t *) bufs[i - 1];
+ s->f[ifp_no].data.ptr = (uint8_t *) bufs[i - 1];
s->f[ifp_no].offset = 0;
s->f[ifp_no].src = "UDPTL";
if (ifp_no > 0)
s->f[ifp_no].offset = 0;
s->f[ifp_no].src = "UDPTL";
if (ifp_no > 0)
s->f[ifp_no].mallocd = 0;
s->f[ifp_no].seqno = j;
s->f[ifp_no].datalen = s->rx[l].buf_len;
s->f[ifp_no].mallocd = 0;
s->f[ifp_no].seqno = j;
s->f[ifp_no].datalen = s->rx[l].buf_len;
- s->f[ifp_no].data = s->rx[l].buf;
+ s->f[ifp_no].data.ptr = s->rx[l].buf;
s->f[ifp_no].offset = 0;
s->f[ifp_no].src = "UDPTL";
if (ifp_no > 0)
s->f[ifp_no].offset = 0;
s->f[ifp_no].src = "UDPTL";
if (ifp_no > 0)
s->f[ifp_no].mallocd = 0;
s->f[ifp_no].seqno = seq_no;
s->f[ifp_no].datalen = ifp_len;
s->f[ifp_no].mallocd = 0;
s->f[ifp_no].seqno = seq_no;
s->f[ifp_no].datalen = ifp_len;
- s->f[ifp_no].data = (uint8_t *) ifp;
+ s->f[ifp_no].data.ptr = (uint8_t *) ifp;
s->f[ifp_no].offset = 0;
s->f[ifp_no].src = "UDPTL";
if (ifp_no > 0)
s->f[ifp_no].offset = 0;
s->f[ifp_no].src = "UDPTL";
if (ifp_no > 0)
seq = s->tx_seq_no & 0xFFFF;
/* Cook up the UDPTL packet, with the relevant EC info. */
seq = s->tx_seq_no & 0xFFFF;
/* Cook up the UDPTL packet, with the relevant EC info. */
- len = udptl_build_packet(s, buf, f->data, f->datalen);
+ len = udptl_build_packet(s, buf, f->data.ptr, f->datalen);
if (len > 0 && s->them.sin_port && s->them.sin_addr.s_addr) {
if ((res = sendto(s->fd, buf, len, 0, (struct sockaddr *) &s->them, sizeof(s->them))) < 0)
if (len > 0 && s->them.sin_port && s->them.sin_addr.s_addr) {
if ((res = sendto(s->fd, buf, len, 0, (struct sockaddr *) &s->them, sizeof(s->them))) < 0)
*remainder = *remainder - amt;
outf.frametype = AST_FRAME_VOICE;
outf.subclass = AST_FORMAT_ULAW;
*remainder = *remainder - amt;
outf.frametype = AST_FRAME_VOICE;
outf.subclass = AST_FORMAT_ULAW;
outf.datalen = amt;
outf.samples = amt;
if (ast_write(chan, &outf)) {
outf.datalen = amt;
outf.samples = amt;
if (ast_write(chan, &outf)) {
*remainder = inf->datalen - amt;
outf.frametype = AST_FRAME_VOICE;
outf.subclass = AST_FORMAT_ULAW;
*remainder = inf->datalen - amt;
outf.frametype = AST_FRAME_VOICE;
outf.subclass = AST_FORMAT_ULAW;
outf.datalen = amt;
outf.samples = amt;
if (ast_write(chan, &outf)) {
outf.datalen = amt;
outf.samples = amt;
if (ast_write(chan, &outf)) {
}
/* Write audio frame data into speech engine if possible */
if (fr && fr->frametype == AST_FRAME_VOICE)
}
/* Write audio frame data into speech engine if possible */
if (fr && fr->frametype == AST_FRAME_VOICE)
- ast_speech_write(speech, fr->data, fr->datalen);
+ ast_speech_write(speech, fr->data.ptr, fr->datalen);
break;
case AST_SPEECH_STATE_WAIT:
/* Cue waiting sound if not already playing */
break;
case AST_SPEECH_STATE_WAIT:
/* Cue waiting sound if not already playing */
/* If it's voice, write it to the audio pipe */
if ((agi->audio > -1) && (f->frametype == AST_FRAME_VOICE)) {
/* Write, ignoring errors */
/* If it's voice, write it to the audio pipe */
if ((agi->audio > -1) && (f->frametype == AST_FRAME_VOICE)) {
/* Write, ignoring errors */
- write(agi->audio, f->data, f->datalen);
+ write(agi->audio, f->data.ptr, f->datalen);
return 0;
moh->f.datalen = res;
return 0;
moh->f.datalen = res;
- moh->f.data = buf + AST_FRIENDLY_OFFSET / 2;
+ moh->f.data.ptr = buf + AST_FRIENDLY_OFFSET / 2;
moh->f.samples = ast_codec_get_samples(&moh->f);
if (ast_write(chan, &moh->f) < 0) {
moh->f.samples = ast_codec_get_samples(&moh->f);
if (ast_write(chan, &moh->f) < 0) {
projects / asterisk/asterisk.git / commitdiff