int32_t coolapi_open_device (int32_t demux_index, int32_t demux_id)
{
int32_t result = 0;
buffer_open_arg_t bufarg;
channel_open_arg_t chanarg;
int32_t uBufferSize = 8256;
dmx_t * dmx;
coolapi_open();
dmx = find_demux(0, demux_index);
if(dmx == 0) {
cs_log("no free demux found");
return 0;
}
dmx->demux_index = demux_index;
dmx->demux_id = demux_id;
dmx->pid = -1;
memset(&bufarg, 0, sizeof(bufarg));
dmx->device = dmx_device[demux_index];
dmx->opened = true;
bufarg.type = 3;
bufarg.size = uBufferSize;
bufarg.unknown3 = (uBufferSize * 7) / 8;
result = cnxt_cbuf_open(&dmx->buffer1, &bufarg, NULL, NULL);
check_error ("cnxt_cbuf_open", result);
bufarg.type = 0;
result = cnxt_cbuf_open(&dmx->buffer2, &bufarg, NULL, NULL);
check_error ("cnxt_cbuf_open", result);
memset(&chanarg, 0, sizeof(channel_open_arg_t));
chanarg.type = 4;
result = cnxt_dmx_channel_open(dmx->device, &dmx->channel, &chanarg, dmx_callback, dmx);
check_error ("cnxt_dmx_channel_open", result);
result = cnxt_dmx_set_channel_buffer(dmx->channel, 0, dmx->buffer1);
check_error ("cnxt_dmx_set_channel_buffer", result);
result = cnxt_dmx_channel_attach(dmx->channel, 0xB, 0, dmx->buffer2);
check_error ("cnxt_dmx_channel_attach", result);
result = cnxt_cbuf_attach(dmx->buffer2, 2, dmx->channel);
check_error ("cnxt_cbuf_attach", result);
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK_NP);
pthread_mutex_init(&dmx->mutex, &attr);
cs_debug_mask(D_DVBAPI, "fd %08x demux #%d demux_id %d channel %x", dmx->fd, demux_index, demux_id, (int) dmx->channel);
return dmx->fd;
}
int32_t coolapi_set_filter (int32_t fd, int32_t num, int32_t pid, uchar * flt, uchar * mask, int32_t type)
{
dmx_t * dmx = find_demux(fd, 0);
if(!dmx) {
cs_debug_mask(D_DVBAPI, "dmx is NULL!");
return -1;
}
int32_t result, channel_found=0;
void * channel = NULL;
if (ll_count(ll_cool_chanhandle) > 0) {
LL_ITER itr = ll_iter_create(ll_cool_chanhandle);
S_COOL_CHANHANDLE *handle_item;
while ((handle_item=ll_iter_next(&itr))) {
if (handle_item->demux_index == dmx->demux_index && handle_item->pid == pid) {
channel = handle_item->channel;
channel_found=1;
break;
}
}
}
if (!channel) {
buffer_open_arg_t bufarg;
int32_t uBufferSize = 8256;
memset(&bufarg, 0, sizeof(bufarg));
bufarg.type = 3;
bufarg.size = uBufferSize;
bufarg.unknown3 = (uBufferSize * 7) / 8;
result = cnxt_cbuf_open(&dmx->buffer1, &bufarg, NULL, NULL);
coolapi_check_error("cnxt_cbuf_open", result);
bufarg.type = 0;
result = cnxt_cbuf_open(&dmx->buffer2, &bufarg, NULL, NULL);
coolapi_check_error("cnxt_cbuf_open", result);
channel_open_arg_t chanarg;
memset(&chanarg, 0, sizeof(channel_open_arg_t));
chanarg.type = 4;
result = cnxt_dmx_channel_open(dmx->device, &dmx->channel, &chanarg, dmx_callback, dmx);
coolapi_check_error("cnxt_dmx_channel_open", result);
result = cnxt_dmx_set_channel_buffer(dmx->channel, 0, dmx->buffer1);
coolapi_check_error("cnxt_dmx_set_channel_buffer", result);
result = cnxt_dmx_channel_attach(dmx->channel, 0xB, 0, dmx->buffer2);
coolapi_check_error("cnxt_dmx_channel_attach", result);
result = cnxt_cbuf_attach(dmx->buffer2, 2, dmx->channel);
coolapi_check_error("cnxt_cbuf_attach", result);
result = cnxt_dmx_set_channel_pid(dmx->channel, pid);
coolapi_check_error("cnxt_dmx_set_channel_pid", result);
result = cnxt_cbuf_flush (dmx->buffer1, 0);
coolapi_check_error("cnxt_cbuf_flush", result);
result = cnxt_cbuf_flush (dmx->buffer2, 0);
coolapi_check_error("cnxt_cbuf_flush", result);
S_COOL_CHANHANDLE *handle_item;
if (cs_malloc(&handle_item,sizeof(S_COOL_CHANHANDLE))) {
handle_item->pid = pid;
handle_item->channel = dmx->channel;
handle_item->buffer1 = dmx->buffer1;
handle_item->buffer2 = dmx->buffer2;
handle_item->demux_index = dmx->demux_index;
ll_append(ll_cool_chanhandle, handle_item);
}
cs_debug_mask(D_DVBAPI, "opened new channel %x", (int32_t) dmx->channel);
} else {
channel_found=1;
dmx->channel = channel;
dmx->buffer1 = NULL;
dmx->buffer2 = NULL;
}
cs_debug_mask(D_DVBAPI, "setting new filter fd=%08x demux=%d channel=%x num=%d pid=%04x flt=%x mask=%x", fd, dmx->demux_index, (int32_t) dmx->channel, num, pid, flt[0], mask[0]);
pthread_mutex_lock(&dmx->mutex);
filter_set_t filter;
dmx->filter_num = num;
dmx->pid = pid;
dmx->type = type;
memset(&filter, 0, sizeof(filter));
filter.length = 12;
memcpy(filter.filter, flt, 16);
memcpy(filter.mask, mask, 16);
result = cnxt_dmx_open_filter(dmx->device, &dmx->filter);
coolapi_check_error("cnxt_dmx_open_filter", result);
result = cnxt_dmx_set_filter(dmx->filter, &filter, NULL);
coolapi_check_error("cnxt_dmx_set_filter", result);
result = cnxt_dmx_channel_attach_filter(dmx->channel, dmx->filter);
coolapi_check_error("cnxt_dmx_channel_attach_filter", result);
if (channel_found) {
result = cnxt_dmx_channel_ctrl(dmx->channel, 0, 0);
coolapi_check_error("cnxt_dmx_channel_ctrl", result);
}
result = cnxt_dmx_channel_ctrl(dmx->channel, 2, 0);
coolapi_check_error("cnxt_dmx_channel_ctrl", result);
pthread_mutex_unlock(&dmx->mutex);
S_COOL_FILTER *filter_item;
if (cs_malloc(&filter_item,sizeof(S_COOL_FILTER))) {
// fill filter item
filter_item->fd = fd;
filter_item->pid = pid;
filter_item->channel = (int32_t) dmx->channel;
memcpy(filter_item->filter16, flt, 16);
memcpy(filter_item->mask16, mask, 16);
//add filter item
ll_append(ll_cool_filter, filter_item);
}
return 0;
}
int32_t coolapi_set_filter(int32_t fd, int32_t num, int32_t pid, uchar *flt, uchar *mask, int32_t type)
{
dmx_t *dmx = find_demux(fd, 0);
if(!dmx)
{
cs_log_dbg(D_DVBAPI, "dmx is NULL!");
return -1;
}
int32_t result, channel_found;
SAFE_MUTEX_LOCK(&dmx->mutex);
// Find matching channel, if it exists.
S_COOL_CHANHANDLE *handle_item = find_chanhandle(COOLDEMUX_DMX_DEV(fd), pid);
if(!handle_item)
{
// No channel was found, allocate one
buffer_open_arg_t bufarg;
int32_t uBufferSize = 8192 + 64;
/* Mark that we did not find any open channel on this PID */
channel_found = 0;
if(!cs_malloc(&handle_item, sizeof(S_COOL_CHANHANDLE)))
{
return -1;
}
memset(&bufarg, 0, sizeof(bufarg));
#ifdef HAVE_COOLAPI2
bufarg.poolid = 5
#endif
bufarg.type = 3;
bufarg.size = uBufferSize;
bufarg.hwm = (uBufferSize * 7) / 8;
result = cnxt_cbuf_open(&handle_item->buffer1, &bufarg, NULL, NULL);
coolapi_check_error("cnxt_cbuf_open", result);
bufarg.type = 0;
#ifdef HAVE_COOLAPI2
bufarg.poolid = 0
#endif
result = cnxt_cbuf_open(&handle_item->buffer2, &bufarg, NULL, NULL);
coolapi_check_error("cnxt_cbuf_open", result);
channel_open_arg_t chanarg;
memset(&chanarg, 0, sizeof(channel_open_arg_t));
chanarg.type = 4;
result = cnxt_dmx_channel_open(dmx_handles[COOLDEMUX_DMX_DEV(fd)].handle, &handle_item->channel, &chanarg, dmx_callback, dmx);
coolapi_check_error("cnxt_dmx_channel_open", result);
result = cnxt_dmx_set_channel_buffer(handle_item->channel, 0, handle_item->buffer1);
coolapi_check_error("cnxt_dmx_set_channel_buffer", result);
result = cnxt_dmx_channel_attach(handle_item->channel, 0xB, 0, handle_item->buffer2);
coolapi_check_error("cnxt_dmx_channel_attach", result);
result = cnxt_cbuf_attach(handle_item->buffer2, 2, handle_item->channel);
coolapi_check_error("cnxt_cbuf_attach", result);
result = cnxt_dmx_set_channel_pid(handle_item->channel, pid);
coolapi_check_error("cnxt_dmx_set_channel_pid", result);
result = cnxt_cbuf_flush(handle_item->buffer1, 0);
coolapi_check_error("cnxt_cbuf_flush", result);
result = cnxt_cbuf_flush(handle_item->buffer2, 0);
coolapi_check_error("cnxt_cbuf_flush", result);
handle_item->pid = pid;
handle_item->dmx_handle = &dmx_handles[COOLDEMUX_DMX_DEV(fd)];
dmx_handles[COOLDEMUX_DMX_DEV(fd)].allocated_channels++;
ll_append(ll_cool_chanhandle, handle_item);
cs_log_dbg(D_DVBAPI, "opened new channel %x", (int32_t) handle_item->channel);;
}
else
{
channel_found = 1;
}
cs_log_dbg(D_DVBAPI, "setting new filter fd=%08x demux=%d channel=%x num=%d pid=%04x flt=%x mask=%x", fd, COOLDEMUX_DMX_DEV(fd), (int32_t) handle_item->channel, num, pid, flt[0], mask[0]);
void *filter_handle = NULL;
filter_set_t filterset;
int32_t has_filter = 0;
S_COOL_FILTER *filter_item = find_filter_by_chanhandle(handle_item, num);
if (filter_item && type == dmx->type && pid == dmx->pid &&
(memcmp(flt, filter_item->filter16, 16) || memcmp(mask, filter_item->mask16, 16)))
{
cs_log_dbg(D_DVBAPI, "setting new filter fd=%08x demux=%d channel=%x num=%d pid=%04x flt=%x mask=%x, filter exists.. modifying", fd, COOLDEMUX_DMX_DEV(fd), (int32_t) handle_item->channel, num, pid, flt[0], mask[0]);
filter_handle = filter_item->filter;
has_filter = 1;
memcpy(filter_item->filter16, flt, 16);
memcpy(filter_item->mask16, mask, 16);
}
else
{
dmx->pid = pid;
dmx->type = type;
dmx->filter_num = num;
result = cnxt_dmx_open_filter(dmx_handles[COOLDEMUX_DMX_DEV(fd)].handle, &filter_handle);
coolapi_check_error("cnxt_dmx_open_filter", result);
if(!cs_malloc(&filter_item, sizeof(S_COOL_FILTER)))
{
SAFE_MUTEX_UNLOCK(&dmx->mutex);
return -1;
}
// fill filter item
filter_item->fd = fd;
filter_item->filter = filter_handle;
filter_item->filter_num = num;
filter_item->chanhandle = handle_item;
memcpy(filter_item->filter16, flt, 16);
memcpy(filter_item->mask16, mask, 16);
//add filter item
ll_append(ll_cool_filter, filter_item);
// increase allocated filters
handle_item->allocated_filters++;
}
if (has_filter)
{
result = cnxt_dmx_channel_suspend(handle_item->channel, 1);
coolapi_check_error("cnxt_dmx_channel_suspend", result);
result = cnxt_dmx_channel_detach_filter(handle_item->channel, filter_handle);
coolapi_check_error("cnxt_dmx_channel_detach_filter", result);
}
memset(&filterset, 0, sizeof(filterset));
filterset.length = 12;
memcpy(filterset.filter, flt, 16);
memcpy(filterset.mask, mask, 16);
result = cnxt_dmx_set_filter(filter_handle, &filterset, (void *)num);
coolapi_check_error("cnxt_dmx_set_filter", result);
result = cnxt_dmx_channel_attach_filter(handle_item->channel, filter_handle);
coolapi_check_error("cnxt_dmx_channel_attach_filter", result);
if (has_filter)
{
result = cnxt_dmx_channel_suspend(handle_item->channel, 0);
coolapi_check_error("cnxt_dmx_channel_suspend", result);
}
if(!channel_found)
{
// Start channel
result = cnxt_dmx_channel_ctrl(handle_item->channel, 2, 0);
coolapi_check_error("cnxt_dmx_channel_ctrl", result);
}
SAFE_MUTEX_UNLOCK(&dmx->mutex);
return 0;
}