u16 r8712_read16(struct _adapter *adapter, u32 addr)
{
struct io_queue *pio_queue = adapter->pio_queue;
struct intf_hdl *pintfhdl = &(pio_queue->intf);
u16 (*_read16)(struct intf_hdl *pintfhdl, u32 addr);
_read16 = pintfhdl->io_ops._read16;
return _read16(pintfhdl, addr);
}
u16 _rtw_read16(_adapter *adapter, u32 addr)
{
u16 r_val;
//struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue;
struct io_priv *pio_priv = &adapter->iopriv;
struct intf_hdl *pintfhdl = &(pio_priv->intf);
u16 (*_read16)(struct intf_hdl *pintfhdl, u32 addr);
_read16 = pintfhdl->io_ops._read16;
r_val = _read16(pintfhdl, addr);
return rtw_le16_to_cpu(r_val);
}
u16 read16(_adapter *adapter, u32 addr)
{
u16 r_val;
struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue;
struct intf_hdl *pintfhdl = &(pio_queue->intf);
u16 (*_read16)(struct intf_hdl *pintfhdl, u32 addr);
_func_enter_;
_read16 = pintfhdl->io_ops._read16;
r_val = _read16(pintfhdl, addr);
_func_exit_;
return r_val;
}
u16 _rtw_read16(struct adapter *adapter, u32 addr)
{
u16 r_val;
struct io_priv *pio_priv = &adapter->iopriv;
struct intf_hdl *pintfhdl = &(pio_priv->intf);
u16 (*_read16)(struct intf_hdl *pintfhdl, u32 addr);
_func_enter_;
_read16 = pintfhdl->io_ops._read16;
r_val = _read16(pintfhdl, addr);
_func_exit_;
return r_val;
}
u16 rtw_read16(_adapter *adapter, u32 addr)
{
u16 r_val;
//struct io_queue *pio_queue = (struct io_queue *)adapter->pio_queue;
struct io_priv *pio_priv = &adapter->iopriv;
struct intf_hdl *pintfhdl = &(pio_priv->intf);
u16 (*_read16)(struct intf_hdl *pintfhdl, u32 addr);
_irqL irqL;
_func_enter_;
_read16 = pintfhdl->io_ops._read16;
_enter_critical_mutex(&pintfhdl->io_mutex, &irqL);
r_val = _read16(pintfhdl, addr);
_exit_critical_mutex(&pintfhdl->io_mutex, &irqL);
_func_exit_;
return r_val;
}
int32_t aac_rtp_dump(stream_state_t* audio){//pkt_format_data_t *pktdata, indinfo_t ind){
uint8_t *buf,*pld,*auh;
uint32_t pkt_size,offset,numNALs,i;
uint16_t word16,bits16;
FILE* fout;
pkt_format_data_t *pktdata;
bitstream_state_t *bs;
pktdata = &audio->pkt;
buf = pktdata->data;
pkt_size = pktdata->size;
fout = pktdata->fout;
pld = buf+12;
bits16 = _read16(pld,0);
/*
Each NAL would have to be preceeded by an ADTS header.
NAL boundaries are indentified as follows:
x---RTP header(12)---x---AU header(y) --x--NAL1 NAL2 .... NALk--x
AU header
|- Let s = sizeLength,d = indexDeltaLength, i = indexLength in bits obtained from SDP.
|-> x--AU hdr size y in bits (16 bits) --x--NAL1len(s)SeqnumofNAL1(d)--x...x--NALklen(s)SeqnumofNALk(d)--x
*/
word16=bits16/8;
numNALs = (int32_t)(bits16/(audio->ind.sizelen+audio->ind.deltalen));
// numNALs/=8;
auh = buf+12+2;
// auh+=2; //account for size of auh
bs = bio_init_bitstream(auh,word16);
offset = 12+2+word16;
pkt_size-=offset;
pld = buf+offset;
for(i=0;i<numNALs;i++){
audio->adts.sample_len = bio_read_bits(bs,audio->ind.sizelen+audio->ind.deltalen);
audio->adts.sample_len>>=audio->ind.deltalen;
// audio->adts.sample_len/=8;
aac_add_adts(audio);
nkn_vfs_fwrite(pld,audio->adts.sample_len,sizeof(uint8_t),fout);
pld+=audio->adts.sample_len;
auh+=((audio->ind.sizelen+audio->ind.deltalen)/8);
}
return VPE_SUCCESS;
}
int32_t
get_nal_size( uint8_t *data,uint8_t NALlen)
{
uint32_t nal_uint;
uint16_t nal_short;
uint8_t nal_char;
int32_t nal_size;
if(NALlen == 4){
nal_uint = _read32(data,0);
nal_size = (int32_t)(nal_uint);
}
if(NALlen == 2){
nal_short = _read16(data,0);
nal_size = (int32_t)(nal_short);
}
if(NALlen == 1){
nal_char = *data;
nal_size = (int32_t)(nal_char);
}
return nal_size;
}
int32_t
get_num_NALs_AU(uint8_t* data,uint8_t NALlen,int32_t data_size)
{
int32_t data_left = data_size,nal_size,num_NALS = 0;
while(data_left>0){
if(NALlen ==4){
nal_size = _read32(data,0);
num_NALS++;
data_left-=nal_size+4;
if(data_left<0)
break;
data+=nal_size+4;
}
else if(NALlen == 2){
nal_size = _read16(data,0);
num_NALS++;
data_left-=nal_size+2;
if(data_left<0)
break;
data+=nal_size+2;
}
else{
nal_size = *data;
num_NALS++;
data_left-=nal_size+1;
if(data_left<0)
break;
data+=nal_size+1;
}
}
return num_NALS;
}
int
_read (int fd, void *ptr, size_t len)
{
return _read16 ((short)fd, ptr, (short)len);
}
int32_t h264_rtp_dump(pkt_format_data_t *pktdata){
/*
Core level function that blindly extracts the h.264 payload and dumps into the file specified.
Does not check for sequence numbers:
1. Special handling required for SPS/PPs can be a part of separate function.
2. For each NAL - being represented by the NAL octet in the RTP header, add Annex B ompliance - 0x00000001
*/
uint8_t *buf,*pld,uword;
uint32_t pkt_size,pos=0,word32,ts;
static uint32_t second_ts = 0;
FILE* fout;
buf = pktdata->data;
pkt_size = pktdata->size;
fout = pktdata->fout;
ts = _read32(buf,4);
//if(ts == 511281197)
//{
// ts =511281197;
// ts= ts;
//}
#if 0
if(pktdata->prev_time==0 && (ts!= pktdata->prev_time)){
pktdata->frame_rate = 90000/(ts-pktdata->prev_time);
pktdata->prev_time = ts;
}
#endif
#if 0//by suma
if(pktdata->prev_time==0 && pktdata->frame_rate ==0)
pktdata->prev_time = ts;
if(pktdata->prev_time!=ts &&pktdata->frame_rate ==0){
second_ts = ts;
pktdata->frame_rate = 90000/(ts-pktdata->prev_time);
}
if(ts<second_ts && pktdata->frame_rate && (ts>pktdata->prev_time)){
second_ts = ts;
pktdata->frame_rate = 90000/(ts-pktdata->prev_time);
}
#else
if(pktdata->prev_time != ts)
{
pktdata->num_frames++;
}
pktdata->prev_time = ts;
//nkn_vfs_fwrite(ts,1,sizeof(uint32_t),fout_data);
//nkn_vfs_fwrite(pktdata5->prev_time,1,sizeof(uint32_t),fout_data);
#endif
pld = buf+12;
uword = pld[pos]&0x1F;
if(uword == 0)
return VPE_ERROR;
if((uword <=MAX_SINGLE_NALU) && (uword >=MIN_SINGLE_NALU)){
/*single NALU*/
word32 = NALU_DELIMIT;
word32 = htonl(word32);
nkn_vfs_fwrite(&word32,1,sizeof(uint32_t),fout);
nkn_vfs_fwrite(pld,pkt_size-12,sizeof(uint8_t),fout);
}
else if(uword ==STAPA){
/*STAPS */
uint32_t wsize;
uint16_t NALsize;
pos++;
wsize = pkt_size-12-1;
while(wsize){
NALsize = _read16(pld,pos);
pos+=2;
word32 = NALU_DELIMIT;
word32 = htonl(word32);
nkn_vfs_fwrite(&word32,1,sizeof(uint32_t),fout);
nkn_vfs_fwrite(&pld[pos],NALsize,sizeof(uint8_t),fout);
pos+=NALsize;
wsize= wsize - NALsize - 2;
}
}
else if(uword == FUA){
/*Fragmented unit*/
uint8_t S,nal_h=0;
uint32_t wsize;
nal_h = pld[pos]>>5;
nal_h<<=5;
pos++;
nal_h|=(pld[pos]&0x1F);
uword = pld[pos++];
S = uword >> 7;
if(S){
word32 = NALU_DELIMIT;
word32 = htonl(word32);
nkn_vfs_fwrite(&word32,1,sizeof(uint32_t),fout);
nkn_vfs_fwrite(&nal_h,1,1,fout);
}
wsize = pkt_size-12-2;
nkn_vfs_fwrite(&pld[pos],wsize,sizeof(uint8_t),fout);
}
//#define VPE_DUMP_FILE "/nkn/vpe/dump_file"
int32_t rtp_format_convert(rtp_formatizer_t *rtp){
uint8_t *data, *data_init;
int32_t datalen = 0,i,j;
uint32_t cid,rtpsize,pos = 0,count = 0;
int32_t seek_box_size = 0;
uint8_t *seek_data;
int32_t temp=0;
FILE *fout_data;
if(!rtp)//||rtp->fin==NULL))
return VPE_ERROR;
/*Malloc for audio and video streams*/
if(allocate_rtp_streams(rtp)!=VPE_SUCCESS)
return VPE_ERROR;
/*Write the SPS PPS in the file*/
// fout_data = fopen(VPE_DUMP_FILE, "wb");
//if(fout_data == NULL)
//printf("Error in opening dump file \n");
for(i=0;i<rtp->num_video_streams;i++){
if(rtp->video[i].codec_type == VID_H264)
write_h264_ps(rtp->video[i].sdp,rtp->video[i].fout);
rtp->video[i].pkt.prev_time = 0;
}
data_init = data = (uint8_t*)malloc(sizeof(uint8_t)*rtp->rtp_data_size);
datalen = rtp->rtp_data_size;
//fread(data,datalen,1,rtp->fin);
temp = read(rtp->fin, data, datalen);
#if 0
if(temp != datalen) {
assert(0);
}
{
uint8_t *zero_data;
zero_data = (uint8_t*)calloc(1, 100);
if( !memcmp(data + 16384, zero_data, 100) ) {
/* hit error case */
lseek(rtp->fin, -datalen, SEEK_CUR);
read(rtp->fin, data, datalen);
}
}
#endif
//nkn_vfs_fwrite(data,datalen,sizeof(uint8_t),fout_data);
//fclose(fout_data);
/*Skip the seek boxes*/
pos = 4;
seek_box_size = _read32(data,pos);
seek_box_size = ntohl(seek_box_size);
pos+=4;
#ifdef _HACK_
pos+=4; ///Remove MFC
#endif
data+=pos;
seek_data = data;
while(datalen>0){
/*'$' separated RTP packets*/
count++;
pos =0;
#ifdef NKN_DEBUG_PRINT
printf("dataleft = %u\n",datalen);
if(data[pos]!=0x24)
printf("$ missing here\n");
#endif
pos++;
cid = data[pos];
pos++;
rtpsize= _read16(data,pos);
pos+=2;
#ifndef _HACK_
rtpsize = ntohs(rtpsize);
pos+=4; //Skip timestamp
#endif
for(i = 0;i <rtp->num_audio_streams;i++){
if(cid == rtp->audio[i].cid){
switch(rtp->audio[i].codec_type){
case AUD_AAC:
rtp->audio[i].pkt.data = data+pos;
rtp->audio[i].pkt.size = rtpsize;
rtp->audio[i].pkt.fout = rtp->audio[i].fout;
// aac_add_adts(&rtp->audio[i]);
aac_rtp_dump(&rtp->audio[i]);
break;
default:
break;
}
break;
}
}
for(j=0;j <rtp->num_video_streams;j++){
if(cid == rtp->video[j].cid){
switch(rtp->video[j].codec_type){
case VID_H264:
rtp->video[j].pkt.data = data+pos;
rtp->video[j].pkt.size = rtpsize;
rtp->video[j].pkt.fout = rtp->video[j].fout;
h264_rtp_dump(&rtp->video[j].pkt);
break;
default:
break;
}
break;
}
}
pos+=rtpsize;
if((uint32_t)datalen<pos+1){
int iiii = 0;
break;
}
data+=pos;
/*Skip the seek boxes*/
if((int32_t)(data-seek_data)>= seek_box_size){
int32_t pos1 ;
pos1 = 4;
seek_box_size = _read32(data,pos1);
seek_box_size = ntohl(seek_box_size);
pos1+=4;
data+=pos1;
seek_data = data;
pos+=pos1;
}
datalen-=pos;
}
#ifdef NKN_DEBUG_PRINT
printf("Deleting All temp Files\n");
#endif
/*Close all the raw files*/
for(j=0;j <rtp->num_video_streams;j++){
if( rtp->video[j].fout!=NULL)
fclose(rtp->video[j].fout);
}
for(j=0;j <rtp->num_audio_streams;j++){
if( rtp->audio[j].fout!=NULL)
fclose(rtp->audio[j].fout);
}
if(data_init) {
free(data_init);
}
return VPE_SUCCESS;
}
static void
_load_frames (struct ov_animation *anim,
unsigned char *data,
struct _iqm_header *h)
{
int i;
int k;
int n;
struct chan *chans = malloc (h->num_joints * sizeof(struct chan));
unsigned char *p = data + h->ofs_frames;
anim->num_frames = h->num_frames;
anim->poses = malloc(h->num_frames * sizeof (struct iqm_pose *));
int ofs_poses = h->ofs_poses;
for (k=0; k<h->num_joints; k++) {
chans[k].mask = _read32(data + ofs_poses + 4);
for (n=0; n<10; n++) {
chans[k].offset[n] = _readfloat(data + ofs_poses + 8 + n * 4);
chans[k].scale[n] = _readfloat(data + ofs_poses + 8 + 10 * 4 + n * 4);
}
ofs_poses += 22*4;
}
for (i=0; i<h->num_frames; i++) {
anim->poses[i] = malloc (h->num_joints * sizeof(struct iqm_pose));
for (k=0; k<h->num_joints; k++) {
for (n=0; n<3; n++) {
anim->poses[i][k].translate[n] = chans[k].offset[n];
anim->poses[i][k].rotate[n] = chans[k].offset[3+n];
anim->poses[i][k].scale[n] = chans[k].offset[7+n];
}
anim->poses[i][k].rotate[3] = chans[k].offset[6];
if (chans[k].mask & 0x01) {
anim->poses[i][k].translate[0] += _read16(p) * chans[k].scale[0]; p += 2;
}
if (chans[k].mask & 0x02) {
anim->poses[i][k].translate[1] += _read16(p) * chans[k].scale[1]; p += 2;
}
if (chans[k].mask & 0x04) {
anim->poses[i][k].translate[2] += _read16(p) * chans[k].scale[2]; p += 2;
}
if (chans[k].mask & 0x08) {
anim->poses[i][k].rotate[0] += _read16(p) * chans[k].scale[3]; p += 2;
}
if (chans[k].mask & 0x10) {
anim->poses[i][k].rotate[1] += _read16(p) * chans[k].scale[4]; p += 2;
}
if (chans[k].mask & 0x20) {
anim->poses[i][k].rotate[2] += _read16(p) * chans[k].scale[5]; p += 2;
}
if (chans[k].mask & 0x40) {
anim->poses[i][k].rotate[3] += _read16(p) * chans[k].scale[6]; p += 2;
}
if (chans[k].mask & 0x80) {
anim->poses[i][k].scale[0] += _read16(p) * chans[k].scale[7]; p += 2;
}
if (chans[k].mask & 0x100) {
anim->poses[i][k].scale[1] += _read16(p) * chans[k].scale[8]; p += 2;
}
if (chans[k].mask & 0x200) {
anim->poses[i][k].scale[2] += _read16(p) * chans[k].scale[9]; p += 2;
}
}
}
free (chans);
}
