static int kr_mkv_check_ebml_header (kr_mkv_t *mkv) {
char doctype[64];
uint32_t version;
uint32_t read_version;
if (0 > kr_ebml2_unpack_header (mkv->e, doctype, 64,
&version, &read_version)) {
printke ("Could not read EBML header");
return -1;
}
if ((strncmp(doctype, "webm", 4) != 0) &&
(strncmp(doctype, "matroska", 8) != 0)) {
printke ("Invalid Doctype: %s", doctype);
return -1;
}
if ((version < 2) || (version > 4) ||
(read_version < 2) || (read_version > 4)) {
printke ("Crazy Version Number: %u - %u",
version, read_version);
return -1;
}
printk ("Got EBML doctype: %s Version %u Read Version %u",
doctype, version, read_version);
return 0;
}
void *kr_audioport_process_thread (void *arg) {
kr_audioport_t *kr_audioport = (kr_audioport_t *)arg;
int ret;
char buf[1];
krad_system_set_thread_name ("krc_audioport");
while (kr_audioport->active == 1) {
// wait for socket to have a byte
ret = read (kr_audioport->sd, buf, 1);
if (ret != 1) {
printke ("krad mixer client: unexpected read return value %d in kr_audioport_process_thread", ret);
}
//kr_audioport->callback (kr_audioport->kr_shm->buffer, kr_audioport->pointer);
kr_audioport->callback (1600, kr_audioport->pointer);
// write a byte to socket
ret = write (kr_audioport->sd, buf, 1);
if (ret != 1) {
printke ("krad mixer client: unexpected write return value %d in kr_audioport_process_thread", ret);
}
}
return NULL;
}
static int kr_mkv_parse_tracks (kr_mkv_t *mkv, uint64_t max_pos) {
int ret;
uint32_t id;
uint64_t size;
while (1) {
if (mkv->e->pos >= max_pos) {
printk ("Got to end of tracks info");
break;
}
ret = kr_ebml2_unpack_id (mkv->e, &id, &size);
if (ret < 0) {
printke ("Read error...");
return -1;
}
if ((id == MKV_CLUSTER) || (id == EID_VOID) ||
(id == EID_CRC32) || (id == MKV_TAGS) || (id == MKV_CUES) ||
(id == MKV_ATTACHMENTS) || (id == MKV_CHAPTERS)) {
printk ("Done with tracks. Got %d", mkv->track_count);
return 0;
}
if (id != MKV_TRACK) {
printke ("No Track :/");
return -1;
}
printk ("Got Track!");
ret = kr_mkv_parse_track (mkv, mkv->e->pos + size);
if (ret < 0) {
printke ("Track parse error...");
return -1;
}
}
return 0;
}
int32_t kr_vorbis_encode (krad_vorbis_t *vorbis,
kr_codeme_t *codeme,
kr_medium_t *medium) {
int32_t bo_ret;
int32_t ret;
int c;
float **pcm;
ogg_packet op;
if (medium != NULL) {
if (medium->a.count > 0) {
pcm = vorbis_analysis_buffer (&vorbis->vdsp, medium->a.count);
for (c = 0; c < vorbis->channels; c++) {
memcpy (pcm[c], medium->a.samples[c], medium->a.count * 4);
}
} else {
printk ("KR Vorbis Encoder: Got finish notice");
}
ret = vorbis_analysis_wrote (&vorbis->vdsp, medium->a.count);
if (ret < 0) {
vorbis->error = ret;
vorbis->state_str = "Krad Vorbis Encoder: vorbis_analysis_wrote fail";
printke (vorbis->state_str);
return -1;
}
//printk ("KR Vorbis Encoder: wrote %d samples", medium->a.count);
}
bo_ret = vorbis_analysis_blockout (&vorbis->vdsp, &vorbis->vblock);
if (bo_ret < 0) {
vorbis->error = bo_ret;
vorbis->state_str = "Krad Vorbis Encoder: vorbis_analysis_blockout fail";
printke (vorbis->state_str);
return -1;
}
if (bo_ret == 1) {
ret = vorbis_analysis (&vorbis->vblock, &op);
if (ret < 0) {
vorbis->error = ret;
vorbis->state_str = "Krad Vorbis Encoder: vorbis_analysis fail";
printke (vorbis->state_str);
return -1;
}
//printk ("KR Vorbis Encoder: op gpos: %"PRIi64" size %ld",
// op.granulepos, op.bytes);
codeme->sz = op.bytes;
codeme->count = op.granulepos - vorbis->frames;
vorbis->frames = op.granulepos;
memcpy (codeme->data, op.packet, codeme->sz);
//printk ("KR Vorbis Encoder: codeme size: %zu Count: %d",
// codeme->sz, codeme->count);
}
return bo_ret;
}
int krad_transmitter_transmission_transmit_header (krad_transmission_t *krad_transmission,
krad_transmission_receiver_t *krad_transmission_receiver) {
int wrote;
wrote = 0;
while (krad_transmission_receiver->wrote_http_header == 0) {
wrote = write (krad_transmission_receiver->fd,
krad_transmission->http_header + krad_transmission_receiver->http_header_position,
krad_transmission->http_header_len - krad_transmission_receiver->http_header_position);
if (wrote > 0) {
krad_transmission_receiver->http_header_position += wrote;
if (krad_transmission_receiver->http_header_position == krad_transmission->http_header_len) {
krad_transmission_receiver->wrote_http_header = 1;
} else {
return 0;
}
} else {
if (wrote == -1) {
if (errno != EAGAIN) {
printke ("Krad Transmitter: transmission error writing to socket");
krad_transmitter_receiver_destroy (krad_transmission_receiver);
}
}
return 0;
}
}
while (krad_transmission_receiver->wrote_header == 0) {
wrote = write (krad_transmission_receiver->fd,
krad_transmission->header + krad_transmission_receiver->header_position,
krad_transmission->header_len - krad_transmission_receiver->header_position);
if (wrote > 0) {
krad_transmission_receiver->header_position += wrote;
if (krad_transmission_receiver->header_position == krad_transmission->header_len) {
krad_transmission_receiver->wrote_header = 1;
} else {
return 0;
}
} else {
if (wrote == -1) {
if (errno != EAGAIN) {
printke ("Krad Transmitter: transmission error writing to socket");
krad_transmitter_receiver_destroy (krad_transmission_receiver);
}
}
return 0;
}
}
krad_transmission_receiver->position = krad_transmission->sync_point;
return 1;
}
static void krad_vpx_fail (vpx_codec_ctx_t *ctx, const char *s) {
const char *detail = vpx_codec_error_detail(ctx);
printke ("%s: %s\n", s, vpx_codec_error(ctx));
if (detail) {
printke ("%s\n", detail);
}
failfast ("");
}
int marlin_priv_cmd(struct net_device *ndev, struct ifreq *ifr)
{
struct wlan_vif_t *vif;
struct android_wifi_priv_cmd priv_cmd;
char *command = NULL;
u8 addr[ETH_ALEN] = {0};
int bytes_written = 0;
int ret = 0;
vif = ndev_to_vif(ndev);
if (!ifr->ifr_data)
return -EINVAL;
if (copy_from_user(&priv_cmd, ifr->ifr_data,
sizeof(struct android_wifi_priv_cmd)))
return -EFAULT;
command = kmalloc(priv_cmd.total_len, GFP_KERNEL);
if (!command) {
printke("%s: Failed to allocate command!\n", __func__);
return -ENOMEM;
}
if (copy_from_user(command, priv_cmd.buf, priv_cmd.total_len)) {
ret = -EFAULT;
goto exit;
}
if (strnicmp(command, CMD_BLACKLIST_ENABLE,
strlen(CMD_BLACKLIST_ENABLE)) == 0) {
int skip = strlen(CMD_BLACKLIST_ENABLE) + 1;
printke("%s, Received regular blacklist enable command\n",
__func__);
sscanf(command + skip, "" MACSTR "", STR2MAC(addr));
bytes_written = wlan_cmd_add_blacklist(vif, addr);
} else if (strnicmp(command, CMD_BLACKLIST_DISABLE,
strlen(CMD_BLACKLIST_DISABLE)) == 0) {
int skip = strlen(CMD_BLACKLIST_DISABLE) + 1;
printke("%s, Received regular blacklist disable command\n",
__func__);
sscanf(command + skip, "" MACSTR "", STR2MAC(addr));
bytes_written = wlan_cmd_del_blacklist(vif, addr);
}
if (bytes_written < 0)
ret = bytes_written;
exit:
kfree(command);
return ret;
}
static int wlan_rx_process(unsigned char *buf, unsigned int max_len)
{
static unsigned int cnt;
static unsigned int skb;
unsigned int p = 0;
r_msg_hdr_t *msg = NULL;
unsigned char vif_id;
unsigned char *pData = NULL;
unsigned short len;
unsigned char event;
if ((NULL == buf) || (0 == max_len)) {
printke("[%s][ERROR]\n", __func__);
return OK;
}
buf = buf + 8;
msg = (r_msg_hdr_t *) (buf);
max_len = max_len - 8;
while (p < max_len) {
vif_id = msg->mode;
pData = (unsigned char *)(msg + 1);
len = msg->len;
if ((0xFF == msg->type) || (0xFF == msg->subtype))
break;
if (HOST_SC2331_PKT == msg->type) {
pData = pData + msg->subtype;
len = len - msg->subtype;
wlan_rx_skb_process(vif_id, pData, len);
} else if (HOST_SC2331_WAPI == msg->type) {
wlan_rx_wapi_process(vif_id, pData, len);
} else if (SC2331_HOST_RSP == msg->type) {
wlan_rx_rsp_process(vif_id, msg);
} else if (HOST_SC2331_CMD == msg->type) {
event = msg->subtype;
wlan_rx_event_process(vif_id, event, pData, len);
} else {
printke("[%s][RX DATA ERR]\n", __func__);
break;
}
p = p + sizeof(t_msg_hdr_t) + ALIGN_4BYTE(msg->len);
msg = (r_msg_hdr_t *) (buf + p);
skb++;
}
cnt++;
if (1000 == cnt) {
printkd("r%d\n", skb);
cnt = 0;
skb = 0;
}
return OK;
}
static int kr_interweb_server_socket_setup(char *interface, int port) {
char port_string[6];
struct addrinfo hints;
struct addrinfo *result, *rp;
int s;
int sfd = 0;
char *interface_actual;
interface_actual = interface;
printk ("Krad Interweb Server: interface: %s port %d", interface, port);
snprintf (port_string, 6, "%d", port);
memset (&hints, 0, sizeof (struct addrinfo));
hints.ai_family = AF_UNSPEC; /* Return IPv4 and IPv6 choices */
hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */
hints.ai_flags = AI_PASSIVE; /* All interfaces */
if ((strlen(interface) == 7) && (strncmp(interface, "0.0.0.0", 7) == 0)) {
hints.ai_family = AF_INET;
interface_actual = NULL;
}
if ((strlen(interface) == 4) && (strncmp(interface, "[::]", 4) == 0)) {
hints.ai_family = AF_INET6;
interface_actual = NULL;
}
s = getaddrinfo (interface_actual, port_string, &hints, &result);
if (s != 0) {
printke ("getaddrinfo: %s\n", gai_strerror (s));
return -1;
}
for (rp = result; rp != NULL; rp = rp->ai_next) {
sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);
if (sfd == -1) {
continue;
}
set_socket_reuseaddr(sfd);
s = bind (sfd, rp->ai_addr, rp->ai_addrlen);
if (s == 0) {
/* We managed to bind successfully! */
break;
}
close (sfd);
}
if (rp == NULL) {
printke ("Could not bind %d\n", port);
return -1;
}
freeaddrinfo (result);
return sfd;
}
static int kr_mkv_parse_segment_header (kr_mkv_t *mkv) {
int ret;
uint32_t id;
uint64_t size;
ret = kr_ebml2_unpack_id (mkv->e, &id, &size);
if (ret < 0) {
printke ("Read error...");
return -1;
}
if (id != MKV_SEGMENT) {
printke ("No Segment :/");
return -1;
}
printk ("Got Segment");
while (1) {
ret = kr_ebml2_unpack_id (mkv->e, &id, &size);
if (ret < 0) {
printke ("Read error..");
return -1;
}
switch (id) {
case MKV_TRACKS:
mkv->tracks_info_data = mkv->e->bufstart + mkv->e->pos;
mkv->tracks_info_data_size = size;
if (kr_mkv_parse_tracks (mkv, mkv->e->pos + size) < 0) {
return -1;
} else {
return 0;
}
case MKV_SEGMENT_INFO:
mkv->segment_info_data = mkv->e->bufstart + mkv->e->pos;
mkv->segment_info_data_size = size;
printk ("Got Segment Info: %"PRIu64" bytes", size);
if (kr_mkv_parse_segment_info (mkv, mkv->e->pos + size) < 0) {
return -1;
}
break;
default:
printk ("Skipping unknown element: %"PRIu64" bytes", size);
kr_ebml2_advance (mkv->e, size);
break;
}
}
return 0;
}
int krad_ipc_server_tcp_socket_create (int port) {
char port_string[6];
struct addrinfo hints;
struct addrinfo *result, *rp;
int s;
int sfd = 0;
snprintf (port_string, 6, "%d", port);
memset (&hints, 0, sizeof (struct addrinfo));
hints.ai_family = AF_UNSPEC; /* Return IPv4 and IPv6 choices */
hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */
hints.ai_flags = AI_PASSIVE; /* All interfaces */
s = getaddrinfo (NULL, port_string, &hints, &result);
if (s != 0) {
printke ("getaddrinfo: %s\n", gai_strerror (s));
return -1;
}
for (rp = result; rp != NULL; rp = rp->ai_next) {
sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);
if (sfd == -1) {
continue;
}
s = bind (sfd, rp->ai_addr, rp->ai_addrlen);
if (s == 0) {
/* We managed to bind successfully! */
break;
}
close (sfd);
}
if (rp == NULL) {
printke ("Could not bind %d\n", port);
return -1;
}
freeaddrinfo (result);
return sfd;
}
static int hw_tx(const unsigned short chn, unsigned char *buf, unsigned int len)
{
int ret;
static unsigned int cnt;
static unsigned int skb;
tx_big_hdr_t *big_hdr;
big_hdr = (tx_big_hdr_t *) buf;
if ((PKT_AGGR_NUM < big_hdr->msg_num) || (0 == big_hdr->msg_num)) {
ASSERT();
return ERROR;
}
big_hdr->tx_cnt = g_wlan.hw.tx_cnt;
printkp("[tx][%d][%d]\n", big_hdr->tx_cnt, chn);
len = (len + 1023) & 0xFC00;
wlan_tx_buf_decode(buf, len);
ret = sdio_dev_write(chn, buf, len);
if (0 != ret) {
printke("call sdio_dev_write err:%d\n", ret);
return HW_WRITE_ERROR;
}
skb = skb + big_hdr->msg_num;
cnt++;
if (1000 == cnt) {
printkd("w%d\n", skb);
cnt = 0;
skb = 0;
}
g_wlan.hw.tx_cnt++;
return OK;
}
int kr_io2_output(kr_io2_t *io) {
ssize_t ret;
if (!kr_io2_want_out(io)) {
return 0;
}
ret = kr_io2_write(io);
//printk("kr_io2_output wrote: %zu old len: %zu new len: %zu",
// ret, io->len, io->len - ret);
if (ret != io->len) {
if (ret < 1) {
printke("its bad we should certainly fail, ret %zu len %zu",
ret, io->len);
return ret;
} else {
io->len -= ret;
io->wr_buf += ret;
}
return 0;
}
kr_io2_restart(io);
return 0;
}
int krad_opus_decoder_write (krad_opus_t *krad_opus,
uint8_t *buffer,
int length) {
int i;
int frames_decoded;
frames_decoded = 0;
krad_opus->opus_decoder_error = opus_multistream_decode_float (krad_opus->decoder,
buffer,
length,
krad_opus->interleaved_samples,
2880 * 2,
0);
if (krad_opus->opus_decoder_error < 0) {
printke ("Krad Opus decoder error: %s\n",
opus_strerror (krad_opus->opus_decoder_error));
} else {
frames_decoded = krad_opus->opus_decoder_error;
}
for (i = 0; i < frames_decoded; i++) {
krad_opus->samples[0][i] = krad_opus->interleaved_samples[i * 2 + 0];
krad_opus->samples[1][i] = krad_opus->interleaved_samples[i * 2 + 1];
}
krad_ringbuffer_write (krad_opus->ringbuf[0], (char *)krad_opus->samples[0], (frames_decoded * 4) );
krad_ringbuffer_write (krad_opus->ringbuf[1], (char *)krad_opus->samples[1], (frames_decoded * 4) );
return 0;
}
kr_app_client *kr_app_connect(char *sysname, int timeout_ms) {
kr_app_client *client;
client = calloc(1, sizeof(kr_app_client));
if (client == NULL) {
failfast("Krad APP Client mem alloc fail");
return NULL;
}
uname (&client->unixname);
if (krad_valid_host_and_port (sysname)) {
krad_get_host_and_port (sysname, client->host, &client->tcp_port);
} else {
strncpy (client->sysname, sysname, sizeof (client->sysname));
if (strncmp(client->unixname.sysname, "Linux", 5) == 0) {
client->on_linux = 1;
client->api_path_pos = sprintf(client->api_path, "@krad_radio_%s_api", sysname);
} else {
client->api_path_pos = sprintf(client->api_path, "%s/krad_radio_%s_api", "/tmp", sysname);
}
if (!client->on_linux) {
if(stat(client->api_path, &client->info) != 0) {
kr_app_disconnect(client);
failfast ("Krad APP Client: API PATH Failure\n");
return NULL;
}
}
}
if (kr_app_client_init(client, timeout_ms) == 0) {
printke ("Krad APP Client: Failed to init!");
kr_app_disconnect(client);
return NULL;
}
return client;
}
int krad_decklink_cpp_detect_devices () {
IDeckLinkIterator *deckLinkIterator;
IDeckLink *deckLink;
int device_count;
//HRESULT result;
device_count = 0;
deckLinkIterator = CreateDeckLinkIteratorInstance();
if (deckLinkIterator == NULL) {
printke ("krad_decklink_detect_devices: The DeckLink drivers may not be installed.");
return 0;
}
while (deckLinkIterator->Next(&deckLink) == S_OK) {
device_count++;
deckLink->Release();
}
deckLinkIterator->Release();
return device_count;
}
static void krad_transmission_remove_ready (krad_transmission_t *krad_transmission, krad_transmission_receiver_t *krad_transmission_receiver) {
if (krad_transmission_receiver->ready != 1) {
printke ("Krad Transmitter: receiver was not ready!");
return;
}
krad_transmission_receiver->ready = 0;
/*
while (1) {
if ((krad_transmission_receiver->prev == NULL) && (krad_transmission_receiver->next == NULL)) {
krad_transmission->ready_receivers = NULL;
break;
}
if ((krad_transmission_receiver->prev == NULL) && (krad_transmission_receiver->next != NULL)) {
krad_transmission->ready_receivers = krad_transmission_receiver->next;
krad_transmission_receiver->next->prev = NULL;
break;
}
if ((krad_transmission_receiver->prev != NULL) && (krad_transmission_receiver->next == NULL)) {
krad_transmission_receiver->prev->next = NULL;
break;
}
if ((krad_transmission_receiver->prev != NULL) && (krad_transmission_receiver->next != NULL)) {
krad_transmission_receiver->prev->next = krad_transmission_receiver->next;
krad_transmission_receiver->next->prev = krad_transmission_receiver->prev;
break;
}
}
krad_transmission_receiver->prev = NULL;
krad_transmission_receiver->next = NULL;
*/
krad_transmission->ready_receiver_count--;
}
static int wlan_hw_init(hw_info_t *hw)
{
struct device_node *np;
memset(hw, 0, sizeof(hw_info_t));
hw->sdio_tx_chn.num = 3;
hw->sdio_tx_chn.chn[0] = 0;
hw->sdio_tx_chn.chn[1] = 1;
hw->sdio_tx_chn.chn[2] = 2;
hw->sdio_tx_chn.bit_map = 0x0007;
hw->sdio_tx_chn.timeout_time = 600;
hw->sdio_tx_chn.timeout_flag = false;
hw->sdio_rx_chn.num = 6;
hw->sdio_rx_chn.chn[0] = 8;
hw->sdio_rx_chn.chn[1] = 9;
hw->sdio_rx_chn.chn[2] = 14;
hw->sdio_rx_chn.chn[3] = 11;
hw->sdio_rx_chn.chn[4] = 15;
hw->sdio_rx_chn.chn[5] = 13;
hw->sdio_rx_chn.bit_map = 0xeb00;
hw->sdio_rx_chn.gpio_high = false;
hw->sdio_rx_chn.timeout_time = 600;
hw->sdio_rx_chn.timeout_flag = false;
np = of_find_node_by_name(NULL, "sprd-marlin");
if (!np) {
printke("sprd-marlin not found");
return -1;
}
hw->rx_gpio = of_get_gpio(np, 1);
printke("[SDIO_TX_CHN][0x%x][0x%x]\n", hw->sdio_tx_chn.bit_map,
HW_TX_SIZE);
printke("[SDIO_RX_CHN][0x%x][0x%x]\n", hw->sdio_rx_chn.bit_map,
HW_RX_SIZE);
hw->wakeup = 0;
spin_lock_init(&(hw->sdio_rx_chn.lock));
wake_lock_init(&g_wlan.hw.wlan_lock, WAKE_LOCK_SUSPEND,
"wlan_sc2331_lock");
init_timer(&g_wlan.hw.wakeup_timer);
g_wlan.hw.wakeup_timer.function = wakeup_timer_func;
g_wlan.hw.wakeup_time = 500;
return OK;
}
void krad_mixer_crossfade_group_create (krad_mixer_t *krad_mixer, krad_mixer_portgroup_t *portgroup1, krad_mixer_portgroup_t *portgroup2) {
int x;
krad_mixer_crossfade_group_t *crossfade_group;
if ((portgroup1 == NULL) || ((portgroup1->active != 1) && (portgroup1->active != 2)) ||
(portgroup2 == NULL) || ((portgroup2->active != 1) && (portgroup2->active != 2))) {
printke ("Invalid portgroup for crossfade!");
return;
}
if (!(((portgroup1->direction == INPUT) || (portgroup1->direction == MIX)) &&
((portgroup1->direction == INPUT) || (portgroup2->direction == MIX)) &&
(((portgroup1->io_type == MIXBUS) && (portgroup2->io_type == MIXBUS)) ||
((portgroup1->io_type != MIXBUS) && (portgroup2->io_type != MIXBUS))))) {
printke ("Invalid crossfade group!");
return;
}
if (portgroup1->crossfade_group != NULL) {
krad_mixer_crossfade_group_destroy (krad_mixer, portgroup1->crossfade_group);
}
if (portgroup2->crossfade_group != NULL) {
krad_mixer_crossfade_group_destroy (krad_mixer, portgroup2->crossfade_group);
}
for (x = 0; x < KRAD_MIXER_MAX_PORTGROUPS / 2; x++) {
crossfade_group = &krad_mixer->crossfade_group[x];
if ((crossfade_group != NULL) && ((crossfade_group->portgroup[0] == NULL) && (crossfade_group->portgroup[1] == NULL))) {
break;
}
}
crossfade_group->portgroup[0] = portgroup1;
crossfade_group->portgroup[1] = portgroup2;
portgroup1->crossfade_group = crossfade_group;
portgroup2->crossfade_group = crossfade_group;
krad_radio_broadcast_subunit_update ( krad_mixer->krad_ipc->ipc_broadcaster, &portgroup1->address, KR_CROSSFADE_GROUP,
KR_STRING, portgroup2->sysname, NULL );
krad_mixer_set_portgroup_control (krad_mixer, portgroup1->sysname, "crossfade", -100.0f, 0, NULL );
}
int krad_control_init (krad_control_t *krad_control) {
if (socketpair(AF_UNIX, SOCK_STREAM, 0, krad_control->sockets)) {
printke ("Krad System: can't socketpair errno: %d", errno);
krad_control->sockets[0] = 0;
krad_control->sockets[1] = 0;
return -1;
}
return 0;
}
void krad_decklink_capture_stop(krad_decklink_capture_t *krad_decklink_capture) {
if (krad_decklink_capture->deckLinkInput != NULL) {
krad_decklink_capture->result = krad_decklink_capture->deckLinkInput->StopStreams ();
if (krad_decklink_capture->result != S_OK) {
printke ("Krad Decklink: Fail StopStreams\n");
}
krad_decklink_capture->result = krad_decklink_capture->deckLinkInput->DisableVideoInput ();
if (krad_decklink_capture->result != S_OK) {
printke ("Krad Decklink: Fail DisableVideoInput\n");
}
krad_decklink_capture->result = krad_decklink_capture->deckLinkInput->DisableAudioInput ();
if (krad_decklink_capture->result != S_OK) {
printke ("Krad Decklink: Fail DisableAudioInput\n");
}
krad_decklink_capture->result = krad_decklink_capture->deckLinkConfiguration->Release();
if (krad_decklink_capture->result != S_OK) {
printke ("Krad Decklink: Fail to Release deckLinkConfiguration\n");
}
krad_decklink_capture->deckLinkConfiguration = NULL;
krad_decklink_capture->result = krad_decklink_capture->deckLinkInput->Release();
if (krad_decklink_capture->result != S_OK) {
printke ("Krad Decklink: Fail Release\n");
}
krad_decklink_capture->deckLinkInput = NULL;
}
if (krad_decklink_capture->deckLink != NULL) {
krad_decklink_capture->deckLink->Release();
krad_decklink_capture->deckLink = NULL;
}
if (krad_decklink_capture->deckLinkIterator != NULL) {
krad_decklink_capture->deckLinkIterator->Release();
}
//printf("\n");
free(krad_decklink_capture);
}
void krad_ipc_server_read_tag ( krad_ipc_server_t *krad_ipc_server, char **tag_item, char **tag_name, char **tag_value ) {
uint32_t ebml_id;
uint64_t ebml_data_size;
krad_ebml_read_element (krad_ipc_server->current_client->krad_ebml, &ebml_id, &ebml_data_size);
if (ebml_id != EBML_ID_KRAD_RADIO_TAG) {
printke ("hrm wtf\n");
} else {
//printf("tag size %zu\n", ebml_data_size);
}
krad_ebml_read_element (krad_ipc_server->current_client->krad_ebml, &ebml_id, &ebml_data_size);
if (ebml_id != EBML_ID_KRAD_RADIO_TAG_ITEM) {
printke ("hrm wtf2\n");
} else {
//printf("tag name size %zu\n", ebml_data_size);
}
krad_ebml_read_string (krad_ipc_server->current_client->krad_ebml, *tag_item, ebml_data_size);
krad_ebml_read_element (krad_ipc_server->current_client->krad_ebml, &ebml_id, &ebml_data_size);
if (ebml_id != EBML_ID_KRAD_RADIO_TAG_NAME) {
printke ("hrm wtf2\n");
} else {
//printf("tag name size %zu\n", ebml_data_size);
}
krad_ebml_read_string (krad_ipc_server->current_client->krad_ebml, *tag_name, ebml_data_size);
krad_ebml_read_element (krad_ipc_server->current_client->krad_ebml, &ebml_id, &ebml_data_size);
if (ebml_id != EBML_ID_KRAD_RADIO_TAG_VALUE) {
printke ("hrm wtf3\n");
} else {
//printf("tag value size %zu\n", ebml_data_size);
}
krad_ebml_read_string (krad_ipc_server->current_client->krad_ebml, *tag_value, ebml_data_size);
}
void krad_vpx_encoder_config_set (krad_vpx_encoder_t *vpx,
vpx_codec_enc_cfg_t *cfg) {
int ret;
ret = vpx_codec_enc_config_set (&vpx->encoder, cfg);
if (ret != VPX_CODEC_OK) {
printke ("VPX Config problem: %s\n", vpx_codec_err_to_string (ret));
}
}
int kr_mkv_read_packet (kr_mkv_t *mkv, uint32_t *track,
uint64_t *timecode, uint8_t *flags, uint8_t *buffer) {
int ret;
uint32_t id;
uint64_t size;
//printk ("kr_mkv_read_packet");
while (1) {
ret = kr_ebml2_unpack_id (mkv->e, &id, &size);
if (ret < 0) {
printke ("Read error..");
return -1;
}
switch (id) {
case MKV_CLUSTER:
break;
case EID_VOID:
case EID_CRC32:
case MKV_TAGS:
case MKV_CUES:
case MKV_ATTACHMENTS:
case MKV_CHAPTERS:
kr_ebml2_advance (mkv->e, size);
break;
case MKV_CLUSTER_TIMECODE:
kr_ebml2_unpack_uint64 (mkv->e, &mkv->cluster_timecode, size);
break;
case MKV_SIMPLEBLOCK:
kr_mkv_parse_simpleblock (mkv, size, track, timecode, flags);
kr_ebml2_unpack_data ( mkv->e, buffer, size - 4 );
return size - 4;
default:
printke ("Err! Unknown element: %"PRIu64" bytes", size);
return -1;
break;
}
}
return 0;
}
void kr_io2_pack(kr_io2_t *io, void *buffer, size_t len) {
if (len > io->space) {
printk("io2_pack len: %zu buf len: %zu new len: %zu size: %zu space: %zu",
len, io->len, len + io->len, io->size, io->space);
printke("buffer overpack cancelling!");
return;
}
memcpy (io->buf, buffer, len);
kr_io2_advance (io, len);
}
static int kr_mkv_parse_segment_info (kr_mkv_t *mkv, uint64_t max_pos) {
int ret;
uint32_t id;
uint64_t size;
while (1) {
if (mkv->e->pos >= max_pos) {
printk ("Got to end of segment info");
break;
}
ret = kr_ebml2_unpack_id (mkv->e, &id, &size);
if (ret < 0) {
printke ("Read error..");
return -1;
}
switch (id) {
case MKV_SEGMENT_TITLE:
//kr_ebml2_unpack_uint64 (mkv->e, &mkv->timecode_scale, size);
//break;
printk ("Skipping TITLE: %"PRIu64" bytes",
size);
kr_ebml2_advance (mkv->e, size);
break;
case MKV_SEGMENT_TIMECODESCALE:
kr_ebml2_unpack_uint64 (mkv->e, &mkv->timecode_scale, size);
break;
case MKV_SEGMENT_DURATION:
kr_ebml2_unpack_double (mkv->e, &mkv->duration, size);
break;
case MKV_SEGMENT_UID:
case MKV_SEGMENT_FILENAME:
case MKV_SEGMENT_PREVUID:
case MKV_SEGMENT_PREVFILENAME:
case MKV_SEGMENT_NEXTUID:
case MKV_SEGMENT_NEXTFILENAME:
case MKV_SEGMENT_FAMILY:
case MKV_SEGMENT_CHAPTERTRANSLATE:
case MKV_SEGMENT_DATEUTC:
case MKV_SEGMENT_MUXINGAPP:
case MKV_SEGMENT_WRITINGAPP:
kr_ebml2_advance (mkv->e, size);
break;
default:
printk ("Skipping unknown element in segment info: %"PRIu64" bytes",
size);
kr_ebml2_advance (mkv->e, size);
break;
}
}
return 0;
}
krad_x11_t *krad_x11_create () {
krad_x11_t *krad_x11;
if ((krad_x11 = calloc (1, sizeof (krad_x11_t))) == NULL) {
failfast ("krad_x11 mem alloc fail");
}
printke ("x11 is disabled and fake");
return krad_x11;
}
void krad_system_monitor_cpu_on () {
if (krad_system.kcm.on == 0) {
if (krad_control_init (&krad_system.kcm.control)) {
printke ("Krad System: can't socketpair errno: %d", errno);
return;
}
krad_system.kcm.on = 1;
pthread_create (&krad_system.kcm.monitor_thread, NULL, krad_system_monitor_cpu_thread, NULL);
}
}
int set_socket_nodelay(int sd) {
int ret;
const int val = 1;
ret = setsockopt(sd, IPPROTO_TCP, TCP_NODELAY, (const void *)&val,
(socklen_t)sizeof(int));
if (ret != 0) {
printke("Could not set socket to TCP_NODELAY");
}
return ret;
}
int set_socket_reuseaddr(int sd) {
int ret;
const int val = 1;
ret = setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (const void *)&val,
(socklen_t)sizeof(int));
if (ret != 0) {
printke("Could not set socket to SO_REUSEADDR");
}
return ret;
}