int32_t coolapi_close_device(int32_t fd)
{
int32_t result;
dmx_t * dmx = find_demux(fd, 0);
if(!dmx) {
cs_debug_mask(D_DVBAPI, "dmx is NULL!");
return -1;
}
cs_debug_mask(D_DVBAPI, "fd %08x channel %x pid %x", fd, (int) dmx->channel, dmx->pid);
if(dmx->filter != NULL) {
result = cnxt_dmx_channel_detach_filter(dmx->channel, dmx->filter);
check_error ("cnxt_dmx_channel_detach_filter", result);
result = cnxt_dmx_close_filter(dmx->filter);
check_error ("cnxt_dmx_close_filter", result);
dmx->filter = NULL;
dmx->filter_attached = false;
}
result = cnxt_cbuf_detach(dmx->buffer2, 2, dmx->channel);
check_error ("cnxt_cbuf_detach", result);
result = cnxt_dmx_channel_detach(dmx->channel, 0xB, 0, dmx->buffer2);
check_error ("cnxt_dmx_channel_detach", result);
result = cnxt_dmx_channel_detach(dmx->channel, 0xB, 0, dmx->buffer1);
check_error ("cnxt_dmx_channel_detach", result);
result = cnxt_dmx_channel_close(dmx->channel);
check_error ("cnxt_dmx_channel_close", result);
result = cnxt_cbuf_close(dmx->buffer2);
check_error ("cnxt_cbuf_close", result);
result = cnxt_cbuf_close(dmx->buffer1);
check_error ("cnxt_cbuf_close", result);
dmx->opened = false;
pthread_mutex_destroy(&dmx->mutex);
memset(dmx, 0, sizeof(dmx_t));
return 0;
}
int32_t coolapi_remove_filter (int32_t fd, int32_t num)
{
dmx_t * dmx = find_demux(fd, 0);
if(!dmx) {
cs_debug_mask(D_DVBAPI, "dmx is NULL!");
return -1;
}
if(dmx->pid <= 0)
return -1;
int32_t result, filter_on_channel=0;
cs_debug_mask(D_DVBAPI, "removing filter fd=%08x num=%d pid=%04x on channel=%x", fd, num, dmx->pid, (int32_t) dmx->channel);
pthread_mutex_lock(&dmx->mutex);
if(dmx->filter) {
result = cnxt_dmx_channel_detach_filter(dmx->channel, dmx->filter);
coolapi_check_error("cnxt_dmx_channel_detach_filter", result);
result = cnxt_dmx_close_filter(dmx->filter);
coolapi_check_error("cnxt_dmx_close_filter", result);
dmx->filter = NULL;
result = cnxt_dmx_channel_ctrl(dmx->channel, 0, 0);
coolapi_check_error("cnxt_dmx_channel_ctrl", result);
}
LL_ITER itr = ll_iter_create(ll_cool_filter);
S_COOL_FILTER *filter_item;
while ((filter_item=ll_iter_next(&itr))) {
if (filter_item->channel == (int32_t) dmx->channel)
filter_on_channel++;
if (filter_item->fd == fd) {
ll_iter_remove_data(&itr);
filter_on_channel--;
}
}
if (!filter_on_channel) {
cs_debug_mask(D_DVBAPI, "closing channel %x", (int32_t) dmx->channel);
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 == dmx->pid) {
dmx->buffer1=handle_item->buffer1;
dmx->buffer2=handle_item->buffer2;
ll_iter_remove_data(&itr);
break;
}
}
if (!dmx->buffer1 || !dmx->buffer2)
cs_debug_mask(D_DVBAPI, "WARNING: buffer handle not found!");
result = cnxt_dmx_channel_ctrl(dmx->channel, 0, 0);
coolapi_check_error("cnxt_dmx_channel_ctrl", result);
result = cnxt_dmx_set_channel_pid(dmx->channel, 0x1FFF);
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);
result = cnxt_cbuf_detach(dmx->buffer2, 2, dmx->channel);
coolapi_check_error("cnxt_cbuf_detach", result);
result = cnxt_dmx_channel_detach(dmx->channel, 0xB, 0, dmx->buffer1);
coolapi_check_error("cnxt_dmx_channel_detach", result);
result = cnxt_dmx_channel_close(dmx->channel);
coolapi_check_error("cnxt_dmx_channel_close", result);
result = cnxt_cbuf_close(dmx->buffer2);
coolapi_check_error("cnxt_cbuf_close", result);
result = cnxt_cbuf_close(dmx->buffer1);
coolapi_check_error("cnxt_cbuf_close", result);
}
if (filter_on_channel) {
result = cnxt_dmx_channel_ctrl(dmx->channel, 2, 0);
coolapi_check_error("cnxt_dmx_channel_ctrl", result);
}
pthread_mutex_unlock(&dmx->mutex);
dmx->pid = -1;
return 0;
}
int32_t coolapi_remove_filter(int32_t fd, int32_t num)
{
void * channel = NULL;
void * filter = NULL;
dmx_t *dmx = find_demux(fd, 0);
if(!dmx)
{
cs_log_dbg(D_DVBAPI, "dmx is NULL!");
return -1;
}
if(dmx->pid <= 0)
{ return -1; }
int32_t result;
SAFE_MUTEX_LOCK(&dmx->mutex);
// Find matching channel, if it exists.
S_COOL_CHANHANDLE *handle_item = find_chanhandle(COOLDEMUX_DMX_DEV(fd), dmx->pid);
if (!handle_item)
{
SAFE_MUTEX_UNLOCK(&dmx->mutex);
cs_log_dbg(D_DVBAPI, "removing filter fd=%08x num=%d pid=%04xcfailed, channel does not exist.", fd, num, dmx->pid);
return -1;
}
channel = handle_item->channel;
cs_log_dbg(D_DVBAPI, "removing filter fd=%08x num=%d pid=%04x on channel=%p", fd, num, dmx->pid, channel);
S_COOL_FILTER *filter_item = find_filter_by_chanhandle(handle_item, num);
if(filter_item)
{
result = cnxt_dmx_channel_suspend(channel, 1);
coolapi_check_error("cnxt_dmx_channel_suspend", result);
result = cnxt_dmx_channel_detach_filter(channel, filter_item->filter);
coolapi_check_error("cnxt_dmx_channel_detach_filter", result);
#if 0
result = cnxt_dmx_close_filter(filter_item->filter);
coolapi_check_error("cnxt_dmx_close_filter", result);
#endif
filter = filter_item->filter;
remove_filter(filter_item);
handle_item->allocated_filters--;
}
else
{
SAFE_MUTEX_UNLOCK(&dmx->mutex);
cs_log_dbg(D_DVBAPI, "removing filter fd=%08x num=%d pid=%04x on channel=%x failed, channel does not exist.", fd, num, dmx->pid, (int32_t) handle_item->channel);
return -1;
}
if (!handle_item->allocated_filters)
{
result = cnxt_dmx_channel_ctrl(channel, 0, 0);
coolapi_check_error("cnxt_dmx_channel_ctrl", result);
cs_log_dbg(D_DVBAPI, "closing channel %x", (int32_t) channel);
result = cnxt_dmx_set_channel_pid(channel, 0x1FFF);
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);
result = cnxt_cbuf_detach(handle_item->buffer2, 2, channel);
coolapi_check_error("cnxt_cbuf_detach", result);
result = cnxt_dmx_channel_detach(channel, 0xB, 0, handle_item->buffer1);
coolapi_check_error("cnxt_dmx_channel_detach", result);
#if 0
result = cnxt_dmx_channel_close(channel);
coolapi_check_error("cnxt_dmx_channel_close", result);
#endif
result = cnxt_cbuf_close(handle_item->buffer2);
coolapi_check_error("cnxt_cbuf_close", result);
result = cnxt_cbuf_close(handle_item->buffer1);
coolapi_check_error("cnxt_cbuf_close", result);
handle_item->channel = NULL;
handle_item->buffer1 = NULL;
handle_item->buffer2 = NULL;
remove_chanhandle(handle_item);
dmx_handles[COOLDEMUX_DMX_DEV(fd)].allocated_channels--;
dmx->pid = -1;
} else {
result = cnxt_dmx_channel_suspend(channel, 0);
coolapi_check_error("cnxt_dmx_channel_suspend", result);
channel = NULL;
}
SAFE_MUTEX_UNLOCK(&dmx->mutex);
if (filter) {
result = cnxt_dmx_close_filter(filter);
coolapi_check_error("cnxt_dmx_close_filter", result);
}
if (channel) {
result = cnxt_dmx_channel_close(channel);
coolapi_check_error("cnxt_dmx_channel_close", result);
}
return 0;
}