static int wilc_wlan_txq_add_to_head(struct wilc *wilc, struct txq_entry_t *tqe)
{
unsigned long flags;
if (wilc_lock_timeout(wilc, &wilc->txq_add_to_head_cs,
CFG_PKTS_TIMEOUT))
return -1;
spin_lock_irqsave(&wilc->txq_spinlock, flags);
if (!wilc->txq_head) {
tqe->next = NULL;
tqe->prev = NULL;
wilc->txq_head = tqe;
wilc->txq_tail = tqe;
} else {
tqe->next = wilc->txq_head;
tqe->prev = NULL;
wilc->txq_head->prev = tqe;
wilc->txq_head = tqe;
}
wilc->txq_entries += 1;
PRINT_D(TX_DBG, "Number of entries in TxQ = %d\n", wilc->txq_entries);
spin_unlock_irqrestore(&wilc->txq_spinlock, flags);
up(&wilc->txq_add_to_head_cs);
up(&wilc->txq_event);
PRINT_D(TX_DBG, "Wake up the txq_handler\n");
return 0;
}
static void wilc_wlan_txq_add_to_tail(struct net_device *dev,
struct txq_entry_t *tqe)
{
unsigned long flags;
struct wilc_vif *vif;
struct wilc *wilc;
vif = netdev_priv(dev);
wilc = vif->wilc;
spin_lock_irqsave(&wilc->txq_spinlock, flags);
if (!wilc->txq_head) {
tqe->next = NULL;
tqe->prev = NULL;
wilc->txq_head = tqe;
wilc->txq_tail = tqe;
} else {
tqe->next = NULL;
tqe->prev = wilc->txq_tail;
wilc->txq_tail->next = tqe;
wilc->txq_tail = tqe;
}
wilc->txq_entries += 1;
PRINT_D(TX_DBG, "Number of entries in TxQ = %d\n", wilc->txq_entries);
spin_unlock_irqrestore(&wilc->txq_spinlock, flags);
PRINT_D(TX_DBG, "Wake the txq_handling\n");
up(&wilc->txq_event);
}
/**
* @brief ATWILC_WFI_deinit_mon_interface
* @details
* @param[in]
* @return int : Return 0 on Success
* @author mdaftedar
* @date 12 JUL 2012
* @version 1.0
*/
int ATWILC_WFI_deinit_mon_interface()
{
bool rollback_lock = false;
if(atwilc_wfi_mon != NULL)
{
PRINT_D(HOSTAPD_DBG,"In Deinit monitor interface\n");
PRINT_D(HOSTAPD_DBG,"RTNL is being locked\n");
if (rtnl_is_locked())
{
rtnl_unlock();
rollback_lock = true;
}
PRINT_D(HOSTAPD_DBG,"Unregister netdev\n");
unregister_netdev(atwilc_wfi_mon);
//ATL_PRINTF("Free Netdev\n");
//free_netdev(atwilc_wfi_mon);
if (rollback_lock)
{
rtnl_lock();
rollback_lock = false;
}
atwilc_wfi_mon = NULL;
}
return ATL_SUCCESS;
}
static int wilc_bus_probe(struct spi_device *spi)
{
PRINT_D(BUS_DBG, "spiModalias: %s\n", spi->modalias);
PRINT_D(BUS_DBG, "spiMax-Speed: %d\n", spi->max_speed_hz);
wilc_spi_dev = spi;
up(&spi_probe_sync);
return 0;
}
static void mgmt_tx_complete(void* priv, int status){
//struct sk_buff *skb2;
//struct atwilc_wfi_radiotap_cb_hdr *cb_hdr;
struct tx_complete_mon_data* pv_data = (struct tx_complete_mon_data*)priv;
ATL_Uint8 * buf= pv_data->buff;
if(status == 1){
if(INFO || buf[0] == 0x10 || buf[0] == 0xb0)
PRINT_D(HOSTAPD_DBG,"Packet sent successfully - Size = %d - Address = %p.\n",pv_data->size,pv_data->buff);
}else{
PRINT_D(HOSTAPD_DBG,"Couldn't send packet - Size = %d - Address = %p.\n",pv_data->size,pv_data->buff);
}
/* //(skb->data[9] == 0x00 || skb->data[9] == 0xb0 || skb->data[9] == 0x40 || skb->data[9] == 0xd0 )
{
skb2 = dev_alloc_skb(pv_data->size+sizeof(struct atwilc_wfi_radiotap_cb_hdr));
memcpy(skb_put(skb2,pv_data->size),pv_data->buff, pv_data->size);
cb_hdr = (struct atwilc_wfi_radiotap_cb_hdr *) skb_push(skb2, sizeof(*cb_hdr));
memset(cb_hdr, 0, sizeof(struct atwilc_wfi_radiotap_cb_hdr));
cb_hdr->hdr.it_version = 0;//PKTHDR_RADIOTAP_VERSION;
cb_hdr->hdr.it_len = cpu_to_le16(sizeof(struct atwilc_wfi_radiotap_cb_hdr));
cb_hdr->hdr.it_present = cpu_to_le32(
(1 << IEEE80211_RADIOTAP_RATE) |
(1 << IEEE80211_RADIOTAP_TX_FLAGS));
cb_hdr->rate = 5;//txrate->bitrate / 5;
cb_hdr->tx_flags = 0x0004;
skb2->dev = atwilc_wfi_mon;
skb_set_mac_header(skb2, 0);
skb2->ip_summed = CHECKSUM_UNNECESSARY;
skb2->pkt_type = PACKET_OTHERHOST;
skb2->protocol = htons(ETH_P_802_2);
memset(skb2->cb, 0, sizeof(skb2->cb));
netif_rx(skb2);
}*/
/* incase of fully hosting mode, the freeing will be done in response to the cfg packet */
#ifndef ATWILC_FULLY_HOSTING_AP
kfree(pv_data->buff);
kfree(pv_data);
#endif
}
int linux_spi_write(uint8_t* b, uint32_t len){
int ret;
if(len > 0 && b != NULL) {
struct spi_message msg;
PRINT_D(BUS_DBG,"Request writing %d bytes\n",len);
struct spi_transfer tr = {
.tx_buf = b,
.len = len,
.speed_hz = SPEED,
.delay_usecs = 0,
};
spi_message_init(&msg);
spi_message_add_tail(&tr,&msg);
ret = spi_sync(atwilc_spi_dev,&msg);
if(ret < 0){
PRINT_ER( "SPI transaction failed\n");
}
} else{
PRINT_ER("can't write data with the following length: %d\n",len);
PRINT_ER("FAILED due to NULL buffer or ZERO length check the following length: %d\n",len);
ret = -1;
}
/* change return value to match ATWILC interface */
(ret<0)? (ret = 0):(ret = 1);
return ret;
}
void disable_sdio_interrupt(void)
{
#ifndef WILC_SDIO_IRQ_GPIO
int ret;
PRINT_D(INIT_DBG, "disable_sdio_interrupt IN\n");
sdio_claim_host(local_sdio_func);
ret = sdio_release_irq(local_sdio_func);
if (ret < 0) {
PRINT_ER("can't release sdio_irq, err(%d)\n", ret);
}
sdio_release_host(local_sdio_func);
PRINT_D(INIT_DBG, "disable_sdio_interrupt OUT\n");
#endif
}
static int mon_mgmt_tx(struct net_device *dev, const u8 *buf, size_t len)
{
linux_wlan_t* nic;
struct tx_complete_mon_data *mgmt_tx =NULL;
if(dev == NULL)
{
PRINT_D(HOSTAPD_DBG,"ERROR: dev == NULL\n");
return ATL_FAIL;
}
nic =netdev_priv(dev);
//ATL_PRINTF("--IN mon_mgmt_tx--\n");
netif_stop_queue(dev);
mgmt_tx = (struct tx_complete_mon_data*)kmalloc(sizeof(struct tx_complete_mon_data),GFP_ATOMIC);
if(mgmt_tx == NULL){
PRINT_ER("Failed to allocate memory for mgmt_tx structure\n");
return ATL_FAIL;
}
#ifdef ATWILC_FULLY_HOSTING_AP
// add space for the pointer to tx_complete_mon_data
len+=sizeof(struct tx_complete_mon_data*);
#endif
mgmt_tx->buff= (char*)kmalloc(len,GFP_ATOMIC);
if(mgmt_tx->buff == NULL)
{
PRINT_ER("Failed to allocate memory for mgmt_tx buff\n");
return ATL_FAIL;
}
mgmt_tx->size=len;
#ifndef ATWILC_FULLY_HOSTING_AP
memcpy(mgmt_tx->buff,buf,len);
#else
//printk("sizeof(struct tx_complete_mon_data*) = %d\n",sizeof(struct tx_complete_mon_data*));
//printk("len = %d, mgmt_tx=%x\n",len,mgmt_tx);
memcpy(mgmt_tx->buff,buf,len-sizeof(struct tx_complete_mon_data*));
memcpy((mgmt_tx->buff)+(len-sizeof(struct tx_complete_mon_data*)),&mgmt_tx,sizeof(struct tx_complete_mon_data*));
// filter data frames to handle it's PS
if(filter_monitor_data_frames((mgmt_tx->buff),len)== ATL_TRUE)
{
return;
}
#endif //ATWILC_FULLY_HOSTING_AP
//printk("--IN mon_mgmt_tx: Sending MGMT Pkt to tx queue--\n");
g_linux_wlan->oup.wlan_add_mgmt_to_tx_que(mgmt_tx,mgmt_tx->buff,mgmt_tx->size,mgmt_tx_complete);
netif_wake_queue(dev);
return 0;
}
static inline int add_tcp_session(u32 src_prt, u32 dst_prt, u32 seq)
{
ack_session_info[tcp_session].seq_num = seq;
ack_session_info[tcp_session].bigger_ack_num = 0;
ack_session_info[tcp_session].src_port = src_prt;
ack_session_info[tcp_session].dst_port = dst_prt;
tcp_session++;
PRINT_D(TCP_ENH, "TCP Session %d to Ack %d\n", tcp_session, seq);
return 0;
}
static int linux_sdio_probe(struct sdio_func *func, const struct sdio_device_id *id)
{
struct wilc_sdio *wl_sdio;
struct wilc *wilc;
PRINT_D(INIT_DBG, "probe function\n");
wl_sdio = kzalloc(sizeof(struct wilc_sdio), GFP_KERNEL);
if (!wl_sdio)
return -ENOMEM;
PRINT_D(INIT_DBG, "Initializing netdev\n");
local_sdio_func = func;
if (wilc_netdev_init(&wilc)) {
PRINT_ER("Couldn't initialize netdev\n");
kfree(wl_sdio);
return -1;
}
wl_sdio->func = func;
wl_sdio->wilc = wilc;
sdio_set_drvdata(func, wl_sdio);
printk("Driver Initializing success\n");
return 0;
}
static int linux_sdio_set_speed(int speed)
{
#if 1
struct mmc_ios ios;
sdio_claim_host(local_sdio_func);
memcpy((void *)&ios,(void *)&local_sdio_func->card->host->ios,sizeof(struct mmc_ios));
local_sdio_func->card->host->ios.clock = speed;
ios.clock = speed;
local_sdio_func->card->host->ops->set_ios(local_sdio_func->card->host,&ios);
sdio_release_host(local_sdio_func);
PRINT_D(INIT_DBG,"@@@@@@@@@@@@ change SDIO speed to %d @@@@@@@@@\n", speed);
#endif
return 1;
}
/**
* @brief sends certain Configuration Packet based on the input WIDs pstrWIDs
* using driver config layer
*
* @details
* @param[in] pstrWIDs WIDs to be sent in the configuration packet
* @param[in] u32WIDsCount number of WIDs to be sent in the configuration packet
* @param[out] pu8RxResp The received Packet Response
* @param[out] ps32RxRespLen Length of the received Packet Response
* @return Error code indicating success/failure
* @note
* @author mabubakr
* @date 1 Mar 2012
* @version 1.0
*/
s32 send_config_pkt(u8 mode, struct wid *wids, u32 count, u32 drv)
{
s32 counter = 0, ret = 0;
if (mode == GET_CFG) {
for (counter = 0; counter < count; counter++) {
PRINT_INFO(CORECONFIG_DBG, "Sending CFG packet [%d][%d]\n", !counter,
(counter == count - 1));
if (!wilc_wlan_cfg_get(!counter,
wids[counter].id,
(counter == count - 1),
drv)) {
ret = -1;
printk("[Sendconfigpkt]Get Timed out\n");
break;
}
}
counter = 0;
for (counter = 0; counter < count; counter++) {
wids[counter].size = wilc_wlan_cfg_get_val(
wids[counter].id,
wids[counter].val,
wids[counter].size);
}
} else if (mode == SET_CFG) {
for (counter = 0; counter < count; counter++) {
PRINT_D(CORECONFIG_DBG, "Sending config SET PACKET WID:%x\n", wids[counter].id);
if (!wilc_wlan_cfg_set(!counter,
wids[counter].id,
wids[counter].val,
wids[counter].size,
(counter == count - 1),
drv)) {
ret = -1;
printk("[Sendconfigpkt]Set Timed out\n");
break;
}
}
}
return ret;
}
int linux_spi_write(uint8_t *b, uint32_t len)
{
int ret;
struct spi_message msg;
if (len > 0 && NULL != b) {
struct spi_transfer tr = {
.tx_buf = b,
.len = len,
.speed_hz = SPEED,
.delay_usecs = 0,
};
char *r_buffer = kzalloc(len, GFP_KERNEL);
if (!r_buffer)
return 0; /* TODO: it should be return -ENOMEM */
tr.rx_buf = r_buffer;
PRINT_D(BUS_DBG, "Request writing %d bytes\n", len);
spi_message_init(&msg);
spi_message_add_tail(&tr, &msg);
ret = spi_sync(wilc_spi_dev, &msg);
if (ret < 0)
PRINT_ER("SPI transaction failed\n");
kfree(r_buffer);
} else {
PRINT_ER("can't write data due to NULL buffer or zero length\n");
ret = -1;
}
(ret < 0) ? (ret = 0) : (ret = 1);
return ret;
}
static void print_gll_lag_fix(int n)
{
int i;
DECLARE_1VAR(z);
if(n>3) {
printf("static const double gllz_%02d[%2d] = {\n ",n,n/2-1);
for(i=1;i<=n/2-1;++i) {
lobatto_node(z, n,n-1-i);
if(i!=1) printf(",\n ");
gmp_printf("%.*Fg",DIGITS,z);
}
puts("\n};\n");
}
printf(STATIC "void gll_lag_%02d(double *restrict p, double *restrict data,\n"
" unsigned n, int d, double xh)\n{\n",n);
printf(" const double *restrict w = data;\n");
printf(" const double x = xh*2;\n");
#define PRINT_D(i) do { \
printf("d%02d=x",i); \
if(2*i+1==n) printf(" "); \
else if(i==0) printf("+2 "); \
else if(i==n-1) printf("-2 "); \
else if(i<n/2) printf("+2*gllz_%02d[%2d]",n,i-1); \
else printf("-2*gllz_%02d[%2d]",n,n-2-i); \
} while(0)
printf("%s", " const double ");
PRINT_LIST(i, 0,3,n, PRINT_D(i),",",",\n ");
#undef PRINT_D
#define PRINT_U0(i) (i==0 ?printf(" 1"):printf("u0_%02d",i))
#define PRINT_V0(i) (i==n-1?printf(" 1"):printf("v0_%02d",i))
#define PRINT_U1(i) (i<=1 ?printf(" %d",i ):printf("u1_%02d",i))
#define PRINT_V1(i) (i>=n-2?printf(" %d",n-1-(i)):printf("v1_%02d",i))
#define PRINT_U2(i) (i<=1 ?printf(" 0"): \
(i==2 ?printf(" 2"):printf("u2_%02d",i)))
#define PRINT_V2(i) (i>=n-2?printf(" 0"): \
(i==n-3?printf(" 2"):printf("v2_%02d",i)))
printf("%s",";\n const double ");
PRINT_LIST(i, 1,3,n,
(PRINT_U0(i),putchar('='),PRINT_U0(i-1),printf("*d%02d",i-1)),
",",",\n ");
printf("%s",";\n const double ");
PRINT_LIST(i, 1,3,n,
(PRINT_V0(n-1-i),putchar('='),printf("d%02d*",n-i),PRINT_V0(n-i)),
",",",\n ");
printf("%s",";\n ");
PRINT_LIST(i, 0,3,n,
(printf("p[%2d]=w[%2d]*",i,i),PRINT_U0(i),putchar('*'),
PRINT_V0(i)),"; ",";\n ");
puts(";\n if(d>0) {");
if(n>2) {
printf("%s"," const double ");
PRINT_LIST(i, 2,2,n,
(PRINT_U1(i),putchar('='),PRINT_U1(i-1),printf("*d%02d",i-1),
putchar('+'),PRINT_U0(i-1)),
",",",\n ");
printf("%s",";\n const double ");
PRINT_LIST(i, 2,2,n,
(PRINT_V1(n-1-i),putchar('='),printf("d%02d*",n-i),PRINT_V1(n-i),
putchar('+'),PRINT_V0(n-i)),
",",",\n ");
puts(";");
}
for(i=0;i<n;++i) {
printf(" p[%d+%2d]=2*w[%2d]*(",n,i,i);
if(i==0) printf(" "),PRINT_V1(0);
else if(i==n-1) PRINT_U1(i),printf(" ");
else PRINT_U1(i),putchar('*'),PRINT_V0(i),putchar('+'),
PRINT_U0(i),putchar('*'),PRINT_V1(i);
puts(");");
}
puts(" if(d>1) {");
if(n>3) {
printf("%s"," const double ");
PRINT_LIST(i, 3,2,n,
(PRINT_U2(i),putchar('='),PRINT_U2(i-1),printf("*d%02d",i-1),
printf("+2*"),PRINT_U1(i-1)),
",",",\n ");
printf("%s",";\n const double ");
PRINT_LIST(i, 3,2,n,
(PRINT_V2(n-1-i),putchar('='),printf("d%02d*",n-i),PRINT_V2(n-i),
printf("+2*"),PRINT_V1(n-i)),
",",",\n ");
puts(";");
}
if(n<3) for(i=0;i<n;++i) printf(" p[2*%d+%2d]=0;\n",n,i);
else for(i=0;i<n;++i) {
printf(" p[2*%d+%2d]=4*w[%2d]*(",n,i,i);
if(i>1)
PRINT_U2(i),putchar('*'),PRINT_V0(i);
else printf(" ");
if(i>0 && i<n-1)
printf("+2*"),PRINT_U1(i),putchar('*'),PRINT_V1(i);
else printf(" ");
if(i<n-2)
putchar('+'),PRINT_U0(i),putchar('*'),PRINT_V2(i);
else printf(" ");
puts(");");
}
#undef PRINT_U0
#undef PRINT_V0
#undef PRINT_U1
#undef PRINT_V1
#undef PRINT_U2
#undef PRINT_V2
puts(" }\n }\n}");
}
/**
* @brief parses the received 'N' message
* @details
* @param[in] pu8MsgBuffer The message to be parsed
* @param[out] ppstrNetworkInfo pointer to pointer to the structure containing the parsed Network Info
* @return Error code indicating success/failure
* @note
* @author mabubakr
* @date 1 Mar 2012
* @version 1.0
*/
s32 parse_network_info(u8 *pu8MsgBuffer, tstrNetworkInfo **ppstrNetworkInfo)
{
tstrNetworkInfo *pstrNetworkInfo = NULL;
u8 u8MsgType = 0;
u8 u8MsgID = 0;
u16 u16MsgLen = 0;
u16 u16WidID = (u16)WID_NIL;
u16 u16WidLen = 0;
u8 *pu8WidVal = NULL;
u8MsgType = pu8MsgBuffer[0];
/* Check whether the received message type is 'N' */
if ('N' != u8MsgType) {
PRINT_ER("Received Message format incorrect.\n");
return -EFAULT;
}
/* Extract message ID */
u8MsgID = pu8MsgBuffer[1];
/* Extract message Length */
u16MsgLen = MAKE_WORD16(pu8MsgBuffer[2], pu8MsgBuffer[3]);
/* Extract WID ID */
u16WidID = MAKE_WORD16(pu8MsgBuffer[4], pu8MsgBuffer[5]);
/* Extract WID Length */
u16WidLen = MAKE_WORD16(pu8MsgBuffer[6], pu8MsgBuffer[7]);
/* Assign a pointer to the WID value */
pu8WidVal = &pu8MsgBuffer[8];
/* parse the WID value of the WID "WID_NEWORK_INFO" */
{
u8 *pu8msa = NULL;
u16 u16RxLen = 0;
u8 *pu8TimElm = NULL;
u8 *pu8IEs = NULL;
u16 u16IEsLen = 0;
u8 u8index = 0;
u32 u32Tsf_Lo;
u32 u32Tsf_Hi;
pstrNetworkInfo = kzalloc(sizeof(tstrNetworkInfo), GFP_KERNEL);
if (!pstrNetworkInfo)
return -ENOMEM;
pstrNetworkInfo->s8rssi = pu8WidVal[0];
/* Assign a pointer to msa "Mac Header Start Address" */
pu8msa = &pu8WidVal[1];
u16RxLen = u16WidLen - 1;
/* parse msa*/
/* Get the cap_info */
pstrNetworkInfo->u16CapInfo = get_cap_info(pu8msa);
/* Get time-stamp [Low only 32 bit] */
pstrNetworkInfo->u32Tsf = get_beacon_timestamp_lo(pu8msa);
PRINT_D(CORECONFIG_DBG, "TSF :%x\n", pstrNetworkInfo->u32Tsf);
/* Get full time-stamp [Low and High 64 bit] */
u32Tsf_Lo = get_beacon_timestamp_lo(pu8msa);
u32Tsf_Hi = get_beacon_timestamp_hi(pu8msa);
pstrNetworkInfo->u64Tsf = u32Tsf_Lo | ((u64)u32Tsf_Hi << 32);
/* Get SSID */
get_ssid(pu8msa, pstrNetworkInfo->au8ssid, &pstrNetworkInfo->u8SsidLen);
/* Get BSSID */
get_BSSID(pu8msa, pstrNetworkInfo->au8bssid);
/*
* Extract current channel information from
* the beacon/probe response frame
*/
pstrNetworkInfo->u8channel = get_current_channel_802_11n(pu8msa,
u16RxLen + FCS_LEN);
/* Get beacon period */
u8index = MAC_HDR_LEN + TIME_STAMP_LEN;
pstrNetworkInfo->u16BeaconPeriod = get_beacon_period(pu8msa + u8index);
u8index += BEACON_INTERVAL_LEN + CAP_INFO_LEN;
/* Get DTIM Period */
pu8TimElm = get_tim_elm(pu8msa, u16RxLen + FCS_LEN, u8index);
if (pu8TimElm != NULL)
pstrNetworkInfo->u8DtimPeriod = pu8TimElm[3];
pu8IEs = &pu8msa[MAC_HDR_LEN + TIME_STAMP_LEN + BEACON_INTERVAL_LEN + CAP_INFO_LEN];
u16IEsLen = u16RxLen - (MAC_HDR_LEN + TIME_STAMP_LEN + BEACON_INTERVAL_LEN + CAP_INFO_LEN);
if (u16IEsLen > 0) {
pstrNetworkInfo->pu8IEs = kmemdup(pu8IEs, u16IEsLen,
GFP_KERNEL);
if (!pstrNetworkInfo->pu8IEs)
return -ENOMEM;
}
pstrNetworkInfo->u16IEsLen = u16IEsLen;
}
*ppstrNetworkInfo = pstrNetworkInfo;
return 0;
}
int
libapetag_convertID3v2toAPE (const ID3Frame * frame,
char **item_, size_t * item_len,
char **value_, size_t * value_len,
unsigned long *flags)
{
ID3Field *text;
ID3Field *desc;
ID3Field *url;
// ID3Field *bin; // will be implemented some day
char *item = NULL;
char *value = NULL;
ID3_FrameID frameid = ID3Frame_GetID (frame);
unsigned int i;
*flags = ITEM_TEXT;
for (i = 0; i < sizeof (convert) / sizeof (struct id3vtwo2ape); i++)
if (frameid == convert[i].frame)
break;
if (convert[i].field_type == ID3FN_TEXT) {
switch (convert[i].special) {
case APETAG_TYPE_COMMENT: /* Comments and unsynced lyrics */
if ((text = ID3Frame_GetField(frame, ID3FN_TEXT)) != NULL) {
ALOCATE(text, value, *value_len);
ID3Field_GetASCII(text, value, *value_len);
}
ALOCATE_ITEM(item, convert[i].APEName, *item_len);
strncpy(item, convert[i].APEName, *item_len);
item[*item_len]='\0';
//break;
if ((text = ID3Frame_GetField (frame, ID3FN_DESCRIPTION)) != NULL) {
char *value_ds=NULL;
int value_len2;
if (ID3Field_Size(text) != 0) {
ALOCATE(text, value_ds, value_len2);
ID3Field_GetASCII(text, value_ds, value_len2);
if ( strcmp(value_ds, STR_V1_COMMENT_DESC) == 0 ) {
value_len2 = 0;
value[0]='\0';
} else {
item = (char *) realloc( item, (*item_len) + value_len2 + 3);
item[(*item_len)++]='-'; item[(*item_len)]='\0';
strncpy(item + (*item_len),value_ds ,(value_len2 + 1));
(*item_len)+=value_len2;
}
free(value_ds);
}
}
break;
case APETAG_TYPE_USER: /* User texts */
if ((text = ID3Frame_GetField(frame, ID3FN_TEXT)) != NULL) {
ALOCATE(text, value, *value_len);
ID3Field_GetASCII(text, value, *value_len);
}
if ((desc = ID3Frame_GetField(frame, ID3FN_DESCRIPTION)) != NULL) {
ALOCATE(desc, item, *item_len);
ID3Field_GetASCII(desc, item, *item_len);
}
break;
case APETAG_TYPE_GENRE: /* genre */
if ((text = ID3Frame_GetField(frame, ID3FN_TEXT)) != NULL) {
char *p;
int j;
ALOCATE(text, value, *value_len);
ID3Field_GetASCII(text, value, *value_len);
ALOCATE_ITEM(item, convert[i].APEName, *item_len);
strncpy(item, convert[i].APEName, *item_len);
value[*value_len]='\0';
p = value;
if (*p == '(') {
p++;
while (*p && (*p >= '0' && *p <= '9'))
p++;
if (*p && *p == ')') {
p++;
} else {
p = value;
}
*value_len -= (p-value); // corect lenght of frame
if (*p != '\0') { // copy in place
for (j = 0; *p != '\0'; j++) {
value[j] = *p;
p++;
}
value[j] = '\0';
}
}
}
break;
default: /* normal text tags */
if ((text = ID3Frame_GetField(frame, ID3FN_TEXT)) != NULL) {
ALOCATE(text, value, *value_len);
ID3Field_GetASCII(text, value, *value_len);
ALOCATE_ITEM(item, convert[i].APEName, *item_len);
strncpy(item, convert[i].APEName, *item_len);
}
break;
} /* <- switch( convert[i].special ) */
item[*item_len]='\0';
value[*value_len]='\0';
} else
if (convert[i].field_type == ID3FN_URL) {
*flags = ITEM_URL;
/* TODO: set ape_tag_URL in flag */
/* user url */
if (convert[i].special == APETAG_TYPE_USER) {
if ((url = ID3Frame_GetField(frame, ID3FN_URL)) != NULL) {
ALOCATE(url, value, *value_len);
ID3Field_GetASCII(url, value, *value_len);
}
if ((desc = ID3Frame_GetField(frame, ID3FN_DESCRIPTION)) != NULL) {
ALOCATE(desc, item, *item_len);
ID3Field_GetASCII(desc, item, *item_len);
}
/* normal url */
} else {
if ((url = ID3Frame_GetField (frame, ID3FN_URL)) != NULL) {
ALOCATE(url, value, *value_len);
ID3Field_GetASCII(url, value, *value_len);
ALOCATE_ITEM(item, convert[i].APEName, *item_len);
strncpy(item, convert[i].APEName, *item_len);
}
}
item[*item_len]='\0';
value[*value_len]='\0';
} else { //convert[i].field_type
item = NULL;
value = NULL;
PRINT_D (">id3v2_read>other\n");
}
*item_ = item;
*value_ = value;
if (!(value==NULL || (*value_len)==0) && value[(*value_len)-1]=='\0')
(*value_len)--;
return 0;
}
void fprint_table(FILE* stream, rs_sample *s_x[N_EX_VAR], rs_sample *s_q[2],\
const mat *res, const fit_param *param, const plot_flag f)
{
mat **x_err,*q_err;
const rs_sample *s_q_pt;
size_t nens,ydim;
size_t ens_ind;
nens = param->nens;
ydim = (f == SCALE) ? 0 : 1;
s_q_pt = s_q[ydim];
x_err = mat_ar_create(N_EX_VAR,nens,1);
q_err = mat_create(nens,1);
/* computing errors */
rs_sample_varp(x_err[i_ud],s_x[i_ud]);
mat_eqsqrt(x_err[i_ud]);
rs_sample_varp(x_err[i_s],s_x[i_s]);
mat_eqsqrt(x_err[i_s]);
rs_sample_varp(x_err[i_a],s_x[i_a]);
mat_eqsqrt(x_err[i_a]);
rs_sample_varp(x_err[i_umd],s_x[i_umd]);
mat_eqsqrt(x_err[i_umd]);
rs_sample_varp(x_err[i_Linv],s_x[i_Linv]);
mat_eqsqrt(x_err[i_Linv]);
rs_sample_varp(q_err,s_q_pt);
mat_eqsqrt(q_err);
/* display */
fprintf(stream,"#%49s ","ensemble");
PRINT_DLABEL_WERR(param->ud_name);
PRINT_DLABEL_WERR(param->s_name);
if (f == Q)
{
PRINT_DLABEL_WERR("a");
}
if (param->have_umd)
{
PRINT_DLABEL_WERR(param->umd_name);
}
if (param->have_alpha)
{
PRINT_DLABEL("alpha");
}
PRINT_DLABEL_WERR("1/L");
if (f == Q)
{
PRINT_DLABEL_WERR(param->q_name);
}
else if (f == SCALE)
{
PRINT_DLABEL_WERR(param->scale_part);
}
PRINT_DLABEL("residuals");
fprintf(stream,"\n");
for(ens_ind=0;ens_ind<nens;ens_ind++)
{
fprintf(stream,"%50s ",param->point[ens_ind].dir);
PRINT_X_WERR(i_ud);
PRINT_X_WERR(i_s);
if (f == Q)
{
PRINT_X_WERR(i_a);
}
if (param->have_umd)
{
PRINT_X_WERR(i_umd);
}
if (param->have_alpha)
{
PRINT_X(i_alpha);
}
PRINT_X_WERR(i_Linv);
PRINT_CV_WERR(s_q_pt,q_err);
PRINT_D(mat_get(res,ens_ind,0));
fprintf(stream,"\n");
}
fprintf(stream,"\n");
mat_ar_destroy(x_err,N_EX_VAR);
mat_destroy(q_err);
}
