Changeset 11023
- Timestamp:
- 09/30/15 23:11:35 (9 years ago)
- Location:
- trunk
- Files:
-
- 13 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Makefile
r10875 r11023 95 95 DEFAULT_STAPI5_LIB = -L./stapi -loscam_stapi5 96 96 DEFAULT_COOLAPI_LIB = -lnxp -lrt 97 DEFAULT_COOLAPI2_LIB = -llnxUKAL -llnxcssUsr -llnxscsUsr -llnxnotifyqUsr -llnxplatUsr -lrt 97 98 DEFAULT_SU980_LIB = -lentropic -lrt 98 99 DEFAULT_AZBOX_LIB = -Lextapi/openxcas -lOpenXCASAPI … … 160 161 $(eval $(call prepare_use_flags,STAPI5,stapi5)) 161 162 $(eval $(call prepare_use_flags,COOLAPI,coolapi)) 163 $(eval $(call prepare_use_flags,COOLAPI2,coolapi2)) 162 164 $(eval $(call prepare_use_flags,SU980,su980)) 163 165 $(eval $(call prepare_use_flags,AZBOX,azbox)) … … 242 244 SRC-$(CONFIG_CARDREADER_INTERNAL_AZBOX) += csctapi/ifd_azbox.c 243 245 SRC-$(CONFIG_CARDREADER_INTERNAL_COOLAPI) += csctapi/ifd_cool.c 246 SRC-$(CONFIG_CARDREADER_INTERNAL_COOLAPI2) += csctapi/ifd_cool.c 244 247 SRC-$(CONFIG_CARDREADER_DB2COM) += csctapi/ifd_db2com.c 245 248 SRC-$(CONFIG_CARDREADER_MP35) += csctapi/ifd_mp35.c … … 270 273 SRC-$(CONFIG_WITH_MCA) += module-dvbapi-mca.c 271 274 SRC-$(CONFIG_WITH_COOLAPI) += module-dvbapi-coolapi.c 275 SRC-$(CONFIG_WITH_COOLAPI2) += module-dvbapi-coolapi.c 272 276 SRC-$(CONFIG_WITH_SU980) += module-dvbapi-coolapi.c 273 277 SRC-$(CONFIG_WITH_STAPI) += module-dvbapi-stapi.c … … 591 595 library in your cross compilation toolchain.\n\ 592 596 \n\ 597 USE_COOLAPI2=1 - Request support for Coolstream API aka NeutrinoHD\n\ 598 box. The variables that control the build are:\n\ 599 COOLAPI_FLAGS='$(DEFAULT_COOLAPI2_FLAGS)'\n\ 600 COOLAPI_CFLAGS='$(DEFAULT_COOLAPI2_FLAGS)'\n\ 601 COOLAPI_LDFLAGS='$(DEFAULT_COOLAPI2_FLAGS)'\n\ 602 COOLAPI_LIB='$(DEFAULT_COOLAPI2_LIB)'\n\ 603 Using USE_COOLAPI2=1 adds to '-coolapi2' to PLUS_TARGET.\n\ 604 In order for USE_COOLAPI2 to work you have to have liblnxUKAL.so,\n\ 605 liblnxcssUsr.so, liblnxscsUsr.so, liblnxnotifyqUsr.so, liblnxplatUsr.so\n\ 606 library in your cross compilation toolchain.\n\ 607 \n\ 593 608 USE_SU980=1 - Request support for SU980 API (libentropic) aka Enimga2 arm\n\ 594 609 box. The variables that control the build are:\n\ … … 710 725 make azbox - Builds OSCam for AZBox STBs\n\ 711 726 make mca - Builds OSCam for Matrix Cam Air (MCA)\n\ 712 make coolstream - Builds OSCam for Coolstream\n\ 727 make coolstream - Builds OSCam for Coolstream HD1\n\ 728 make coolstream2 - Builds OSCam for Coolstream HD2\n\ 713 729 make dockstar - Builds OSCam for Dockstar\n\ 714 730 make qboxhd - Builds OSCam for QBoxHD STBs\n\ … … 738 754 Build OSCam for ARM with COOLAPI (coolstream aka NeutrinoHD):\n\ 739 755 make CROSS=arm-cx2450x-linux-gnueabi- USE_COOLAPI=1\n\n\ 756 Build OSCam for ARM with COOLAPI2 (coolstream aka NeutrinoHD):\n\ 757 make CROSS=arm-pnx8400-linux-uclibcgnueabi- USE_COOLAPI2=1\n\n\ 740 758 Build OSCam for MIPSEL with AZBOX support:\n\ 741 759 make CROSS=mipsel-linux-uclibc- USE_AZBOX=1\n\n\ -
trunk/Makefile.extra
r9285 r11023 224 224 $(MAKEFLAGS) 225 225 226 cool2: 227 $(MAKE) --no-print-directory \ 228 CROSS=arm-pnx8400-linux-uclibcgnueabi- \ 229 CONF_DIR=/var/tuxbox/config \ 230 USE_COOLAPI2=1 \ 231 $(MAKEFLAGS) 232 226 233 neutrinohd: cool 227 234 coolstream: cool 235 236 neutrinohd2: cool2 237 coolstream2: cool2 228 238 229 239 su980: -
trunk/config.h
r10789 r11023 72 72 // CARDREADER_INTERNAL_{AZBOX,COOLAPI,SCI} are internal variables 73 73 // do not touch them 74 #if defined(CARDREADER_INTERNAL) && defined(WITH_AZBOX)74 #if (defined(CARDREADER_INTERNAL) && defined(WITH_AZBOX)) 75 75 #define CARDREADER_INTERNAL_AZBOX 1 76 #elif defined(CARDREADER_INTERNAL) && (defined(WITH_COOLAPI) || defined(WITH_SU980))76 #elif (defined(CARDREADER_INTERNAL) && (defined(WITH_COOLAPI) || defined(WITH_SU980))) 77 77 #define CARDREADER_INTERNAL_COOLAPI 1 78 #elif defined(CARDREADER_INTERNAL) && defined(WITH_COOLAPI2) 79 #define CARDREADER_INTERNAL_COOLAPI2 1 78 80 #elif defined(CARDREADER_INTERNAL) 79 81 #define CARDREADER_INTERNAL_SCI 1 -
trunk/config.sh
r10894 r11023 134 134 for FLAG in $USE_FLAGS 135 135 do 136 [ $FLAG= "$1" ] && return 0136 [ "$FLAG" = "$1" ] && return 0 137 137 done 138 138 return 1 … … 156 156 for FLAG in $USE_FLAGS 157 157 do 158 [ $FLAG= "$1" ] && return 1158 [ "$FLAG" = "$1" ] && return 1 159 159 done 160 160 return 0 … … 303 303 have_flag USE_STAPI5 && echo "CONFIG_WITH_STAPI5=y" || echo "# CONFIG_WITH_STAPI5=n" 304 304 have_flag USE_COOLAPI && echo "CONFIG_WITH_COOLAPI=y" || echo "# CONFIG_WITH_COOLAPI=n" 305 have_flag USE_COOLAPI2 && echo "CONFIG_WITH_COOLAPI2=y" || echo "# CONFIG_WITH_COOLAPI2=n" 305 306 have_flag USE_SU980 && echo "CONFIG_WITH_SU980=y" || echo "# CONFIG_WITH_SU980=n" 306 307 have_flag USE_AZBOX && echo "CONFIG_WITH_AZBOX=y" || echo "# CONFIG_WITH_AZBOX=n" … … 318 319 enabled $OPT && have_flag USE_AZBOX && echo "CONFIG_${OPT}_AZBOX=y" || echo "# CONFIG_${OPT}_AZBOX=n" 319 320 enabled $OPT && have_any_flags USE_COOLAPI USE_SU980 && echo "CONFIG_${OPT}_COOLAPI=y" || echo "# CONFIG_${OPT}_COOLAPI=n" 320 enabled $OPT && not_have_all_flags USE_AZBOX USE_COOLAPI USE_SU980 && echo "CONFIG_${OPT}_SCI=y" || echo "# CONFIG_${OPT}_SCI=n" 321 enabled $OPT && have_flag USE_COOLAPI2 && echo "CONFIG_${OPT}_COOLAPI2=y" || echo "# CONFIG_${OPT}_COOLAPI2=n" 322 enabled $OPT && not_have_all_flags USE_AZBOX USE_COOLAPI USE_COOLAPI2 USE_SU980 && echo "CONFIG_${OPT}_SCI=y" || echo "# CONFIG_${OPT}_SCI=n" 321 323 continue 322 324 fi -
trunk/csctapi/ifd_cool.c
r10577 r11023 5 5 #include"../globals.h" 6 6 7 #if def CARDREADER_INTERNAL_COOLAPI7 #if defined(CARDREADER_INTERNAL_COOLAPI) || defined(CARDREADER_INTERNAL_COOLAPI2) 8 8 #include "../extapi/coolapi.h" 9 9 #include "../oscam-string.h" -
trunk/csctapi/ifd_stinger.c
r10749 r11023 48 48 int64_t polltimeout = timeout_us / 1000; 49 49 50 #if !defined(WITH_COOLAPI) && !defined(WITH_ AZBOX)50 #if !defined(WITH_COOLAPI) && !defined(WITH_COOLAPI2) && !defined(WITH_AZBOX) 51 51 52 52 if(reader->typ == R_INTERNAL) { return OK; } // needed for internal readers, otherwise error! -
trunk/csctapi/io_serial.c
r10749 r11023 745 745 int64_t polltimeout = timeout_us / 1000; 746 746 747 #if !defined(WITH_COOLAPI) 747 #if !defined(WITH_COOLAPI) && defined(WITH_COOLAPI2) 748 748 if(reader->typ == R_INTERNAL) { return OK; } // needed for internal readers, otherwise error! 749 749 #endif -
trunk/extapi/coolapi.h
r8960 r11023 44 44 } CNXT_SMC_COMM; 45 45 46 typedef struct 47 { 48 uint8_t *pStartAddress; 49 uint8_t *pEndAddress; 50 uint8_t *pWriteAddress; 51 uint8_t *pReadAddress; 52 } CNXT_CBUF_POINTERS; 53 46 54 /* These functions are implemented in libnxp and are used in coolstream */ 47 55 int32_t cnxt_cbuf_init(void *); … … 52 60 int32_t cnxt_cbuf_read_data(void * handle, void *buffer, uint32_t size, uint32_t * ret_size); 53 61 int32_t cnxt_cbuf_flush(void * handle, int); 62 int32_t cnxt_cbuf_removed_data(void *handle, uint32_t bytes); 63 int32_t cnxt_cbuf_get_pointers(void *handle, CNXT_CBUF_POINTERS *buffer_pointers); 54 64 55 65 void cnxt_kal_initialize(void); … … 220 230 } while(0) 221 231 222 #if defined(HAVE_DVBAPI) && (defined(WITH_COOLAPI) || defined(WITH_SU980) )232 #if defined(HAVE_DVBAPI) && (defined(WITH_COOLAPI) || defined(WITH_SU980) || defined(WITH_COOLAPI2)) 223 233 extern void coolapi_open_all(void); 224 234 extern void coolapi_close_all(void); -
trunk/module-dvbapi-coolapi.c
r10817 r11023 5 5 #include "globals.h" 6 6 7 #if defined(HAVE_DVBAPI) && defined(WITH_COOLAPI) 8 7 #if defined(HAVE_DVBAPI) && (defined(WITH_SU980) || defined(WITH_COOLAPI2) || defined(WITH_COOLAPI)) 9 8 #include "extapi/coolapi.h" 10 9 11 10 #include "module-dvbapi.h" 12 11 #include "module-dvbapi-coolapi.h" 13 #include "oscam-string.h" 12 #include "oscam-string.h" 13 14 14 15 15 #define MAX_COOL_DMX 4 16 16 17 //kronos-Plattform (Coolsterem ZEE²) 18 //#define MAX_COOL_DMX 3 19 20 21 #define DMX_MAX_FILTERS_PER_CHAN 16 22 #define DMX_MAX_CHANNELS_PER_DMX 192 23 //#define MAX_COOL_DMX_FILTERS 128 24 25 struct s_cool_chanhandle; 26 17 27 typedef struct s_cool_filter 18 28 { 19 29 int32_t fd; 20 int32_t channel; 21 int32_t pid; 30 struct s_cool_chanhandle *chanhandle; 31 void *filter; 32 int32_t filter_num; 22 33 uchar filter16[16]; 23 34 uchar mask16[16]; … … 27 38 { 28 39 int32_t pid; 29 void *buffer1; 30 void *buffer2; 31 void *channel; 32 int32_t demux_index; 40 void *buffer1; // filter Cbuf 1 41 void *buffer2; // filter Cbuf 2 42 void *channel; 43 int32_t demux_index; 44 struct s_cool_dmxhandle *dmx_handle; 45 uint32_t allocated_filters; 33 46 } S_COOL_CHANHANDLE; 34 47 48 typedef struct s_cool_dmxhandle 49 { 50 void *handle; 51 uint32_t allocated_channels; 52 } S_COOL_DMXHANDLE; 53 35 54 struct cool_dmx 36 55 { 56 int32_t pid; 37 57 int32_t opened; 38 58 int32_t fd; 39 uchar buffer[4096];40 void *buffer1;41 void *buffer2;42 void *channel;43 void *filter;44 void *device;45 int32_t pid;46 59 pthread_mutex_t mutex; 47 int32_t demux_index;60 int32_t filter_num; 48 61 int32_t demux_id; 49 int32_t filter_num;50 62 int32_t type; 51 63 }; … … 56 68 int32_t type; 57 69 uint32_t size; 70 #ifdef HAVE_COOLAPI2 71 uint32_t ptsbufsize; 72 #endif 58 73 int32_t unknown1; 59 74 int16_t unknown2; 60 int32_t unknown3; 61 int32_t unknown[4]; 75 int32_t hwm; 76 int32_t lwm; 77 int32_t unknown5; 78 int32_t unknown6; 79 int32_t poolid; 80 #ifdef HAVE_COOLAPI2 81 uint32_t unit; 82 #endif 62 83 } buffer_open_arg_t; 63 84 … … 68 89 } channel_open_arg_t; 69 90 91 // Nevis : 13 92 // Apollo: 13 70 93 typedef struct 71 94 { 72 95 uint32_t number; 73 int32_t unknown1; 74 int32_t unknown2; 75 int32_t unknown3; 76 int32_t unknown4; 96 int32_t unknown1; // channel source 97 int32_t unknown2; // mcard cap 98 int32_t unknown3; // descrambler type 99 int32_t unknown4; // support legacy NDS 77 100 int32_t unknown5; 78 101 int32_t unknown6; … … 121 144 void *channel; 122 145 DATA_ACQUIRE_STATUS type; 123 DMX_PTS ptssnapshop; 146 // 147 DMX_PTS ptssnapshot; 148 void *buf; 149 uint32_t start; 150 // 124 151 DATA_ACQUIRE_MODE mode; 125 void *buf;126 152 uint32_t len; 127 uint 32_t num;128 void *filters[ 64];129 void *tags[ 64];153 uint16_t num; 154 void *filters[DMX_MAX_FILTERS_PER_CHAN]; 155 void *tags[DMX_MAX_FILTERS_PER_CHAN]; 130 156 } dmx_callback_data_t; 131 157 … … 138 164 139 165 /* Local coolapi functions */ 140 static void coolapi_open(void); 141 static int32_t coolapi_read(dmx_t *dmx, dmx_callback_data_t *data); 166 static int32_t coolapi_read(dmx_t *dmx, dmx_callback_data_t *dataa, uchar *buffer); 142 167 143 168 static int8_t dmx_opened; 144 int 8_tcool_kal_opened = 0;145 146 static void *dmx_device[MAX_COOL_DMX];169 int32_t cool_kal_opened = 0; 170 171 static S_COOL_DMXHANDLE dmx_handles[MAX_COOL_DMX]; 147 172 static dmx_t cdemuxes[MAX_COOL_DMX][MAX_FILTER]; 148 173 static pthread_mutex_t demux_lock = PTHREAD_MUTEX_INITIALIZER; 149 174 extern void *dvbapi_client; 150 175 … … 154 179 #define COOLDEMUX_FD(device, num) (('O' << 24) | ('S' << 16) | (device << 8) | num) 155 180 #define COOLDEMUX_DMX_DEV(fd) (((fd) >> 8) & 0xFF) 181 #define COOLDEMUX_FLT_IDX(fd) (((fd) >> 0) & 0xFF) 182 #define COOLDEMUX_IS_VALID_FD(fd) ((((fd) & 0xFF000000) == ('O' << 24)) && \ 183 (((fd) & 0x00FF0000) == ('S' << 16))) 184 185 #define COOLDEMUX_DATA_RECEIVED 1 186 #define COOLDEMUX_CHANNEL_TIMEOUT 2 187 #define COOLDEMUX_CRC_ERROR 3 188 #define COOLDEMUX_BUFF_OVERFLOW 4 156 189 157 190 static dmx_t *find_demux(int32_t fd, int32_t dmx_dev_num) … … 163 196 } 164 197 165 int32_t i, idx;166 167 idx = dmx_dev_num; 168 if(fd == 0) 198 dmx_t *dmx; 199 int32_t i; 200 201 if(fd == 0) // DEMUX FILTER ALLOCATE 169 202 { 170 203 for(i = 0; i < MAX_FILTER; i++) 171 204 { 172 if(!cdemuxes[idx][i].opened) 205 dmx = &cdemuxes[dmx_dev_num][i]; 206 if(!dmx->opened) 173 207 { 174 cdemuxes[idx][i].fd = COOLDEMUX_FD(dmx_dev_num, i); 175 cs_log_dbg(D_DVBAPI, "opening new fd: %08x", cdemuxes[idx][i].fd); 176 cdemuxes[idx][i].demux_index = dmx_dev_num; 177 return &cdemuxes[idx][i]; 208 dmx->fd = COOLDEMUX_FD(dmx_dev_num, i); 209 cs_log_dbg(D_DVBAPI, "opening new fd: %08x", dmx->fd); 210 return dmx; 178 211 } 179 212 } … … 182 215 } 183 216 184 idx = COOLDEMUX_DMX_DEV(fd); 217 if (!COOLDEMUX_IS_VALID_FD(fd)) 218 { 219 cs_log_dbg(D_DVBAPI, "ERROR: invalid FD"); 220 return NULL; 221 } 222 223 dmx_dev_num = COOLDEMUX_DMX_DEV(fd); 185 224 for(i = 0; i < MAX_FILTER; i++) 186 225 { 187 if(cdemuxes[idx][i].fd == fd) 188 { return &cdemuxes[idx][i]; } 226 dmx = &cdemuxes[dmx_dev_num][i]; 227 if(dmx->fd == fd) 228 { 229 return dmx; 230 } 189 231 } 190 232 … … 192 234 193 235 return NULL; 236 } 237 238 int32_t coolapi_get_filter_num(int32_t fd) 239 { 240 if (!COOLDEMUX_IS_VALID_FD(fd)) 241 { 242 cs_log_dbg(D_DVBAPI, "ERROR: invalid FD"); 243 return -1; 244 } 245 246 return cdemuxes[COOLDEMUX_DMX_DEV(fd)][COOLDEMUX_FLT_IDX(fd)].filter_num; 247 } 248 249 static S_COOL_CHANHANDLE *find_chanhandle(int32_t demux_index, int32_t pid) 250 { 251 // Find matching channel, if it exists. 252 if(ll_count(ll_cool_chanhandle) > 0) 253 { 254 LL_ITER itr = ll_iter_create(ll_cool_chanhandle); 255 S_COOL_CHANHANDLE *handle_item; 256 257 while((handle_item = ll_iter_next(&itr))) 258 { 259 if(handle_item->demux_index == demux_index && handle_item->pid == pid) 260 { 261 return handle_item; 262 } 263 } 264 } 265 266 return NULL; 267 } 268 269 static int32_t remove_chanhandle(S_COOL_CHANHANDLE *handle) 270 { 271 // Find matching channel, if it exists. 272 if(ll_count(ll_cool_chanhandle) > 0) 273 { 274 LL_ITER itr = ll_iter_create(ll_cool_chanhandle); 275 S_COOL_CHANHANDLE *handle_item; 276 277 while((handle_item = ll_iter_next(&itr))) 278 { 279 if(handle_item == handle) 280 { 281 ll_iter_remove_data(&itr); 282 return 0; 283 } 284 } 285 } 286 287 return -1; 288 } 289 290 static S_COOL_FILTER *find_filter_by_chanhandle(S_COOL_CHANHANDLE *chanhandle, int32_t filter_num) 291 { 292 // Find matching channel, if it exists. 293 if(ll_count(ll_cool_filter) > 0) 294 { 295 LL_ITER itr = ll_iter_create(ll_cool_filter); 296 S_COOL_FILTER *filter_item; 297 298 while((filter_item = ll_iter_next(&itr))) 299 { 300 if(filter_item->chanhandle == chanhandle && filter_item->filter_num == filter_num) 301 { 302 return filter_item; 303 } 304 } 305 } 306 307 return NULL; 308 } 309 310 static S_COOL_FILTER *find_filter_by_channel(void *channel, int32_t filter_num) 311 { 312 // Find matching channel, if it exists. 313 if(ll_count(ll_cool_filter) > 0) 314 { 315 LL_ITER itr = ll_iter_create(ll_cool_filter); 316 S_COOL_FILTER *filter_item; 317 318 while((filter_item = ll_iter_next(&itr))) 319 { 320 if(filter_item->chanhandle && 321 filter_item->chanhandle->channel == channel && 322 filter_item->filter_num == filter_num) 323 { 324 return filter_item; 325 } 326 } 327 } 328 329 return NULL; 330 } 331 332 static int32_t remove_filter(S_COOL_FILTER *filter_handle) 333 { 334 if(ll_count(ll_cool_filter) > 0) 335 { 336 LL_ITER itr = ll_iter_create(ll_cool_filter); 337 S_COOL_FILTER *filter_item; 338 339 while((filter_item = ll_iter_next(&itr))) 340 { 341 if(filter_item == filter_handle) 342 { 343 ll_iter_remove_data(&itr); 344 return 0; 345 } 346 } 347 } 348 349 return -1; 194 350 } 195 351 … … 203 359 204 360 int32_t ret; 361 uchar buffer[4096]; 205 362 206 363 SAFE_SETSPECIFIC(getclient, dvbapi_client); 207 364 SAFE_MUTEX_LOCK(&dmx->mutex); 208 memset( dmx->buffer, 0, 4096);209 ret = coolapi_read(dmx, data );365 memset(buffer, 0, sizeof(buffer)); 366 ret = coolapi_read(dmx, data, buffer); 210 367 SAFE_MUTEX_UNLOCK(&dmx->mutex); 211 if(ret > -1) 212 { dvbapi_process_input(dmx->demux_id, dmx->filter_num, dmx->buffer, data->len); } 213 } 214 215 static void dmx_callback(void *UNUSED(unk), dmx_t *dmx, int32_t type, dmx_callback_data_t *data) 368 369 if(ret > -1) { 370 uint16_t filters = data->num; 371 uint16_t flt; 372 373 for (flt = 0; flt < filters; flt++) { 374 uint32_t n = (uint32_t)data->tags[flt]; 375 S_COOL_FILTER *filter = find_filter_by_channel(data->channel, n); 376 377 if (!filter || data->filters[flt] != filter->filter) 378 { 379 cs_log_dbg(D_DVBAPI, "filter not found in notification!!!!"); 380 continue; 381 } 382 383 dvbapi_process_input(dmx->demux_id, n, buffer, data->len); 384 } 385 } 386 } 387 388 static void dmx_callback(void *channel, dmx_t *dmx, int32_t type, dmx_callback_data_t *data) 216 389 { 217 390 if(!dmx) … … 221 394 } 222 395 223 if(data != NULL) 224 { 225 switch(type) 226 { 227 case 0xE: 228 if(data->type == 1 && data->len > 0) 229 { 230 coolapi_read_data(dmx, data); 231 } 232 else 233 { cs_log_dbg(D_DVBAPI, "unknown callback data %d len %d", data->type, data->len); } 234 break; 235 default: 236 break; 237 238 } 396 if(data == NULL) 397 return; 398 399 if (channel != data->channel) 400 return; 401 402 switch(type) 403 { 404 #ifdef WITH_COOLAPI2 405 case 0x11: 406 #else 407 case 0x0E: 408 #endif 409 if(data->type == COOLDEMUX_DATA_RECEIVED && data->len > 0) { 410 coolapi_read_data(dmx, data); 411 } else if(data->type == COOLDEMUX_CRC_ERROR && data->len > 0) { 412 cs_log_dbg(D_DVBAPI, "CRC error !!!"); 413 cnxt_cbuf_removed_data(data->buf, data->len); 414 } else if(data->type == COOLDEMUX_BUFF_OVERFLOW) { 415 cs_log_dbg(D_DVBAPI, "OVERFLOW !!!"); 416 } else { 417 cs_log_dbg(D_DVBAPI, "unknown callback data %d len %d", data->type, data->len); 418 } 419 break; 420 default: 421 break; 239 422 } 240 423 } … … 242 425 int32_t coolapi_set_filter(int32_t fd, int32_t num, int32_t pid, uchar *flt, uchar *mask, int32_t type) 243 426 { 244 dmx_t *dmx = 427 dmx_t *dmx = find_demux(fd, 0); 245 428 if(!dmx) 246 429 { … … 249 432 } 250 433 251 int32_t result, channel_found = 0; 252 253 void *channel = NULL; 254 255 if(ll_count(ll_cool_chanhandle) > 0) 256 { 257 LL_ITER itr = ll_iter_create(ll_cool_chanhandle); 258 S_COOL_CHANHANDLE *handle_item; 259 while((handle_item = ll_iter_next(&itr))) 260 { 261 if(handle_item->demux_index == dmx->demux_index && handle_item->pid == pid) 262 { 263 channel = handle_item->channel; 264 channel_found = 1; 265 break; 266 } 267 } 268 } 269 270 if(!channel) 271 { 434 int32_t result, channel_found; 435 SAFE_MUTEX_LOCK(&dmx->mutex); 436 437 // Find matching channel, if it exists. 438 S_COOL_CHANHANDLE *handle_item = find_chanhandle(COOLDEMUX_DMX_DEV(fd), pid); 439 if(!handle_item) 440 { 441 // No channel was found, allocate one 272 442 buffer_open_arg_t bufarg; 273 int32_t uBufferSize = 8256; 443 int32_t uBufferSize = 8192 + 64; 444 /* Mark that we did not find any open channel on this PID */ 445 channel_found = 0; 446 447 if(!cs_malloc(&handle_item, sizeof(S_COOL_CHANHANDLE))) 448 { 449 return -1; 450 } 451 274 452 memset(&bufarg, 0, sizeof(bufarg)); 275 453 454 #ifdef HAVE_COOLAPI2 455 bufarg.poolid = 5 456 #endif 276 457 bufarg.type = 3; 277 458 bufarg.size = uBufferSize; 278 bufarg. unknown3= (uBufferSize * 7) / 8;279 280 result = cnxt_cbuf_open(& dmx->buffer1, &bufarg, NULL, NULL);459 bufarg.hwm = (uBufferSize * 7) / 8; 460 461 result = cnxt_cbuf_open(&handle_item->buffer1, &bufarg, NULL, NULL); 281 462 coolapi_check_error("cnxt_cbuf_open", result); 282 283 463 bufarg.type = 0; 284 464 285 result = cnxt_cbuf_open(&dmx->buffer2, &bufarg, NULL, NULL); 465 #ifdef HAVE_COOLAPI2 466 bufarg.poolid = 0 467 #endif 468 result = cnxt_cbuf_open(&handle_item->buffer2, &bufarg, NULL, NULL); 286 469 coolapi_check_error("cnxt_cbuf_open", result); 287 470 288 471 channel_open_arg_t chanarg; 289 472 memset(&chanarg, 0, sizeof(channel_open_arg_t)); 473 290 474 chanarg.type = 4; 291 292 result = cnxt_dmx_channel_open(dmx->device, &dmx->channel, &chanarg, dmx_callback, dmx); 475 result = cnxt_dmx_channel_open(dmx_handles[COOLDEMUX_DMX_DEV(fd)].handle, &handle_item->channel, &chanarg, dmx_callback, dmx); 293 476 coolapi_check_error("cnxt_dmx_channel_open", result); 294 477 295 result = cnxt_dmx_set_channel_buffer( dmx->channel, 0, dmx->buffer1);478 result = cnxt_dmx_set_channel_buffer(handle_item->channel, 0, handle_item->buffer1); 296 479 coolapi_check_error("cnxt_dmx_set_channel_buffer", result); 297 480 298 result = cnxt_dmx_channel_attach( dmx->channel, 0xB, 0, dmx->buffer2);481 result = cnxt_dmx_channel_attach(handle_item->channel, 0xB, 0, handle_item->buffer2); 299 482 coolapi_check_error("cnxt_dmx_channel_attach", result); 300 483 301 result = cnxt_cbuf_attach( dmx->buffer2, 2, dmx->channel);484 result = cnxt_cbuf_attach(handle_item->buffer2, 2, handle_item->channel); 302 485 coolapi_check_error("cnxt_cbuf_attach", result); 303 486 304 result = cnxt_dmx_set_channel_pid( dmx->channel, pid);487 result = cnxt_dmx_set_channel_pid(handle_item->channel, pid); 305 488 coolapi_check_error("cnxt_dmx_set_channel_pid", result); 306 489 307 result = cnxt_cbuf_flush( dmx->buffer1, 0);490 result = cnxt_cbuf_flush(handle_item->buffer1, 0); 308 491 coolapi_check_error("cnxt_cbuf_flush", result); 309 result = cnxt_cbuf_flush( dmx->buffer2, 0);492 result = cnxt_cbuf_flush(handle_item->buffer2, 0); 310 493 coolapi_check_error("cnxt_cbuf_flush", result); 311 494 312 S_COOL_CHANHANDLE *handle_item; 313 if(cs_malloc(&handle_item, sizeof(S_COOL_CHANHANDLE))) 314 { 315 handle_item->pid = pid; 316 handle_item->channel = dmx->channel; 317 handle_item->buffer1 = dmx->buffer1; 318 handle_item->buffer2 = dmx->buffer2; 319 handle_item->demux_index = dmx->demux_index; 320 ll_append(ll_cool_chanhandle, handle_item); 321 } 322 cs_log_dbg(D_DVBAPI, "opened new channel %x", (int32_t) dmx->channel); 495 handle_item->pid = pid; 496 handle_item->dmx_handle = &dmx_handles[COOLDEMUX_DMX_DEV(fd)]; 497 dmx_handles[COOLDEMUX_DMX_DEV(fd)].allocated_channels++; 498 ll_append(ll_cool_chanhandle, handle_item); 499 500 cs_log_dbg(D_DVBAPI, "opened new channel %x", (int32_t) handle_item->channel);; 323 501 } 324 502 else 325 503 { 326 504 channel_found = 1; 327 dmx->channel = channel; 328 dmx->buffer1 = NULL; 329 dmx->buffer2 = NULL; 330 } 331 332 cs_log_dbg(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]); 333 334 SAFE_MUTEX_LOCK(&dmx->mutex); 335 336 filter_set_t filter; 337 dmx->filter_num = num; 338 dmx->pid = pid; 339 dmx->type = type; 340 341 memset(&filter, 0, sizeof(filter)); 342 filter.length = 12; 343 memcpy(filter.filter, flt, 16); 344 memcpy(filter.mask, mask, 16); 345 346 result = cnxt_dmx_open_filter(dmx->device, &dmx->filter); 347 coolapi_check_error("cnxt_dmx_open_filter", result); 348 349 result = cnxt_dmx_set_filter(dmx->filter, &filter, NULL); 350 coolapi_check_error("cnxt_dmx_set_filter", result); 351 352 result = cnxt_dmx_channel_suspend(dmx->channel, 1); 353 coolapi_check_error("cnxt_dmx_channel_suspend", result); 354 result = cnxt_dmx_channel_attach_filter(dmx->channel, dmx->filter); 355 coolapi_check_error("cnxt_dmx_channel_attach_filter", result); 356 result = cnxt_dmx_channel_suspend(dmx->channel, 0); 357 coolapi_check_error("cnxt_dmx_channel_suspend", result); 358 359 if(channel_found) 360 { 361 result = cnxt_dmx_channel_ctrl(dmx->channel, 0, 0); 362 coolapi_check_error("cnxt_dmx_channel_ctrl", result); 363 } 364 365 result = cnxt_dmx_channel_ctrl(dmx->channel, 2, 0); 366 coolapi_check_error("cnxt_dmx_channel_ctrl", result); 367 368 SAFE_MUTEX_UNLOCK(&dmx->mutex); 369 370 S_COOL_FILTER *filter_item; 371 if(cs_malloc(&filter_item, sizeof(S_COOL_FILTER))) 372 { 505 } 506 507 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]); 508 void *filter_handle = NULL; 509 filter_set_t filterset; 510 int32_t has_filter = 0; 511 512 S_COOL_FILTER *filter_item = find_filter_by_chanhandle(handle_item, num); 513 if (filter_item && type == dmx->type && pid == dmx->pid && 514 (memcmp(flt, filter_item->filter16, 16) || memcmp(mask, filter_item->mask16, 16))) 515 { 516 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]); 517 filter_handle = filter_item->filter; 518 519 has_filter = 1; 520 521 memcpy(filter_item->filter16, flt, 16); 522 memcpy(filter_item->mask16, mask, 16); 523 } 524 else 525 { 526 dmx->pid = pid; 527 dmx->type = type; 528 dmx->filter_num = num; 529 result = cnxt_dmx_open_filter(dmx_handles[COOLDEMUX_DMX_DEV(fd)].handle, &filter_handle); 530 coolapi_check_error("cnxt_dmx_open_filter", result); 531 532 if(!cs_malloc(&filter_item, sizeof(S_COOL_FILTER))) 533 { 534 SAFE_MUTEX_UNLOCK(&dmx->mutex); 535 return -1; 536 } 537 373 538 // fill filter item 374 539 filter_item->fd = fd; 375 filter_item->pid = pid; 376 filter_item->channel = (int32_t) dmx->channel; 540 filter_item->filter = filter_handle; 541 filter_item->filter_num = num; 542 filter_item->chanhandle = handle_item; 377 543 memcpy(filter_item->filter16, flt, 16); 378 544 memcpy(filter_item->mask16, mask, 16); … … 380 546 //add filter item 381 547 ll_append(ll_cool_filter, filter_item); 382 } 548 // increase allocated filters 549 handle_item->allocated_filters++; 550 } 551 552 if (has_filter) 553 { 554 result = cnxt_dmx_channel_suspend(handle_item->channel, 1); 555 coolapi_check_error("cnxt_dmx_channel_suspend", result); 556 result = cnxt_dmx_channel_detach_filter(handle_item->channel, filter_handle); 557 coolapi_check_error("cnxt_dmx_channel_detach_filter", result); 558 } 559 560 memset(&filterset, 0, sizeof(filterset)); 561 filterset.length = 12; 562 memcpy(filterset.filter, flt, 16); 563 memcpy(filterset.mask, mask, 16); 564 565 result = cnxt_dmx_set_filter(filter_handle, &filterset, (void *)num); 566 coolapi_check_error("cnxt_dmx_set_filter", result); 567 568 result = cnxt_dmx_channel_attach_filter(handle_item->channel, filter_handle); 569 coolapi_check_error("cnxt_dmx_channel_attach_filter", result); 570 571 if (has_filter) 572 { 573 result = cnxt_dmx_channel_suspend(handle_item->channel, 0); 574 coolapi_check_error("cnxt_dmx_channel_suspend", result); 575 } 576 577 if(!channel_found) 578 { 579 // Start channel 580 result = cnxt_dmx_channel_ctrl(handle_item->channel, 2, 0); 581 coolapi_check_error("cnxt_dmx_channel_ctrl", result); 582 } 583 584 SAFE_MUTEX_UNLOCK(&dmx->mutex); 585 383 586 return 0; 384 587 } … … 386 589 int32_t coolapi_remove_filter(int32_t fd, int32_t num) 387 590 { 591 void * channel = NULL; 592 void * filter = NULL; 593 388 594 dmx_t *dmx = find_demux(fd, 0); 389 595 if(!dmx) … … 396 602 { return -1; } 397 603 398 int32_t result, filter_on_channel = 0; 399 400 cs_log_dbg(D_DVBAPI, "removing filter fd=%08x num=%d pid=%04x on channel=%x", fd, num, dmx->pid, (int32_t) dmx->channel); 604 int32_t result; 401 605 402 606 SAFE_MUTEX_LOCK(&dmx->mutex); 403 607 404 if(dmx->filter) 405 { 406 result = cnxt_dmx_channel_suspend(dmx->channel, 1); 608 // Find matching channel, if it exists. 609 S_COOL_CHANHANDLE *handle_item = find_chanhandle(COOLDEMUX_DMX_DEV(fd), dmx->pid); 610 if (!handle_item) 611 { 612 SAFE_MUTEX_UNLOCK(&dmx->mutex); 613 cs_log_dbg(D_DVBAPI, "removing filter fd=%08x num=%d pid=%04xcfailed, channel does not exist.", fd, num, dmx->pid); 614 return -1; 615 } 616 617 channel = handle_item->channel; 618 cs_log_dbg(D_DVBAPI, "removing filter fd=%08x num=%d pid=%04x on channel=%p", fd, num, dmx->pid, channel); 619 620 621 S_COOL_FILTER *filter_item = find_filter_by_chanhandle(handle_item, num); 622 if(filter_item) 623 { 624 result = cnxt_dmx_channel_suspend(channel, 1); 407 625 coolapi_check_error("cnxt_dmx_channel_suspend", result); 408 result = cnxt_dmx_channel_detach_filter( dmx->channel, dmx->filter);626 result = cnxt_dmx_channel_detach_filter(channel, filter_item->filter); 409 627 coolapi_check_error("cnxt_dmx_channel_detach_filter", result); 410 result = cnxt_dmx_channel_suspend(dmx->channel, 0); 628 #if 0 629 result = cnxt_dmx_close_filter(filter_item->filter); 630 coolapi_check_error("cnxt_dmx_close_filter", result); 631 #endif 632 filter = filter_item->filter; 633 remove_filter(filter_item); 634 handle_item->allocated_filters--; 635 } 636 else 637 { 638 SAFE_MUTEX_UNLOCK(&dmx->mutex); 639 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); 640 return -1; 641 } 642 643 if (!handle_item->allocated_filters) 644 { 645 result = cnxt_dmx_channel_ctrl(channel, 0, 0); 646 coolapi_check_error("cnxt_dmx_channel_ctrl", result); 647 cs_log_dbg(D_DVBAPI, "closing channel %x", (int32_t) channel); 648 649 result = cnxt_dmx_set_channel_pid(channel, 0x1FFF); 650 coolapi_check_error("cnxt_dmx_set_channel_pid", result); 651 652 result = cnxt_cbuf_flush(handle_item->buffer1, 0); 653 coolapi_check_error("cnxt_cbuf_flush", result); 654 655 result = cnxt_cbuf_flush(handle_item->buffer2, 0); 656 coolapi_check_error("cnxt_cbuf_flush", result); 657 658 result = cnxt_cbuf_detach(handle_item->buffer2, 2, channel); 659 coolapi_check_error("cnxt_cbuf_detach", result); 660 661 result = cnxt_dmx_channel_detach(channel, 0xB, 0, handle_item->buffer1); 662 coolapi_check_error("cnxt_dmx_channel_detach", result); 663 664 #if 0 665 result = cnxt_dmx_channel_close(channel); 666 coolapi_check_error("cnxt_dmx_channel_close", result); 667 #endif 668 669 result = cnxt_cbuf_close(handle_item->buffer2); 670 coolapi_check_error("cnxt_cbuf_close", result); 671 672 result = cnxt_cbuf_close(handle_item->buffer1); 673 coolapi_check_error("cnxt_cbuf_close", result); 674 handle_item->channel = NULL; 675 handle_item->buffer1 = NULL; 676 handle_item->buffer2 = NULL; 677 remove_chanhandle(handle_item); 678 dmx_handles[COOLDEMUX_DMX_DEV(fd)].allocated_channels--; 679 dmx->pid = -1; 680 } else { 681 result = cnxt_dmx_channel_suspend(channel, 0); 411 682 coolapi_check_error("cnxt_dmx_channel_suspend", result); 412 result = cnxt_dmx_close_filter(dmx->filter); 683 channel = NULL; 684 } 685 686 SAFE_MUTEX_UNLOCK(&dmx->mutex); 687 if (filter) { 688 result = cnxt_dmx_close_filter(filter); 413 689 coolapi_check_error("cnxt_dmx_close_filter", result); 414 dmx->filter = NULL; 415 result = cnxt_dmx_channel_ctrl(dmx->channel, 0, 0); 416 coolapi_check_error("cnxt_dmx_channel_ctrl", result); 417 } 418 419 LL_ITER itr = ll_iter_create(ll_cool_filter); 420 S_COOL_FILTER *filter_item; 421 while((filter_item = ll_iter_next(&itr))) 422 { 423 if(filter_item->channel == (int32_t) dmx->channel) 424 { filter_on_channel++; } 425 if(filter_item->fd == fd) 426 { 427 ll_iter_remove_data(&itr); 428 filter_on_channel--; 429 } 430 } 431 432 if(!filter_on_channel) 433 { 434 cs_log_dbg(D_DVBAPI, "closing channel %x", (int32_t) dmx->channel); 435 436 itr = ll_iter_create(ll_cool_chanhandle); 437 S_COOL_CHANHANDLE *handle_item; 438 while((handle_item = ll_iter_next(&itr))) 439 { 440 if(handle_item->demux_index == dmx->demux_index && handle_item->pid == dmx->pid) 441 { 442 dmx->buffer1 = handle_item->buffer1; 443 dmx->buffer2 = handle_item->buffer2; 444 ll_iter_remove_data(&itr); 445 break; 446 } 447 } 448 449 if(!dmx->buffer1 || !dmx->buffer2) 450 { cs_log_dbg(D_DVBAPI, "WARNING: buffer handle not found!"); } 451 452 result = cnxt_dmx_channel_ctrl(dmx->channel, 0, 0); 453 coolapi_check_error("cnxt_dmx_channel_ctrl", result); 454 455 result = cnxt_dmx_set_channel_pid(dmx->channel, 0x1FFF); 456 coolapi_check_error("cnxt_dmx_set_channel_pid", result); 457 458 result = cnxt_cbuf_flush(dmx->buffer1, 0); 459 coolapi_check_error("cnxt_cbuf_flush", result); 460 461 result = cnxt_cbuf_flush(dmx->buffer2, 0); 462 coolapi_check_error("cnxt_cbuf_flush", result); 463 464 result = cnxt_cbuf_detach(dmx->buffer2, 2, dmx->channel); 465 coolapi_check_error("cnxt_cbuf_detach", result); 466 result = cnxt_dmx_channel_detach(dmx->channel, 0xB, 0, dmx->buffer1); 467 coolapi_check_error("cnxt_dmx_channel_detach", result); 468 469 result = cnxt_dmx_channel_close(dmx->channel); 690 } 691 if (channel) { 692 result = cnxt_dmx_channel_close(channel); 470 693 coolapi_check_error("cnxt_dmx_channel_close", result); 471 472 result = cnxt_cbuf_close(dmx->buffer2); 473 coolapi_check_error("cnxt_cbuf_close", result); 474 475 result = cnxt_cbuf_close(dmx->buffer1); 476 coolapi_check_error("cnxt_cbuf_close", result); 477 } 478 479 if(filter_on_channel) 480 { 481 result = cnxt_dmx_channel_ctrl(dmx->channel, 2, 0); 482 coolapi_check_error("cnxt_dmx_channel_ctrl", result); 483 } 484 485 SAFE_MUTEX_UNLOCK(&dmx->mutex); 486 487 dmx->pid = -1; 694 } 695 488 696 return 0; 489 697 } … … 493 701 dmx_t *dmx; 494 702 495 coolapi_open();703 SAFE_MUTEX_LOCK(&demux_lock); 496 704 497 705 dmx = find_demux(0, demux_index); 498 706 if(!dmx) 499 707 { 708 SAFE_MUTEX_UNLOCK(&demux_lock); 500 709 cs_log("no free demux found"); 501 710 return 0; … … 508 717 { ll_cool_chanhandle = ll_create("ll_cool_chanhandle"); } 509 718 510 dmx->demux_index = demux_index;511 719 dmx->demux_id = demux_id; 512 720 dmx->pid = -1; 513 721 514 dmx->device = dmx_device[demux_index];722 //dmx->device = dmx_handles[demux_index].handle; 515 723 dmx->opened = 1; 516 724 … … 520 728 SAFE_MUTEX_INIT(&dmx->mutex, &attr); 521 729 730 SAFE_MUTEX_UNLOCK(&demux_lock); 731 522 732 return dmx->fd; 523 733 } … … 529 739 { 530 740 cs_log_dbg(D_DVBAPI, "dmx is NULL!"); 741 SAFE_MUTEX_UNLOCK(&demux_lock); 531 742 return -1; 532 743 } … … 556 767 if(mask & (1 << j)) 557 768 { 558 result = cnxt_dmx_get_channel_from_pid(dmx_ device[j], pid, &channel);769 result = cnxt_dmx_get_channel_from_pid(dmx_handles[j].handle, pid, &channel); 559 770 if(result == 0) 560 771 { … … 573 784 } 574 785 575 static int32_t coolapi_read(dmx_t *dmx, dmx_callback_data_t *data )786 static int32_t coolapi_read(dmx_t *dmx, dmx_callback_data_t *data, uchar *buffer) 576 787 { 577 788 if(!dmx) … … 583 794 int32_t result; 584 795 uint32_t done = 0, toread, len = data->len; 585 uchar *buff = &dmx->buffer[0];586 796 uint32_t bytes_used = 0; 587 797 … … 593 803 { return -1; } 594 804 595 result = cnxt_cbuf_read_data(data->buf, buff , 3, &done);805 result = cnxt_cbuf_read_data(data->buf, buffer, 3, &done); 596 806 coolapi_check_error("cnxt_cbuf_read_data", result); 597 807 … … 599 809 { return -1; } 600 810 601 toread = ((buff [1] << 8) | buff[2]) & 0xFFF;811 toread = ((buffer[1] << 8) | buffer[2]) & 0xFFF; 602 812 if((toread + 3) > len) 603 813 { return -1; } 604 result = cnxt_cbuf_read_data(data->buf, buff + 3, toread, &done);814 result = cnxt_cbuf_read_data(data->buf, buffer + 3, toread, &done); 605 815 coolapi_check_error("cnxt_cbuf_read_data", result); 606 816 if(done != toread) … … 613 823 } 614 824 615 void coolapi_open_all(void) 616 { 617 cnxt_kal_initialize(); 618 cnxt_drv_init(); 619 cnxt_smc_init(NULL); 620 cool_kal_opened = 1; 621 } 622 623 static void coolapi_open(void) 825 static void coolapi_dmx_open(void) 624 826 { 625 827 int32_t result = 0; … … 631 833 632 834 cs_log_dbg(D_DVBAPI, "Open Coolstream DMX API"); 633 cnxt_cbuf_init(NULL);634 cnxt_dmx_init(NULL);635 835 636 836 memset(&devarg, 0, sizeof(device_open_arg_t)); … … 642 842 { 643 843 devarg.number = i; 644 result = cnxt_dmx_open(&dmx_ device[i], &devarg, NULL, NULL);844 result = cnxt_dmx_open(&dmx_handles[i].handle, &devarg, NULL, NULL); 645 845 coolapi_check_error("cnxt_dmx_open", result); 646 846 } … … 649 849 } 650 850 851 static void coolapi_dmx_close(void) 852 { 853 if(dmx_opened) 854 { 855 int32_t result; 856 int32_t i; 857 858 for(i = 0; i < MAX_COOL_DMX; i++) 859 { 860 result = cnxt_dmx_close(dmx_handles[i].handle); 861 coolapi_check_error("cnxt_dmx_close", result); 862 dmx_handles[i].handle = NULL; 863 } 864 dmx_opened = 0; 865 } 866 } 867 868 static void coolapi_start_api(void); 869 static void coolapi_stop_api(void); 870 871 void coolapi_open_all(void) 872 { 873 SAFE_MUTEX_LOCK(&demux_lock); 874 875 coolapi_start_api(); 876 cool_kal_opened = 1; 877 coolapi_dmx_open(); 878 879 SAFE_MUTEX_UNLOCK(&demux_lock); 880 } 881 651 882 void coolapi_close_all(void) 652 883 { 653 if(dmx_opened) 654 { 655 int32_t result; 656 int32_t i, j; 657 658 for(i = 0; i < MAX_COOL_DMX; i++) 659 { 660 for(j = 0; j < MAX_FILTER; j++) 884 SAFE_MUTEX_LOCK(&demux_lock); 885 886 if(!dmx_opened) { 887 SAFE_MUTEX_UNLOCK(&demux_lock); 888 return; 889 } 890 891 int32_t i, j; 892 893 for(i = 0; i < MAX_COOL_DMX; i++) 894 { 895 for(j = 0; j < MAX_FILTER; j++) 896 { 897 if(cdemuxes[i][j].fd > 0) 661 898 { 662 if(cdemuxes[i][j].fd > 0) 663 { 664 coolapi_remove_filter(cdemuxes[i][j].fd, cdemuxes[i][j].filter_num); 665 coolapi_close_device(cdemuxes[i][j].fd); 666 } 899 coolapi_remove_filter(cdemuxes[i][j].fd, cdemuxes[i][j].filter_num); 900 coolapi_close_device(cdemuxes[i][j].fd); 667 901 } 668 902 } 669 for(i = 0; i < MAX_COOL_DMX; i++) 670 { 671 result = cnxt_dmx_close(dmx_device[i]); 672 coolapi_check_error("cnxt_dmx_close", result); 673 dmx_device[i] = NULL; 674 } 675 } 903 } 904 905 coolapi_dmx_close(); 906 coolapi_stop_api(); 676 907 cool_kal_opened = 0; 908 909 SAFE_MUTEX_UNLOCK(&demux_lock); 910 } 911 #endif 912 913 #if defined(HAVE_DVBAPI) && (defined(WITH_SU980) || defined(WITH_COOLAPI2)) 914 #include "extapi/coolapi.h" 915 extern void cnxt_css_drv_init(void); 916 extern void cnxt_css_drv_term(void); 917 extern void cnxt_smc_term(void); 918 919 static void coolapi_start_api(void) 920 { 921 cnxt_kal_initialize(); 922 cnxt_css_drv_init(); 923 cnxt_cbuf_init(NULL); 924 cnxt_dmx_init(NULL); 925 cnxt_smc_init(NULL); 926 } 927 928 static void coolapi_stop_api(void) 929 { 930 cnxt_css_drv_term(); 931 cnxt_kal_terminate(); 932 } 933 #else 934 static void coolapi_start_api(void) 935 { 936 cnxt_kal_initialize(); 937 cnxt_drv_init(); 938 cnxt_smc_init(NULL); 939 } 940 941 static void coolapi_stop_api(void) 942 { 677 943 cnxt_kal_terminate(); 678 944 cnxt_drv_term(); 679 945 } 680 #elif defined(HAVE_DVBAPI) && defined(WITH_SU980)681 #include "extapi/coolapi.h"682 void cnxt_css_drv_init(void);683 void cnxt_css_drv_term(void);684 void cnxt_smc_term(void);685 686 int32_t cool_kal_opened = 0;687 void coolapi_open_all(void)688 {689 cnxt_kal_initialize();690 cnxt_css_drv_init();691 cnxt_smc_init(0);692 cool_kal_opened = 1;693 }694 695 void coolapi_close_all(void)696 {697 cnxt_kal_terminate();698 cool_kal_opened = 0;699 }700 946 #endif -
trunk/module-dvbapi-coolapi.h
r10194 r11023 7 7 int32_t coolapi_close_device(int32_t fd); 8 8 int32_t coolapi_write_cw(int32_t mask, uint16_t *STREAMpids, int32_t count, ca_descr_t *ca_descr); 9 int32_t coolapi_get_filter_num(int32_t fd); 9 10 10 11 #endif -
trunk/module-dvbapi.c
r11014 r11023 724 724 break; 725 725 #endif 726 #if def WITH_COOLAPI726 #if defined WITH_COOLAPI || defined WITH_COOLAPI2 727 727 case COOLAPI: 728 728 ret = filterfd = coolapi_open_device(demux[demux_id].demux_index, demux_id); … … 766 766 static int32_t dvbapi_detect_api(void) 767 767 { 768 #if def WITH_COOLAPI768 #if defined WITH_COOLAPI || defined WITH_COOLAPI2 769 769 selected_api = COOLAPI; 770 770 selected_box = BOX_INDEX_COOLSTREAM; … … 1042 1042 break; 1043 1043 #endif 1044 #if def WITH_COOLAPI1044 #if defined WITH_COOLAPI || defined WITH_COOLAPI2 1045 1045 case COOLAPI: 1046 1046 retfilter = coolapi_remove_filter(fd, num); … … 1052 1052 } 1053 1053 1054 #if ndef WITH_COOLAPI// no fd close for coolapi and stapi, all others do close fd!1054 #if !defined WITH_COOLAPI && !defined WITH_COOLAPI2 // no fd close for coolapi and stapi, all others do close fd! 1055 1055 if (!cfg.dvbapi_listenport && cfg.dvbapi_boxtype != BOXTYPE_PC_NODMX) 1056 1056 { … … 1415 1415 void dvbapi_parse_cat(int32_t demux_id, uchar *buf, int32_t len) 1416 1416 { 1417 #if def WITH_COOLAPI1417 #if defined WITH_COOLAPI || defined WITH_COOLAPI2 1418 1418 // driver sometimes reports error if too many emm filter 1419 1419 // but adding more ecm filter is no problem … … 1557 1557 break; 1558 1558 #endif 1559 #if def WITH_COOLAPI1559 #if defined WITH_COOLAPI || defined WITH_COOLAPI2 1560 1560 case COOLAPI: 1561 1561 break; … … 2832 2832 #define LIST_UPDATE 0x05 //*CA application should replace an entry in the list with an 'UPDATE' CAPMT object, and start working with the updated list 2833 2833 2834 #if def WITH_COOLAPI2834 #if defined WITH_COOLAPI || defined WITH_COOLAPI2 2835 2835 int32_t ca_pmt_list_management = LIST_ONLY; 2836 2836 #else … … 2866 2866 2867 2867 bool full_check = 1, matched = 0; 2868 if (config_enabled(WITH_COOLAPI) || c fg.dvbapi_boxtype == BOXTYPE_SAMYGO)2868 if (config_enabled(WITH_COOLAPI) || config_enabled(WITH_COOLAPI2) || cfg.dvbapi_boxtype == BOXTYPE_SAMYGO) 2869 2869 full_check = 0; 2870 2870 … … 4404 4404 } 4405 4405 4406 #if def WITH_COOLAPI4406 #if defined WITH_COOLAPI || defined WITH_COOLAPI2 4407 4407 system("pzapit -rz"); 4408 4408 #endif … … 5018 5018 if (idx == -1) return; // return on no index! 5019 5019 5020 #if def WITH_COOLAPI5020 #if defined WITH_COOLAPI || defined WITH_COOLAPI2 5021 5021 ca_descr.index = idx; 5022 5022 ca_descr.parity = n; … … 5823 5823 } 5824 5824 #endif 5825 /*#ifdef WITH_COOLAPI ******* NOT IMPLEMENTED YET ******** 5826 case COOLAPI: { 5827 coolapi_set_filter(demux[demux_id].demux_fd[n].fd, n, pid, filter, mask, TYPE_ECM); 5828 break; 5829 } 5825 #if defined WITH_COOLAPI || defined WITH_COOLAPI2 5826 case COOLAPI: 5827 { 5828 int32_t n = coolapi_get_filter_num(fd); 5829 if (n < 0) 5830 return n; 5831 coolapi_set_filter(fd, n, pid, filter, mask, TYPE_ECM); 5832 break; 5833 } 5830 5834 #endif 5831 */5835 5832 5836 default: 5833 5837 break; -
trunk/oscam.c
r11020 r11023 395 395 write_conf(WITH_MCA, "DVB API with MCA support"); 396 396 write_conf(WITH_COOLAPI, "DVB API with COOLAPI support"); 397 write_conf(WITH_COOLAPI2, "DVB API with COOLAPI2 support"); 397 398 write_conf(WITH_STAPI, "DVB API with STAPI support"); 398 399 write_conf(WITH_STAPI5, "DVB API with STAPI5 support"); … … 451 452 write_cardreaderconf(CARDREADER_INTERNAL_AZBOX, "internal_azbox"); 452 453 write_cardreaderconf(CARDREADER_INTERNAL_COOLAPI, "internal_coolapi"); 454 write_cardreaderconf(CARDREADER_INTERNAL_COOLAPI2, "internal_coolapi"); 453 455 write_cardreaderconf(CARDREADER_INTERNAL_SCI, "internal_sci"); 454 456 write_cardreaderconf(CARDREADER_SC8IN1, "sc8in1"); … … 1553 1555 &cardreader_internal_azbox, 1554 1556 #elif defined(CARDREADER_INTERNAL_COOLAPI) 1557 &cardreader_internal_cool, 1558 #elif defined(CARDREADER_INTERNAL_COOLAPI2) 1555 1559 &cardreader_internal_cool, 1556 1560 #elif defined(CARDREADER_INTERNAL_SCI) -
trunk/reader-videoguard2.c
r11017 r11023 853 853 rdr_log(reader, "classD0 ins7E11: Scheduling card reset for TA1 change from %02X to %02X", TA1, reader->ins7E11[0x00]); 854 854 reader->ins7e11_fast_reset = 1; 855 #if def WITH_COOLAPI855 #if defined(WITH_COOLAPI) || defined(WITH_COOLAPI2) 856 856 if(reader->typ == R_MOUSE || reader->typ == R_SC8in1 || reader->typ == R_SMART || reader->typ == R_INTERNAL) 857 857 {
Note:
See TracChangeset
for help on using the changeset viewer.