static void *pout_thread_func(void* arg) {
unsigned int data_len = 0;
unsigned int buff_size = 64 * 1024;
unsigned char *data = malloc(buff_size);
h265_encoder *_this = (h265_encoder*) arg;
while ((data_len = read(_this->pout_fd, data, buff_size)) > 0) {
for (int i = 0; i < data_len;) {
if (!_this->in_nal) {
_this->in_nal = true;
_this->nal_len = data[i] << 24 | data[i + 1] << 16 | data[i + 2] << 8 | data[i + 3];
_this->nal_len += 4; //start code
_this->nal_type = (data[i + 4] & 0x7e) >> 1;
if (_this->nal_len > 1024 * 1024) {
printf("something wrong in h264 stream at %d\n", i);
_this->in_nal = false;
break;
}
if (i + _this->nal_len <= data_len) {
void *frame_data = get_frame_data(_this);
_this->callback(data + i, _this->nal_len, frame_data, _this->user_data);
i += _this->nal_len;
_this->in_nal = false;
} else {
_this->nal_pos = 0;
_this->nal_buff = (uint8_t*) malloc(_this->nal_len);
}
} else {
int rest = _this->nal_len - _this->nal_pos;
if (i + rest <= data_len) {
memcpy(_this->nal_buff + _this->nal_pos, data + i, rest);
void *frame_data = get_frame_data(_this);
_this->callback(_this->nal_buff, _this->nal_len, frame_data, _this->user_data);
free(_this->nal_buff);
_this->nal_buff = NULL;
i += rest;
_this->in_nal = false;
} else {
int len = data_len - i;
memcpy(_this->nal_buff + _this->nal_pos, data + i, len);
_this->nal_pos += len;
i += len;
}
}
}
static void
remove_old_requests(ipmi_packet_data_t * data, const nstime_t * curr_time)
{
wmem_list_frame_t * iter = wmem_list_head(data->request_list);
while (iter) {
ipmi_request_t * rq = (ipmi_request_t *) wmem_list_frame_data(iter);
ipmi_frame_data_t * frame = get_frame_data(data, rq->frame_num);
nstime_t delta;
/* calculate time delta */
nstime_delta(&delta, curr_time, &frame->ts);
if (nstime_to_msec(&delta) > response_after_req) {
wmem_list_frame_t * del = iter;
/* proceed to next request */
iter = wmem_list_frame_next(iter);
/* free request data */
wmem_free(wmem_file_scope(), rq);
/* remove list item */
wmem_list_remove_frame(data->request_list, del);
} else {
break;
}
}
}
static void
match_request_response(ipmi_packet_data_t * data, const ipmi_header_t * hdr,
guint flags)
{
/* get current frame */
ipmi_frame_data_t * rs_frame = data->curr_frame;
/* get current command data */
ipmi_cmd_data_t * rs_data = rs_frame->cmd_data[data->curr_level];
/* check if parse response for the first time */
if (!rs_data) {
ipmi_request_t * rq;
/* allocate command data */
rs_data = wmem_new0(wmem_file_scope(), ipmi_cmd_data_t);
/* search for matching request */
rq = get_matched_request(data, hdr, flags);
/* check if matching request is found */
if (rq) {
/* get request frame data */
ipmi_frame_data_t * rq_frame =
get_frame_data(data, rq->frame_num);
/* get command data */
ipmi_cmd_data_t * rq_data = rq_frame->cmd_data[rq->nest_level];
/* save matched frame numbers */
rq_data->matched_frame_num = data->curr_frame_num;
rs_data->matched_frame_num = rq->frame_num;
/* copy saved command data information */
rs_data->saved_data[0] = rq_data->saved_data[0];
rs_data->saved_data[1] = rq_data->saved_data[1];
/* remove request from the list */
wmem_list_remove(data->request_list, rq);
/* delete request data */
wmem_free(wmem_file_scope(), rq);
}
/* save command data pointer in frame */
rs_frame->cmd_data[data->curr_level] = rs_data;
}
}
void run()
{
if (drive->get() == 0)
current_frame = (int)(engine->vtime * get_frame_rate());
else
current_frame = (int)(time->get() * get_frame_rate());
if (current_frame != previous_frame) {
//printf("r-");
bitm.data=(long unsigned int*)get_frame_data(current_frame);
bitm.timestamp++;
previous_frame = current_frame;
// printf("t-");
}
if (bitm.valid && bitm_timestamp != bitm.timestamp)
{
bitm_timestamp = bitm.timestamp;
result1->set(bitm);
loading_done = true;
}
if (current_frame>num_frames) current_frame=0;
}
const void * rs_get_frame_data(const rs_device * device, rs_stream stream, rs_error ** error) try
{
VALIDATE_NOT_NULL(device);
VALIDATE_ENUM(stream);
return device->get_frame_data(stream);
}
void main(void)
{
u32 cnt = 0;
Init_Device(); //use code generate by silicon tool.
TI0 = 1; //make uart0 in send enable status
//-----------------------------------------
event_init();
//-----------------------------------------add a timer event for printf
#if 0
{
timer_ev_unit_st xdata unit;
timer_event_init();
unit.event = EVENT_ID_TIMER_DEBUG;
unit.time = TRIG_TIME;
unit.callback = func_for_debug;
timer_event_add(&unit);
}
#endif
//-----------------------------------------
report_handler_init();
// while(cnt++<65536);
// config_sensor();
test_func();
Usb_Init();
Interrupts_Init(); //open relative interrupt.
//g_panel_point.ID = 0;
//g_panel_point.x = 0;
//g_panel_point.y = 0;
while (1)
{
event_process();
if(g_work_style == WORK_STYLE_PREVIEW)
{
get_frame_data();
//while(EP_STATUS[1] != 0);
send_debug_info_to_host(REPORT_ID_IN_DBGINFO);
}
else if(g_work_style == WORK_STYLE_CAL)
{
}
else if(g_work_style == WORK_STYLE_NOMAL)
{ /*
g_panel_point.x +=200;
g_panel_point.y +=100;
g_panel_point.x %= 1600;
g_panel_point.y %= 900;
fill_hid_packet(&g_panel_point,1);
send_debug_info_to_host(REPORT_ID_IN_MTOUCH);
*/
}
}
}
static void process_packet_header (isma_enc_rtp_data_t *iptr)
{
rtp_packet *pak;
uint32_t frame_len;
uint32_t prev_frame_len;
uint32_t IV;
uint32_t delta_IV;
uint16_t header_len;
uint32_t retvalue;
pak = iptr->m_vft->get_next_pak(iptr->m_ifptr, NULL, 1);
if (pak == NULL) {
return;
}
#ifdef DEBUG_ISMA_AAC
isma_message(LOG_DEBUG, ismaencrtp,
"processing pak seq %d ts %x len %d",
pak->rtp_pak_seq, pak->rtp_pak_ts, pak->rtp_data_len);
#endif
// This pak has not had it's header processed
// length in bytes
if (pak->rtp_data_len == 0) {
iptr->m_vft->free_pak(pak);
isma_message(LOG_ERR, ismaencrtp, "RTP audio packet with data length of 0");
return;
}
header_len = ntohs(*(unsigned short *)pak->rtp_data);
//fprintf(stdout, "----->AWV, process_packet_header header len %u\n", header_len);
if (header_len < iptr->m_min_first_header_bits) {
// bye bye, frame...
iptr->m_vft->free_pak(pak);
isma_message(LOG_ERR, ismaencrtp, "ISMA rtp - header len %d less than min %d",
header_len, iptr->m_min_first_header_bits);
return;
}
iptr->m_header_bitstream.init(&pak->rtp_data[sizeof(uint16_t)],
header_len);
// this is the first frame in a packet so:
// next should be 4 bytes of IV, what is retvalue if this returns??? awv
if (iptr->m_header_bitstream.getbits(32, &IV) != 0)
return;
// what is retvalue here if this returns??? awv
if (iptr->m_header_bitstream.getbits(iptr->m_fmtp->size_length, &frame_len) != 0)
return;
iptr->m_header_bitstream.getbits(iptr->m_fmtp->index_length, &retvalue);
get_au_header_bits(iptr);
#ifdef DEBUG_ISMA_AAC
uint64_t msec = iptr->m_vft->rtp_ts_to_msec(iptr->m_ifptr, pak->rtp_pak_ts,
pak->pd.rtp_pd_timestamp,
1);
isma_message(LOG_DEBUG, ismaencrtp,
"1st - header len %u frame len %u ts %x U64",
header_len, frame_len, pak->rtp_pak_ts, msec);
#endif
if (frame_len == 0) {
iptr->m_vft->free_pak(pak);
return;
}
uint8_t *frame_ptr;
isma_frame_data_t *frame_data;
uint32_t ts;
ts = pak->rtp_pak_ts;
frame_data = get_frame_data(iptr);
frame_data->pak = pak;
// frame pointer is after header_len + header_len size. Header_len
// is in bits - add 7, divide by 8 to get padding correctly.
frame_data->frame_ptr = &pak->rtp_data[((header_len + 7) / 8)
+ sizeof(uint16_t)];
prev_frame_len = frame_len;
frame_data->frame_len = frame_len;
frame_data->rtp_timestamp = ts;
frame_data->IV = IV;
//fprintf(stdout, "===>AWV A1, Len: %u IV %u\n", frame_len, IV);
// Check if frame is fragmented
// frame_len plus the length of the 2 headers
uint32_t frag_check = frame_len + sizeof(uint16_t);
frag_check += iptr->m_fmtp->size_length / 8;
if ((iptr->m_fmtp->size_length % 8) != 0) frag_check++;
if (frag_check > pak->rtp_data_len) {
#ifdef DEBUG_ISMA_AAC
isma_message(LOG_DEBUG, ismaencrtp, "Frame is fragmented");
#endif
frame_data->is_fragment = 1;
int err = process_fragment(iptr, pak, frame_data);
if (err == 1)
isma_message(LOG_ERR, ismaencrtp, "Error in processing the fragment");
return;
}
else {
#ifdef DEBUG_ISMA_AAC
isma_message(LOG_DEBUG, ismaencrtp, "Frame is not fragmented");
#endif
frame_data->is_fragment = 0;
frame_data->frag_data = NULL;
}
int error = insert_frame_data(iptr, frame_data);
frame_ptr = frame_data->frame_ptr + frame_data->frame_len;
while (iptr->m_header_bitstream.bits_remain() >= iptr->m_min_header_bits) {
uint32_t stride;
// if deltaIVLength is not zero, frames subsequent to the first frame
// will have a deltaIV, otherwise nothing. in either case, need to
// derive the IV.
// next should be deltaIV, what is retvalue if this returns??? awv
if (iptr->m_fmtp->ISMACrypIVDeltaLength == 2 ) {
if (iptr->m_header_bitstream.getbits(16, &delta_IV) != 0)
return;
else {
IV = IV + prev_frame_len + delta_IV;
}
}
else {
if (iptr->m_fmtp->ISMACrypIVDeltaLength == 1 ) {
if (iptr->m_header_bitstream.getbits(8, &delta_IV) != 0)
return;
else {
IV = IV + prev_frame_len + delta_IV;
}
}
else {
IV = IV + prev_frame_len;
}
}
//fprintf(stdout, "=========>AWV, Delta IV %u Delta IV len %d\n", deltaIV,
// iptr->m_fmtp->ISMACrypIVDeltaLength);
iptr->m_header_bitstream.getbits(iptr->m_fmtp->size_length, &frame_len);
iptr->m_header_bitstream.getbits(iptr->m_fmtp->index_delta_length, &stride);
get_au_header_bits(iptr);
ts += (iptr->m_rtp_ts_add * (1 + stride));
#ifdef DEBUG_ISMA_AAC
msec = iptr->m_vft->rtp_ts_to_msec(iptr->m_ifptr,
pak->rtp_pak_ts,
pak->pd.rtp_pd_timestamp,
1);
isma_message(LOG_DEBUG, ismaencrtp,
"Stride %d len %d ts %x U64",
stride, frame_len, ts, msec);
#endif
frame_data = get_frame_data(iptr);
frame_data->pak = pak;
frame_data->is_fragment = 0;
frame_data->frag_data = NULL;
frame_data->frame_ptr = frame_ptr;
prev_frame_len = frame_len;
frame_data->frame_len = frame_len;
frame_ptr += frame_len;
frame_data->IV = IV;
frame_data->rtp_timestamp = ts;
//fprintf(stdout, "===>AWV A2, Len: %u IV %u\n", frame_len, IV);
error |= insert_frame_data(iptr, frame_data);
}
if (error == 0 && frame_data != NULL) {
frame_data->last_in_pak = 1;
}
else {
isma_frame_data_t *p, *last = NULL;
p = iptr->m_frame_data_head;
while (p != NULL) {
if (p->pak == pak) last = p;
p = p->frame_data_next;
}
if (last != NULL) {
last->last_in_pak = 1;
isma_message(LOG_WARNING, ismaencrtp, "error at end - marked ts %x", last->rtp_timestamp);
} else {
// Didn't find pak in list. Weird
isma_message(LOG_ERR, ismaencrtp,
"Decoded packet with RTP timestamp %x and didn't"
"see any good frames", pak->rtp_pak_ts);
iptr->m_vft->free_pak(pak);
return;
}
}
if (iptr->m_fmtp->auxiliary_data_size_length > 0) {
iptr->m_header_bitstream.byte_align();
uint32_t aux_len;
iptr->m_header_bitstream.getbits(iptr->m_fmtp->auxiliary_data_size_length, &aux_len);
aux_len = (aux_len + 7) / 8;
#ifdef DEBUG_ISMA_AAC
isma_message(LOG_DEBUG, ismaencrtp, "Adding %d bytes for aux data size", aux_len);
#endif
isma_frame_data_t *p;
p = iptr->m_frame_data_head;
while (p != NULL) {
if (p->pak == pak) {
p->frame_ptr += aux_len;
}
p = p->frame_data_next;
}
}
}
static int
dissect_ipmi_cmd(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
gint hf_parent_item, gint ett_tree, const ipmi_context_t * ctx)
{
ipmi_packet_data_t * data;
ipmi_netfn_t * cmd_list;
ipmi_cmd_t * cmd;
proto_item * ti;
proto_tree * cmd_tree = NULL, * tmp_tree;
guint8 prev_level, cc_val;
guint offset, siglen, is_resp;
const char * cc_str, * netfn_str;
/* get packet data */
data = get_packet_data(pinfo);
if (!data) {
return 0;
}
/* get prefix length */
siglen = ipmi_getsiglen(ctx->hdr.netfn);
/* get response flag */
is_resp = ctx->hdr.netfn & 1;
/* check message length */
if (tvb_captured_length(tvb) < ctx->hdr_len + siglen + is_resp
+ !(ctx->flags & IPMI_D_NO_CKS)) {
/* don bother with anything */
return call_data_dissector(tvb, pinfo, tree);
}
/* save nest level */
prev_level = data->curr_level;
/* assign next nest level */
data->curr_level = data->next_level;
/* increment next nest level */
data->next_level++;
/* check for the first invocation */
if (!data->curr_level) {
/* get current frame data */
data->curr_frame = get_frame_data(data, pinfo->num);
data->curr_frame_num = pinfo->num;
/* copy frame timestamp */
memcpy(&data->curr_frame->ts, &pinfo->abs_ts, sizeof(nstime_t));
/* cache channel and direction */
data->curr_channel = ctx->hdr.channel;
data->curr_dir = ctx->hdr.dir;
/* remove requests which are too old */
remove_old_requests(data, &pinfo->abs_ts);
}
if (data->curr_level < MAX_NEST_LEVEL) {
if (ctx->hdr.netfn & 1) {
/* perform request/response matching */
match_request_response(data, &ctx->hdr, ctx->flags);
} else {
/* add request to the list for later matching */
add_request(data, &ctx->hdr);
}
}
/* get command list by network function code */
cmd_list = ipmi_getnetfn(ctx->hdr.netfn,
tvb_get_ptr(tvb, ctx->hdr_len + is_resp, siglen));
/* get command descriptor */
cmd = ipmi_getcmd(cmd_list, ctx->hdr.cmd);
/* check if response */
if (is_resp) {
/* get completion code */
cc_val = tvb_get_guint8(tvb, ctx->hdr_len);
/* get completion code desc */
cc_str = ipmi_get_completion_code(cc_val, cmd);
} else {
cc_val = 0;
cc_str = NULL;
}
/* check if not inside a message */
if (!data->curr_level) {
/* add packet info */
add_command_info(pinfo, cmd, is_resp, cc_val, cc_str,
ctx->flags & IPMI_D_BROADCAST ? TRUE : FALSE);
}
if (tree) {
/* add parent node */
if (!data->curr_level) {
ti = proto_tree_add_item(tree, hf_parent_item, tvb, 0, -1, ENC_NA);
cmd_tree = proto_item_add_subtree(ti, ett_tree);
} else {
char str[ITEM_LABEL_LENGTH];
if (is_resp) {
g_snprintf(str, ITEM_LABEL_LENGTH, "Rsp, %s, %s",
cmd->desc, cc_str);
} else {
g_snprintf(str, ITEM_LABEL_LENGTH, "Req, %s", cmd->desc);
}
if (proto_registrar_get_ftype(hf_parent_item) == FT_STRING) {
ti = proto_tree_add_string(tree, hf_parent_item, tvb, 0, -1, str);
cmd_tree = proto_item_add_subtree(ti, ett_tree);
}
else
cmd_tree = proto_tree_add_subtree(tree, tvb, 0, -1, ett_tree, NULL, str);
}
if (data->curr_level < MAX_NEST_LEVEL) {
/* check if response */
if (ctx->hdr.netfn & 1) {
/* get current command data */
ipmi_cmd_data_t * rs_data =
data->curr_frame->cmd_data[data->curr_level];
if (rs_data->matched_frame_num) {
nstime_t ns;
/* add "Request to:" field */
ti = proto_tree_add_uint(cmd_tree, hf_ipmi_response_to,
tvb, 0, 0, rs_data->matched_frame_num);
/* mark field as a generated one */
PROTO_ITEM_SET_GENERATED(ti);
/* calculate delta time */
nstime_delta(&ns, &pinfo->abs_ts,
&get_frame_data(data,
rs_data->matched_frame_num)->ts);
/* add "Response time" field */
ti = proto_tree_add_time(cmd_tree, hf_ipmi_response_time,
tvb, 0, 0, &ns);
/* mark field as a generated one */
PROTO_ITEM_SET_GENERATED(ti);
}
} else {
/* get current command data */
ipmi_cmd_data_t * rq_data =
data->curr_frame->cmd_data[data->curr_level];
if (rq_data->matched_frame_num) {
/* add "Response in:" field */
ti = proto_tree_add_uint(cmd_tree, hf_ipmi_response_in,
tvb, 0, 0, rq_data->matched_frame_num);
/* mark field as a generated one */
PROTO_ITEM_SET_GENERATED(ti);
}
}
}
/* set starting offset */
offset = 0;
/* check if message is broadcast */
if (ctx->flags & IPMI_D_BROADCAST) {
/* skip first byte */
offset++;
}
/* check if session handle is specified */
if (ctx->flags & IPMI_D_SESSION_HANDLE) {
/* add session handle field */
proto_tree_add_item(cmd_tree, hf_ipmi_session_handle,
tvb, offset++, 1, ENC_LITTLE_ENDIAN);
}
/* check if responder address is specified */
if (ctx->flags & IPMI_D_TRG_SA) {
/* add response address field */
proto_tree_add_item(cmd_tree, hf_ipmi_header_trg, tvb,
offset++, 1, ENC_LITTLE_ENDIAN);
}
/* get NetFn string */
netfn_str = ipmi_getnetfnname(ctx->hdr.netfn, cmd_list);
/* Network function + target LUN */
tmp_tree = proto_tree_add_subtree_format(cmd_tree, tvb, offset, 1,
ett_header_byte_1, NULL, "Target LUN: 0x%02x, NetFN: %s %s (0x%02x)",
ctx->hdr.rs_lun, netfn_str,
is_resp ? "Response" : "Request", ctx->hdr.netfn);
/* add Net Fn */
proto_tree_add_uint_format(tmp_tree, hf_ipmi_header_netfn, tvb,
offset, 1, ctx->hdr.netfn << 2,
"NetFn: %s %s (0x%02x)", netfn_str,
is_resp ? "Response" : "Request", ctx->hdr.netfn);
proto_tree_add_item(tmp_tree, hf_ipmi_header_trg_lun, tvb,
offset++, 1, ENC_LITTLE_ENDIAN);
/* check if cks1 is specified */
if (!(ctx->flags & IPMI_D_NO_CKS)) {
guint8 cks = tvb_get_guint8(tvb, offset);
/* Header checksum */
if (ctx->cks1) {
guint8 correct = cks - ctx->cks1;
proto_tree_add_uint_format_value(cmd_tree, hf_ipmi_header_crc,
tvb, offset++, 1, cks,
"0x%02x (incorrect, expected 0x%02x)", cks, correct);
} else {
proto_tree_add_uint_format_value(cmd_tree, hf_ipmi_header_crc,
tvb, offset++, 1, cks,
"0x%02x (correct)", cks);
}
}
/* check if request address is specified */
if (!(ctx->flags & IPMI_D_NO_RQ_SA)) {
/* add request address field */
proto_tree_add_item(cmd_tree, hf_ipmi_header_src, tvb,
offset++, 1, ENC_LITTLE_ENDIAN);
}
/* check if request sequence is specified */
if (!(ctx->flags & IPMI_D_NO_SEQ)) {
/* Sequence number + source LUN */
tmp_tree = proto_tree_add_subtree_format(cmd_tree, tvb, offset, 1,
ett_header_byte_4, NULL, "%s: 0x%02x, SeqNo: 0x%02x",
(ctx->flags & IPMI_D_TMODE) ? "Bridged" : "Source LUN",
ctx->hdr.rq_lun, ctx->hdr.rq_seq);
if (ctx->flags & IPMI_D_TMODE) {
proto_tree_add_item(tmp_tree, hf_ipmi_header_bridged,
tvb, offset, 1, ENC_LITTLE_ENDIAN);
} else {
proto_tree_add_item(tmp_tree, hf_ipmi_header_src_lun,
tvb, offset, 1, ENC_LITTLE_ENDIAN);
}
/* print seq no */
proto_tree_add_item(tmp_tree, hf_ipmi_header_sequence, tvb,
offset++, 1, ENC_LITTLE_ENDIAN);
}
/* command code */
proto_tree_add_uint_format_value(cmd_tree, hf_ipmi_header_command,
tvb, offset++, 1, ctx->hdr.cmd, "%s (0x%02x)",
cmd->desc, ctx->hdr.cmd);
if (is_resp) {
/* completion code */
proto_tree_add_uint_format_value(cmd_tree,
hf_ipmi_header_completion, tvb, offset++, 1,
cc_val, "%s (0x%02x)", cc_str, cc_val);
}
if (siglen) {
/* command prefix (if present) */
ti = proto_tree_add_item(cmd_tree, hf_ipmi_header_sig, tvb,
offset, siglen, ENC_NA);
proto_item_append_text(ti, " (%s)", netfn_str);
}
}
if (tree || (cmd->flags & CMD_CALLRQ)) {
/* calculate message data length */
guint data_len = tvb_captured_length(tvb)
- ctx->hdr_len
- siglen
- (is_resp ? 1 : 0)
- !(ctx->flags & IPMI_D_NO_CKS);
/* create data subset */
tvbuff_t * data_tvb = tvb_new_subset_length(tvb,
ctx->hdr_len + siglen + (is_resp ? 1 : 0), data_len);
/* Select sub-handler */
ipmi_cmd_handler_t hnd = is_resp ? cmd->parse_resp : cmd->parse_req;
if (hnd && tvb_captured_length(data_tvb)) {
/* create data field */
tmp_tree = proto_tree_add_subtree(cmd_tree, data_tvb, 0, -1, ett_data, NULL, "Data");
/* save current command */
data->curr_hdr = &ctx->hdr;
/* save current completion code */
data->curr_ccode = cc_val;
/* call command parser */
hnd(data_tvb, pinfo, tmp_tree);
}
}
/* check if cks2 is specified */
if (tree && !(ctx->flags & IPMI_D_NO_CKS)) {
guint8 cks;
/* get cks2 offset */
offset = tvb_captured_length(tvb) - 1;
/* get cks2 */
cks = tvb_get_guint8(tvb, offset);
/* Header checksum */
if (ctx->cks2) {
guint8 correct = cks - ctx->cks2;
proto_tree_add_uint_format_value(cmd_tree, hf_ipmi_data_crc,
tvb, offset, 1, cks,
"0x%02x (incorrect, expected 0x%02x)", cks, correct);
} else {
proto_tree_add_uint_format_value(cmd_tree, hf_ipmi_data_crc,
tvb, offset, 1, cks,
"0x%02x (correct)", cks);
}
}
/* decrement next nest level */
data->next_level = data->curr_level;
/* restore previous nest level */
data->curr_level = prev_level;
return tvb_captured_length(tvb);
}
const void * rs_get_detached_frame_data(const rs_frame_ref * frame_ref, rs_error ** error) try
{
VALIDATE_NOT_NULL(frame_ref);
return frame_ref->get_frame_data();
}
static void process_packet_header (isma_rtp_data_t *iptr)
{
rtp_packet *pak;
uint32_t frame_len;
uint16_t header_len;
uint32_t retvalue;
pak = iptr->m_vft->get_head_and_check(iptr->m_ifptr, false, 0);
if (pak == NULL) {
return;
}
#ifdef DEBUG_ISMA_AAC
isma_message(LOG_DEBUG, ismartp,
"processing pak seq %d ts %x len %d",
pak->rtp_pak_seq, pak->rtp_pak_ts, pak->rtp_data_len);
#endif
// This pak has not had it's header processed
// length in bytes
if (pak->rtp_data_len == 0) {
iptr->m_vft->free_pak(pak);
isma_message(LOG_ERR, ismartp, "RTP audio packet with data length of 0");
return;
}
header_len = ntohs(*(unsigned short *)pak->rtp_data);
if (header_len < iptr->m_min_first_header_bits) {
// bye bye, frame...
iptr->m_vft->free_pak(pak);
isma_message(LOG_ERR, ismartp, "ISMA rtp - header len %d less than min %d",
header_len, iptr->m_min_first_header_bits);
return;
}
iptr->m_header_bitstream.init(&pak->rtp_data[sizeof(uint16_t)],
header_len);
if (iptr->m_header_bitstream.getbits(iptr->m_fmtp->size_length, &frame_len) != 0)
return;
iptr->m_header_bitstream.getbits(iptr->m_fmtp->index_length, &retvalue);
get_au_header_bits(iptr);
#ifdef DEBUG_ISMA_AAC
uint64_t msec = iptr->m_vft->rtp_ts_to_msec(iptr->m_ifptr, pak->rtp_pak_ts,
pak->pd.rtp_pd_timestamp,
1);
isma_message(LOG_DEBUG, ismartp,
"1st - header len %u frame len %u ts %x "U64,
header_len, frame_len, pak->rtp_pak_ts, msec);
#endif
if (frame_len == 0) {
iptr->m_vft->free_pak(pak);
return;
}
uint8_t *frame_ptr;
isma_frame_data_t *frame_data;
uint32_t ts;
ts = pak->rtp_pak_ts;
frame_data = get_frame_data(iptr);
frame_data->pak = pak;
// frame pointer is after header_len + header_len size. Header_len
// is in bits - add 7, divide by 8 to get padding correctly.
frame_data->frame_ptr = &pak->rtp_data[((header_len + 7) / 8)
+ sizeof(uint16_t)];
frame_data->frame_len = frame_len;
frame_data->rtp_timestamp = ts;
// Check if frame is fragmented
// frame_len plus the length of the 2 headers
uint32_t frag_check = frame_len + sizeof(uint16_t);
frag_check += iptr->m_fmtp->size_length / 8;
if ((iptr->m_fmtp->size_length % 8) != 0) frag_check++;
if (frag_check > pak->rtp_data_len) {
#ifdef DEBUG_ISMA_AAC
isma_message(LOG_DEBUG, ismartp, "Frame is fragmented");
#endif
frame_data->is_fragment = 1;
int err = process_fragment(iptr, pak, frame_data);
if (err == 1)
isma_message(LOG_ERR, ismartp, "Error in processing the fragment");
return;
}
else {
#ifdef DEBUG_ISMA_AAC
isma_message(LOG_DEBUG, ismartp, "Frame is not fragmented");
#endif
frame_data->is_fragment = 0;
frame_data->frag_data = NULL;
}
int error = insert_frame_data(iptr, frame_data);
frame_ptr = frame_data->frame_ptr + frame_data->frame_len;
while (iptr->m_header_bitstream.bits_remain() >= iptr->m_min_header_bits) {
uint32_t stride = 0;
iptr->m_header_bitstream.getbits(iptr->m_fmtp->size_length, &frame_len);
iptr->m_header_bitstream.getbits(iptr->m_fmtp->index_delta_length, &stride);
get_au_header_bits(iptr);
ts += (iptr->m_rtp_ts_add * (1 + stride));
#ifdef DEBUG_ISMA_AAC
msec = iptr->m_vft->rtp_ts_to_msec(iptr->m_ifptr,
pak->rtp_pak_ts,
pak->pd.rtp_pd_timestamp,
1);
isma_message(LOG_DEBUG, ismartp,
"Stride %d len %d ts %x "U64,
stride, frame_len, ts, msec);
#endif
frame_data = get_frame_data(iptr);
frame_data->pak = pak;
frame_data->is_fragment = 0;
frame_data->frag_data = NULL;
frame_data->frame_ptr = frame_ptr;
frame_data->frame_len = frame_len;
frame_ptr += frame_len;
frame_data->rtp_timestamp = ts;
error |= insert_frame_data(iptr, frame_data);
}
if (error == 0 && frame_data != NULL) {
frame_data->last_in_pak = 1;
}
else {
isma_frame_data_t *p, *last = NULL;
p = iptr->m_frame_data_head;
while (p != NULL) {
if (p->pak == pak) last = p;
p = p->frame_data_next;
}
if (last != NULL) {
last->last_in_pak = 1;
isma_message(LOG_WARNING, ismartp, "error at end - marked ts %x", last->rtp_timestamp);
} else {
// Didn't find pak in list. Weird
isma_message(LOG_ERR, ismartp,
"Decoded packet with RTP timestamp %x and didn't"
"see any good frames", pak->rtp_pak_ts);
iptr->m_vft->free_pak(pak);
return;
}
}
if (iptr->m_fmtp->auxiliary_data_size_length > 0) {
iptr->m_header_bitstream.byte_align();
uint32_t aux_len = 0;
iptr->m_header_bitstream.getbits(iptr->m_fmtp->auxiliary_data_size_length, &aux_len);
aux_len = (aux_len + 7) / 8;
#ifdef DEBUG_ISMA_AAC
isma_message(LOG_DEBUG, ismartp, "Adding %d bytes for aux data size", aux_len);
#endif
isma_frame_data_t *p;
p = iptr->m_frame_data_head;
while (p != NULL) {
if (p->pak == pak) {
p->frame_ptr += aux_len;
}
p = p->frame_data_next;
}
}
}
