aboutsummaryrefslogtreecommitdiffstats
path: root/test/libdvben50221
diff options
context:
space:
mode:
Diffstat (limited to 'test/libdvben50221')
-rw-r--r--test/libdvben50221/Makefile14
-rw-r--r--test/libdvben50221/test-app.c854
-rw-r--r--test/libdvben50221/test-session.c171
-rw-r--r--test/libdvben50221/test-transport.c144
4 files changed, 1183 insertions, 0 deletions
diff --git a/test/libdvben50221/Makefile b/test/libdvben50221/Makefile
new file mode 100644
index 0000000..cd29679
--- /dev/null
+++ b/test/libdvben50221/Makefile
@@ -0,0 +1,14 @@
+# Makefile for linuxtv.org dvb-apps/test/libdvben50221
+
+binaries = test-app \
+ test-session \
+ test-transport
+
+CPPFLAGS += -I../../lib
+LDLIBS += ../../lib/libdvbapi/libdvbapi.a ../../lib/libdvben50221/libdvben50221.a ../../lib/libucsi/libucsi.a -lpthread
+
+.PHONY: all
+
+all: $(binaries)
+
+include ../../Make.rules
diff --git a/test/libdvben50221/test-app.c b/test/libdvben50221/test-app.c
new file mode 100644
index 0000000..d99ec01
--- /dev/null
+++ b/test/libdvben50221/test-app.c
@@ -0,0 +1,854 @@
+/*
+ en50221 encoder An implementation for libdvb
+ an implementation for the en50221 transport layer
+
+ Copyright (C) 2004, 2005 Manu Abraham (manu@kromtek.com)
+ Copyright (C) 2005 Julian Scheel (julian at jusst dot de)
+ Copyright (C) 2006 Andrew de Quincey (adq_dvb@lidskialf.net)
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as
+ published by the Free Software Foundation; either version 2.1 of
+ the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include <stdio.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <libdvben50221/en50221_session.h>
+#include <libdvben50221/en50221_app_utils.h>
+#include <libdvben50221/en50221_app_ai.h>
+#include <libdvben50221/en50221_app_auth.h>
+#include <libdvben50221/en50221_app_ca.h>
+#include <libdvben50221/en50221_app_datetime.h>
+#include <libdvben50221/en50221_app_dvb.h>
+#include <libdvben50221/en50221_app_epg.h>
+#include <libdvben50221/en50221_app_lowspeed.h>
+#include <libdvben50221/en50221_app_mmi.h>
+#include <libdvben50221/en50221_app_rm.h>
+#include <libdvben50221/en50221_app_smartcard.h>
+#include <libdvben50221/en50221_app_teletext.h>
+#include <libdvbapi/dvbca.h>
+#include <pthread.h>
+#include <libdvbcfg/dvbcfg_zapchannel.h>
+#include <libdvbapi/dvbdemux.h>
+#include <libucsi/section.h>
+#include <libucsi/mpeg/section.h>
+
+#define DEFAULT_SLOT 0
+
+#define MAX_SESSIONS 256
+#define MAX_TC 32
+
+void *stackthread_func(void* arg);
+void *pmtthread_func(void* arg);
+int test_lookup_callback(void *arg, uint8_t slot_id, uint32_t requested_resource_id,
+ en50221_sl_resource_callback *callback_out, void **arg_out, uint32_t *connected_resource_id);
+int test_session_callback(void *arg, int reason, uint8_t slot_id, uint16_t session_number, uint32_t resource_id);
+
+int test_datetime_enquiry_callback(void *arg, uint8_t slot_id, uint16_t session_number, uint8_t response_interval);
+
+int test_rm_enq_callback(void *arg, uint8_t slot_id, uint16_t session_number);
+int test_rm_reply_callback(void *arg, uint8_t slot_id, uint16_t session_number, uint32_t resource_id_count, uint32_t *resource_ids);
+int test_rm_changed_callback(void *arg, uint8_t slot_id, uint16_t session_number);
+
+int test_ai_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ uint8_t application_type, uint16_t application_manufacturer,
+ uint16_t manufacturer_code, uint8_t menu_string_length,
+ uint8_t *menu_string);
+
+int test_ca_info_callback(void *arg, uint8_t slot_id, uint16_t session_number, uint32_t ca_id_count, uint16_t *ca_ids);
+int test_ca_pmt_reply_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ struct en50221_app_pmt_reply *reply, uint32_t reply_size);
+
+int test_mmi_close_callback(void *arg, uint8_t slot_id, uint16_t session_number, uint8_t cmd_id, uint8_t delay);
+
+int test_mmi_display_control_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ uint8_t cmd_id, uint8_t mmi_mode);
+
+int test_mmi_keypad_control_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ uint8_t cmd_id, uint8_t *key_codes, uint32_t key_codes_count);
+
+int test_mmi_subtitle_segment_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ uint8_t *segment, uint32_t segment_size);
+
+int test_mmi_scene_end_mark_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ uint8_t decoder_continue_flag, uint8_t scene_reveal_flag,
+ uint8_t send_scene_done, uint8_t scene_tag);
+
+int test_mmi_scene_control_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ uint8_t decoder_continue_flag, uint8_t scene_reveal_flag,
+ uint8_t scene_tag);
+
+int test_mmi_subtitle_download_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ uint8_t *segment, uint32_t segment_size);
+
+int test_mmi_flush_download_callback(void *arg, uint8_t slot_id, uint16_t session_number);
+
+int test_mmi_enq_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ uint8_t blind_answer, uint8_t expected_answer_length,
+ uint8_t *text, uint32_t text_size);
+
+int test_mmi_menu_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ struct en50221_app_mmi_text *title,
+ struct en50221_app_mmi_text *sub_title,
+ struct en50221_app_mmi_text *bottom,
+ uint32_t item_count, struct en50221_app_mmi_text *items,
+ uint32_t item_raw_length, uint8_t *items_raw);
+
+int test_app_mmi_list_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ struct en50221_app_mmi_text *title,
+ struct en50221_app_mmi_text *sub_title,
+ struct en50221_app_mmi_text *bottom,
+ uint32_t item_count, struct en50221_app_mmi_text *items,
+ uint32_t item_raw_length, uint8_t *items_raw);
+
+struct section_ext *read_section_ext(char *buf, int buflen, int adapter, int demux, int pid, int table_id);
+
+
+
+
+
+
+
+int adapterid;
+
+int shutdown_stackthread = 0;
+int shutdown_pmtthread = 0;
+int in_menu = 0;
+int in_enq = 0;
+int ca_connected = 0;
+int pmt_pid = -1;
+int ca_session_number = 0;
+
+
+// instances of resources we actually implement here
+struct en50221_app_rm *rm_resource;
+struct en50221_app_datetime *datetime_resource;
+struct en50221_app_ai *ai_resource;
+struct en50221_app_ca *ca_resource;
+struct en50221_app_mmi *mmi_resource;
+
+// lookup table used in resource manager implementation
+struct resource {
+ struct en50221_app_public_resource_id resid;
+ uint32_t binary_resource_id;
+ en50221_sl_resource_callback callback;
+ void *arg;
+};
+struct resource resources[20];
+int resources_count = 0;
+
+// this contains all known resource ids so we can see if the cam asks for something exotic
+uint32_t resource_ids[] = { EN50221_APP_TELETEXT_RESOURCEID,
+ EN50221_APP_SMARTCARD_RESOURCEID(1),
+ EN50221_APP_RM_RESOURCEID,
+ EN50221_APP_MMI_RESOURCEID,
+ EN50221_APP_LOWSPEED_RESOURCEID(1,1),
+ EN50221_APP_EPG_RESOURCEID(1),
+ EN50221_APP_DVB_RESOURCEID,
+ EN50221_APP_CA_RESOURCEID,
+ EN50221_APP_DATETIME_RESOURCEID,
+ EN50221_APP_AUTH_RESOURCEID,
+ EN50221_APP_AI_RESOURCEID, };
+int resource_ids_count = sizeof(resource_ids)/4;
+
+
+uint16_t ai_session_numbers[5];
+
+uint16_t mmi_session_number;
+
+int main(int argc, char * argv[])
+{
+ pthread_t stackthread;
+ pthread_t pmtthread;
+ struct en50221_app_send_functions sendfuncs;
+
+ if ((argc < 2) || (argc > 3)) {
+ fprintf(stderr, "Syntax: test-app <adapterid> [<pmtpid>]\n");
+ exit(1);
+ }
+ adapterid = atoi(argv[1]);
+ if (argc == 3) {
+ if (sscanf(argv[2], "%i", &pmt_pid) != 1) {
+ fprintf(stderr, "Unable to parse PMT PID\n");
+ exit(1);
+ }
+ }
+
+ // create transport layer
+ struct en50221_transport_layer *tl = en50221_tl_create(5, 32);
+ if (tl == NULL) {
+ fprintf(stderr, "Failed to create transport layer\n");
+ exit(1);
+ }
+
+ // find CAMs
+ int cafd;
+ if (((cafd = dvbca_open(adapterid, 0)) < 0) || (dvbca_get_cam_state(cafd, DEFAULT_SLOT) == DVBCA_CAMSTATE_MISSING)) {
+ fprintf(stderr, "Unable to open CAM on adapter %i\n", adapterid);
+ exit(1);
+ }
+
+ // reset it and wait
+ dvbca_reset(cafd, DEFAULT_SLOT);
+ printf("Found a CAM on adapter%i... waiting...\n", adapterid);
+ while(dvbca_get_cam_state(cafd, DEFAULT_SLOT) != DVBCA_CAMSTATE_READY) {
+ usleep(1000);
+ }
+
+ // register it with the CA stack
+ int slot_id = 0;
+ if ((slot_id = en50221_tl_register_slot(tl, cafd, DEFAULT_SLOT, 1000, 100)) < 0) {
+ fprintf(stderr, "Slot registration failed\n");
+ exit(1);
+ }
+ printf("slotid: %i\n", slot_id);
+
+ // create session layer
+ struct en50221_session_layer *sl = en50221_sl_create(tl, 256);
+ if (sl == NULL) {
+ fprintf(stderr, "Failed to create session layer\n");
+ exit(1);
+ }
+
+ // create the sendfuncs
+ sendfuncs.arg = sl;
+ sendfuncs.send_data = (en50221_send_data) en50221_sl_send_data;
+ sendfuncs.send_datav = (en50221_send_datav) en50221_sl_send_datav;
+
+ // create the resource manager resource
+ rm_resource = en50221_app_rm_create(&sendfuncs);
+ en50221_app_decode_public_resource_id(&resources[resources_count].resid, EN50221_APP_RM_RESOURCEID);
+ resources[resources_count].binary_resource_id = EN50221_APP_RM_RESOURCEID;
+ resources[resources_count].callback = (en50221_sl_resource_callback) en50221_app_rm_message;
+ resources[resources_count].arg = rm_resource;
+ en50221_app_rm_register_enq_callback(rm_resource, test_rm_enq_callback, NULL);
+ en50221_app_rm_register_reply_callback(rm_resource, test_rm_reply_callback, NULL);
+ en50221_app_rm_register_changed_callback(rm_resource, test_rm_changed_callback, NULL);
+ resources_count++;
+
+ // create the datetime resource
+ datetime_resource = en50221_app_datetime_create(&sendfuncs);
+ en50221_app_decode_public_resource_id(&resources[resources_count].resid, EN50221_APP_DATETIME_RESOURCEID);
+ resources[resources_count].binary_resource_id = EN50221_APP_DATETIME_RESOURCEID;
+ resources[resources_count].callback = (en50221_sl_resource_callback) en50221_app_datetime_message;
+ resources[resources_count].arg = datetime_resource;
+ en50221_app_datetime_register_enquiry_callback(datetime_resource, test_datetime_enquiry_callback, NULL);
+ resources_count++;
+
+ // create the application information resource
+ ai_resource = en50221_app_ai_create(&sendfuncs);
+ en50221_app_decode_public_resource_id(&resources[resources_count].resid, EN50221_APP_AI_RESOURCEID);
+ resources[resources_count].binary_resource_id = EN50221_APP_AI_RESOURCEID;
+ resources[resources_count].callback = (en50221_sl_resource_callback) en50221_app_ai_message;
+ resources[resources_count].arg = ai_resource;
+ en50221_app_ai_register_callback(ai_resource, test_ai_callback, NULL);
+ resources_count++;
+
+ // create the CA resource
+ ca_resource = en50221_app_ca_create(&sendfuncs);
+ en50221_app_decode_public_resource_id(&resources[resources_count].resid, EN50221_APP_CA_RESOURCEID);
+ resources[resources_count].binary_resource_id = EN50221_APP_CA_RESOURCEID;
+ resources[resources_count].callback = (en50221_sl_resource_callback) en50221_app_ca_message;
+ resources[resources_count].arg = ca_resource;
+ en50221_app_ca_register_info_callback(ca_resource, test_ca_info_callback, NULL);
+ en50221_app_ca_register_pmt_reply_callback(ca_resource, test_ca_pmt_reply_callback, NULL);
+ resources_count++;
+
+ // create the MMI resource
+ mmi_resource = en50221_app_mmi_create(&sendfuncs);
+ en50221_app_decode_public_resource_id(&resources[resources_count].resid, EN50221_APP_MMI_RESOURCEID);
+ resources[resources_count].binary_resource_id = EN50221_APP_MMI_RESOURCEID;
+ resources[resources_count].callback = (en50221_sl_resource_callback) en50221_app_mmi_message;
+ resources[resources_count].arg = mmi_resource;
+ en50221_app_mmi_register_close_callback(mmi_resource, test_mmi_close_callback, NULL);
+ en50221_app_mmi_register_display_control_callback(mmi_resource, test_mmi_display_control_callback, NULL);
+ en50221_app_mmi_register_keypad_control_callback(mmi_resource, test_mmi_keypad_control_callback, NULL);
+ en50221_app_mmi_register_subtitle_segment_callback(mmi_resource, test_mmi_subtitle_segment_callback, NULL);
+ en50221_app_mmi_register_scene_end_mark_callback(mmi_resource, test_mmi_scene_end_mark_callback, NULL);
+ en50221_app_mmi_register_scene_control_callback(mmi_resource, test_mmi_scene_control_callback, NULL);
+ en50221_app_mmi_register_subtitle_download_callback(mmi_resource, test_mmi_subtitle_download_callback, NULL);
+ en50221_app_mmi_register_flush_download_callback(mmi_resource, test_mmi_flush_download_callback, NULL);
+ en50221_app_mmi_register_enq_callback(mmi_resource, test_mmi_enq_callback, NULL);
+ en50221_app_mmi_register_menu_callback(mmi_resource, test_mmi_menu_callback, NULL);
+ en50221_app_mmi_register_list_callback(mmi_resource, test_app_mmi_list_callback, NULL);
+ resources_count++;
+
+ // start another thread running the stack
+ pthread_create(&stackthread, NULL, stackthread_func, tl);
+
+ // start another thread parsing PMT
+ if (pmt_pid != -1) {
+ pthread_create(&pmtthread, NULL, pmtthread_func, tl);
+ }
+
+ // register callbacks
+ en50221_sl_register_lookup_callback(sl, test_lookup_callback, sl);
+ en50221_sl_register_session_callback(sl, test_session_callback, sl);
+
+ // create a new connection on each slot
+ int tc = en50221_tl_new_tc(tl, slot_id);
+ printf("tcid: %i\n", tc);
+
+ printf("Press a key to enter menu\n");
+ getchar();
+ en50221_app_ai_entermenu(ai_resource, ai_session_numbers[slot_id]);
+
+ // wait
+ char tmp[256];
+ while(1) {
+ fgets(tmp, sizeof(tmp), stdin);
+ int choice = atoi(tmp);
+
+ if (in_menu) {
+ en50221_app_mmi_menu_answ(mmi_resource, mmi_session_number, choice);
+ in_menu = 0;
+ }
+ if (in_enq) {
+ uint32_t i;
+ uint32_t len = strlen(tmp);
+ for(i=0; i< len; i++) {
+ if (!isdigit(tmp[i])) {
+ len = i;
+ break;
+ }
+ }
+ en50221_app_mmi_answ(mmi_resource, mmi_session_number, MMI_ANSW_ID_ANSWER, (uint8_t*) tmp, len);
+ in_enq = 0;
+ }
+ }
+ printf("Press a key to exit\n");
+ getchar();
+
+ // destroy slots
+ en50221_tl_destroy_slot(tl, slot_id);
+ shutdown_stackthread = 1;
+ shutdown_pmtthread = 1;
+ pthread_join(stackthread, NULL);
+ if (pmt_pid != -1) {
+ pthread_join(pmtthread, NULL);
+ }
+
+ // destroy session layer
+ en50221_sl_destroy(sl);
+
+ // destroy transport layer
+ en50221_tl_destroy(tl);
+
+ return 0;
+}
+
+int test_lookup_callback(void *arg, uint8_t slot_id, uint32_t requested_resource_id,
+ en50221_sl_resource_callback *callback_out, void **arg_out, uint32_t *connected_resource_id)
+{
+ struct en50221_app_public_resource_id resid;
+ (void)arg;
+
+ // decode the resource id
+ if (en50221_app_decode_public_resource_id(&resid, requested_resource_id)) {
+ printf("%02x:Public resource lookup callback %i %i %i\n", slot_id,
+ resid.resource_class, resid.resource_type, resid.resource_version);
+ } else {
+ printf("%02x:Private resource lookup callback %08x\n", slot_id, requested_resource_id);
+ return -1;
+ }
+
+ // FIXME: need better comparison
+ // FIXME: return resourceid we actually connected to
+
+ // try and find an instance of the resource
+ int i;
+ for(i=0; i<resources_count; i++) {
+ if ((resid.resource_class == resources[i].resid.resource_class) &&
+ (resid.resource_type == resources[i].resid.resource_type)) {
+ *callback_out = resources[i].callback;
+ *arg_out = resources[i].arg;
+ *connected_resource_id = resources[i].binary_resource_id;
+ return 0;
+ }
+ }
+
+ return -1;
+}
+
+int test_session_callback(void *arg, int reason, uint8_t slot_id, uint16_t session_number, uint32_t resource_id)
+{
+ (void)arg;
+ switch(reason) {
+ case S_SCALLBACK_REASON_CAMCONNECTING:
+ printf("%02x:CAM connecting to resource %08x, session_number %i\n",
+ slot_id, resource_id, session_number);
+ break;
+ case S_SCALLBACK_REASON_CAMCONNECTED:
+ printf("%02x:CAM successfully connected to resource %08x, session_number %i\n",
+ slot_id, resource_id, session_number);
+
+ if (resource_id == EN50221_APP_RM_RESOURCEID) {
+ en50221_app_rm_enq(rm_resource, session_number);
+ } else if (resource_id == EN50221_APP_AI_RESOURCEID) {
+ en50221_app_ai_enquiry(ai_resource, session_number);
+ } else if (resource_id == EN50221_APP_CA_RESOURCEID) {
+ en50221_app_ca_info_enq(ca_resource, session_number);
+ ca_session_number = session_number;
+ }
+
+ break;
+ case S_SCALLBACK_REASON_CAMCONNECTFAIL:
+ printf("%02x:CAM on failed to connect to resource %08x\n", slot_id, resource_id);
+ break;
+ case S_SCALLBACK_REASON_CONNECTED:
+ printf("%02x:Host connection to resource %08x connected successfully, session_number %i\n",
+ slot_id, resource_id, session_number);
+ break;
+ case S_SCALLBACK_REASON_CONNECTFAIL:
+ printf("%02x:Host connection to resource %08x failed, session_number %i\n",
+ slot_id, resource_id, session_number);
+ break;
+ case S_SCALLBACK_REASON_CLOSE:
+ printf("%02x:Connection to resource %08x, session_number %i closed\n",
+ slot_id, resource_id, session_number);
+ break;
+ case S_SCALLBACK_REASON_TC_CONNECT:
+ printf("%02x:Host originated transport connection %i connected\n", slot_id, session_number);
+ break;
+ case S_SCALLBACK_REASON_TC_CAMCONNECT:
+ printf("%02x:CAM originated transport connection %i connected\n", slot_id, session_number);
+ break;
+ }
+ return 0;
+}
+
+
+
+int test_rm_enq_callback(void *arg, uint8_t slot_id, uint16_t session_number)
+{
+ (void)arg;
+
+ printf("%02x:%s\n", slot_id, __func__);
+
+ if (en50221_app_rm_reply(rm_resource, session_number, resource_ids_count, resource_ids)) {
+ printf("%02x:Failed to send reply to ENQ\n", slot_id);
+ }
+
+ return 0;
+}
+
+int test_rm_reply_callback(void *arg, uint8_t slot_id, uint16_t session_number, uint32_t resource_id_count, uint32_t *_resource_ids)
+{
+ (void)arg;
+ printf("%02x:%s\n", slot_id, __func__);
+
+ uint32_t i;
+ for(i=0; i< resource_id_count; i++) {
+ printf(" CAM provided resource id: %08x\n", _resource_ids[i]);
+ }
+
+ if (en50221_app_rm_changed(rm_resource, session_number)) {
+ printf("%02x:Failed to send REPLY\n", slot_id);
+ }
+
+ return 0;
+}
+
+int test_rm_changed_callback(void *arg, uint8_t slot_id, uint16_t session_number)
+{
+ (void)arg;
+ printf("%02x:%s\n", slot_id, __func__);
+
+ if (en50221_app_rm_enq(rm_resource, session_number)) {
+ printf("%02x:Failed to send ENQ\n", slot_id);
+ }
+
+ return 0;
+}
+
+
+
+int test_datetime_enquiry_callback(void *arg, uint8_t slot_id, uint16_t session_number, uint8_t response_interval)
+{
+ (void)arg;
+ printf("%02x:%s\n", slot_id, __func__);
+ printf(" response_interval:%i\n", response_interval);
+
+ if (en50221_app_datetime_send(datetime_resource, session_number, time(NULL), -1)) {
+ printf("%02x:Failed to send datetime\n", slot_id);
+ }
+
+ return 0;
+}
+
+
+
+int test_ai_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ uint8_t application_type, uint16_t application_manufacturer,
+ uint16_t manufacturer_code, uint8_t menu_string_length,
+ uint8_t *menu_string)
+{
+ (void)arg;
+
+ printf("%02x:%s\n", slot_id, __func__);
+ printf(" Application type: %02x\n", application_type);
+ printf(" Application manufacturer: %04x\n", application_manufacturer);
+ printf(" Manufacturer code: %04x\n", manufacturer_code);
+ printf(" Menu string: %.*s\n", menu_string_length, menu_string);
+
+ ai_session_numbers[slot_id] = session_number;
+
+ return 0;
+}
+
+
+
+int test_ca_info_callback(void *arg, uint8_t slot_id, uint16_t session_number, uint32_t ca_id_count, uint16_t *ca_ids)
+{
+ (void)arg;
+ (void)session_number;
+
+ printf("%02x:%s\n", slot_id, __func__);
+ uint32_t i;
+ for(i=0; i< ca_id_count; i++) {
+ printf(" Supported CA ID: %04x\n", ca_ids[i]);
+ }
+
+ ca_connected = 1;
+ return 0;
+}
+
+int test_ca_pmt_reply_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ struct en50221_app_pmt_reply *reply, uint32_t reply_size)
+{
+ (void)arg;
+ (void)session_number;
+ (void)reply;
+ (void)reply_size;
+
+ printf("%02x:%s\n", slot_id, __func__);
+
+ return 0;
+}
+
+
+int test_mmi_close_callback(void *arg, uint8_t slot_id, uint16_t session_number, uint8_t cmd_id, uint8_t delay)
+{
+ (void)arg;
+ (void)session_number;
+
+ printf("%02x:%s\n", slot_id, __func__);
+ printf(" cmd_id: %02x\n", cmd_id);
+ printf(" delay: %02x\n", delay);
+
+ return 0;
+}
+
+int test_mmi_display_control_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ uint8_t cmd_id, uint8_t mmi_mode)
+{
+ (void)arg;
+ (void)session_number;
+
+ printf("%02x:%s\n", slot_id, __func__);
+ printf(" cmd_id: %02x\n", cmd_id);
+ printf(" mode: %02x\n", mmi_mode);
+
+ if (cmd_id == MMI_DISPLAY_CONTROL_CMD_ID_SET_MMI_MODE) {
+ struct en50221_app_mmi_display_reply_details details;
+
+ details.u.mode_ack.mmi_mode = mmi_mode;
+ if (en50221_app_mmi_display_reply(mmi_resource, session_number, MMI_DISPLAY_REPLY_ID_MMI_MODE_ACK, &details)) {
+ printf("%02x:Failed to send mode ack\n", slot_id);
+ }
+ }
+
+ return 0;
+}
+
+int test_mmi_keypad_control_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ uint8_t cmd_id, uint8_t *key_codes, uint32_t key_codes_count)
+{
+ (void)arg;
+ (void)session_number;
+ (void)cmd_id;
+ (void)key_codes;
+ (void)key_codes_count;
+
+ printf("%02x:%s\n", slot_id, __func__);
+
+ return 0;
+}
+
+int test_mmi_subtitle_segment_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ uint8_t *segment, uint32_t segment_size)
+{
+ (void)arg;
+ (void)session_number;
+ (void)segment;
+ (void)segment_size;
+
+ printf("%02x:%s\n", slot_id, __func__);
+
+ return 0;
+}
+
+int test_mmi_scene_end_mark_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ uint8_t decoder_continue_flag, uint8_t scene_reveal_flag,
+ uint8_t send_scene_done, uint8_t scene_tag)
+{
+ (void)arg;
+ (void)session_number;
+ (void)decoder_continue_flag;
+ (void)scene_reveal_flag;
+ (void)send_scene_done;
+ (void)scene_tag;
+
+ printf("%02x:%s\n", slot_id, __func__);
+
+ return 0;
+}
+
+int test_mmi_scene_control_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ uint8_t decoder_continue_flag, uint8_t scene_reveal_flag,
+ uint8_t scene_tag)
+{
+ (void)arg;
+ (void)session_number;
+ (void)decoder_continue_flag;
+ (void)scene_reveal_flag;
+ (void)scene_tag;
+
+ printf("%02x:%s\n", slot_id, __func__);
+
+ return 0;
+}
+
+int test_mmi_subtitle_download_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ uint8_t *segment, uint32_t segment_size)
+{
+ (void)arg;
+ (void)session_number;
+ (void)segment;
+ (void)segment_size;
+
+ printf("%02x:%s\n", slot_id, __func__);
+
+ return 0;
+}
+
+int test_mmi_flush_download_callback(void *arg, uint8_t slot_id, uint16_t session_number)
+{
+ (void)arg;
+ (void)session_number;
+
+ printf("%02x:%s\n", slot_id, __func__);
+
+ return 0;
+}
+
+int test_mmi_enq_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ uint8_t blind_answer, uint8_t expected_answer_length,
+ uint8_t *text, uint32_t text_size)
+{
+ (void)arg;
+ (void)text;
+ (void)text_size;
+
+ printf("%02x:%s\n", slot_id, __func__);
+ printf(" blind: %i\n", blind_answer);
+ printf(" expected_answer_length: %i\n", expected_answer_length);
+
+ mmi_session_number = session_number;
+ in_enq = 1;
+
+ return 0;
+}
+
+int test_mmi_menu_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ struct en50221_app_mmi_text *title,
+ struct en50221_app_mmi_text *sub_title,
+ struct en50221_app_mmi_text *bottom,
+ uint32_t item_count, struct en50221_app_mmi_text *items,
+ uint32_t item_raw_length, uint8_t *items_raw)
+{
+ (void)arg;
+ (void)items_raw;
+
+ printf("%02x:%s\n", slot_id, __func__);
+
+ printf(" title: %.*s\n", title->text_length, title->text);
+ printf(" sub_title: %.*s\n", sub_title->text_length, sub_title->text);
+ printf(" bottom: %.*s\n", bottom->text_length, bottom->text);
+
+ uint32_t i;
+ for(i=0; i< item_count; i++) {
+ printf(" item %i: %.*s\n", i+1, items[i].text_length, items[i].text);
+ }
+ printf(" raw_length: %i\n", item_raw_length);
+
+ mmi_session_number = session_number;
+ in_menu = 1;
+
+ return 0;
+}
+
+int test_app_mmi_list_callback(void *arg, uint8_t slot_id, uint16_t session_number,
+ struct en50221_app_mmi_text *title,
+ struct en50221_app_mmi_text *sub_title,
+ struct en50221_app_mmi_text *bottom,
+ uint32_t item_count, struct en50221_app_mmi_text *items,
+ uint32_t item_raw_length, uint8_t *items_raw)
+{
+ (void)arg;
+ (void)items_raw;
+ (void)arg;
+
+ printf("%02x:%s\n", slot_id, __func__);
+
+ printf(" title: %.*s\n", title->text_length, title->text);
+ printf(" sub_title: %.*s\n", sub_title->text_length, sub_title->text);
+ printf(" bottom: %.*s\n", bottom->text_length, bottom->text);
+
+ uint32_t i;
+ for(i=0; i< item_count; i++) {
+ printf(" item %i: %.*s\n", i+1, items[i].text_length, items[i].text);
+ }
+ printf(" raw_length: %i\n", item_raw_length);
+
+ mmi_session_number = session_number;
+ in_menu = 1;
+
+ return 0;
+}
+
+
+
+
+
+
+
+void *stackthread_func(void* arg) {
+ struct en50221_transport_layer *tl = arg;
+ int lasterror = 0;
+
+ while(!shutdown_stackthread) {
+ int error;
+ if ((error = en50221_tl_poll(tl)) != 0) {
+ if (error != lasterror) {
+ fprintf(stderr, "Error reported by stack slot:%i error:%i\n",
+ en50221_tl_get_error_slot(tl),
+ en50221_tl_get_error(tl));
+ }
+ lasterror = error;
+ }
+ }
+
+ shutdown_stackthread = 0;
+ return 0;
+}
+
+void *pmtthread_func(void* arg) {
+ (void)arg;
+ char buf[4096];
+ uint8_t capmt[4096];
+ int pmtversion = -1;
+
+ while(!shutdown_pmtthread) {
+
+ if (!ca_connected) {
+ sleep(1);
+ continue;
+ }
+
+ // read the PMT
+ struct section_ext *section_ext = read_section_ext(buf, sizeof(buf), adapterid, 0, pmt_pid, stag_mpeg_program_map);
+ if (section_ext == NULL) {
+ fprintf(stderr, "Failed to read PMT\n");
+ exit(1);
+ }
+ struct mpeg_pmt_section *pmt = mpeg_pmt_section_codec(section_ext);
+ if (pmt == NULL) {
+ fprintf(stderr, "Bad PMT received\n");
+ exit(1);
+ }
+ if (pmt->head.version_number == pmtversion) {
+ continue;
+ }
+
+ // translate it into a CA PMT
+ int listmgmt = CA_LIST_MANAGEMENT_ONLY;
+ if (pmtversion != -1) {
+ listmgmt = CA_LIST_MANAGEMENT_UPDATE;
+ }
+ int size;
+ if ((size = en50221_ca_format_pmt(pmt,
+ capmt,
+ sizeof(capmt),
+ listmgmt,
+ 0,
+ CA_PMT_CMD_ID_OK_DESCRAMBLING)) < 0) {
+ fprintf(stderr, "Failed to format CA PMT object\n");
+ exit(1);
+ }
+
+ // set it
+ if (en50221_app_ca_pmt(ca_resource, ca_session_number, capmt, size)) {
+ fprintf(stderr, "Failed to send CA PMT object\n");
+ exit(1);
+ }
+ pmtversion = pmt->head.version_number;
+ }
+ shutdown_pmtthread = 0;
+ return 0;
+}
+
+
+struct section_ext *read_section_ext(char *buf, int buflen, int adapter, int demux, int pid, int table_id)
+{
+ int demux_fd = -1;
+ uint8_t filter[18];
+ uint8_t mask[18];
+ int size;
+ struct section *section;
+ struct section_ext *result = NULL;
+
+ // open the demuxer
+ if ((demux_fd = dvbdemux_open_demux(adapter, demux, 0)) < 0) {
+ goto exit;
+ }
+
+ // create a section filter
+ memset(filter, 0, sizeof(filter));
+ memset(mask, 0, sizeof(mask));
+ filter[0] = table_id;
+ mask[0] = 0xFF;
+ if (dvbdemux_set_section_filter(demux_fd, pid, filter, mask, 1, 1)) {
+ goto exit;
+ }
+
+ // read the section
+ if ((size = read(demux_fd, buf, buflen)) < 0) {
+ goto exit;
+ }
+
+ // parse it as a section
+ section = section_codec((uint8_t*) buf, size);
+ if (section == NULL) {
+ goto exit;
+ }
+
+ // parse it as a section_ext
+ result = section_ext_decode(section, 0);
+
+exit:
+ if (demux_fd != -1)
+ close(demux_fd);
+ return result;
+}
diff --git a/test/libdvben50221/test-session.c b/test/libdvben50221/test-session.c
new file mode 100644
index 0000000..14dc13e
--- /dev/null
+++ b/test/libdvben50221/test-session.c
@@ -0,0 +1,171 @@
+/*
+ en50221 encoder An implementation for libdvb
+ an implementation for the en50221 transport layer
+
+ Copyright (C) 2004, 2005 Manu Abraham (manu@kromtek.com)
+ Copyright (C) 2005 Julian Scheel (julian at jusst dot de)
+ Copyright (C) 2006 Andrew de Quincey (adq_dvb@lidskialf.net)
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as
+ published by the Free Software Foundation; either version 2.1 of
+ the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include <stdio.h>
+#include <unistd.h>
+#include <libdvben50221/en50221_session.h>
+#include <libdvben50221/en50221_app_utils.h>
+#include <libdvbapi/dvbca.h>
+#include <pthread.h>
+
+void *stackthread_func(void* arg);
+int test_lookup_callback(void *arg, uint8_t slot_id, uint32_t requested_resource_id,
+ en50221_sl_resource_callback *callback_out, void **arg_out, uint32_t *connected_resource_id);
+int test_session_callback(void *arg, int reason, uint8_t slot_id, uint16_t session_number, uint32_t resource_id);
+
+
+int shutdown_stackthread = 0;
+
+#define DEFAULT_SLOT 0
+
+int main(int argc, char * argv[])
+{
+ (void)argc;
+ (void)argv;
+
+ int i;
+ pthread_t stackthread;
+
+ // create transport layer
+ struct en50221_transport_layer *tl = en50221_tl_create(5, 32);
+ if (tl == NULL) {
+ fprintf(stderr, "Failed to create transport layer\n");
+ exit(1);
+ }
+
+ // find CAMs
+ int slot_count = 0;
+ int cafd= -1;
+ for(i=0; i<20; i++) {
+ if ((cafd = dvbca_open(i, 0)) > 0) {
+ if (dvbca_get_cam_state(cafd, DEFAULT_SLOT) == DVBCA_CAMSTATE_MISSING) {
+ close(cafd);
+ continue;
+ }
+
+ // reset it and wait
+ dvbca_reset(cafd, DEFAULT_SLOT);
+ printf("Found a CAM on adapter%i... waiting...\n", i);
+ while(dvbca_get_cam_state(cafd, DEFAULT_SLOT) != DVBCA_CAMSTATE_READY) {
+ usleep(1000);
+ }
+
+ // register it with the CA stack
+ int slot_id = 0;
+ if ((slot_id = en50221_tl_register_slot(tl, cafd, DEFAULT_SLOT, 1000, 100)) < 0) {
+ fprintf(stderr, "Slot registration failed\n");
+ exit(1);
+ }
+ printf("slotid: %i\n", slot_id);
+ slot_count++;
+ }
+ }
+
+ // create session layer
+ struct en50221_session_layer *sl = en50221_sl_create(tl, 256);
+ if (sl == NULL) {
+ fprintf(stderr, "Failed to create session layer\n");
+ exit(1);
+ }
+
+ // start another thread running the stack
+ pthread_create(&stackthread, NULL, stackthread_func, tl);
+
+ // register callbacks
+ en50221_sl_register_lookup_callback(sl, test_lookup_callback, sl);
+ en50221_sl_register_session_callback(sl, test_session_callback, sl);
+
+ // create a new connection
+ for(i=0; i<slot_count; i++) {
+ int tc = en50221_tl_new_tc(tl, i);
+ printf("tcid: %i\n", tc);
+ }
+
+ // wait
+ printf("Press a key to exit\n");
+ getchar();
+
+ // destroy slots
+ for(i=0; i<slot_count; i++) {
+ en50221_tl_destroy_slot(tl, i);
+ }
+ shutdown_stackthread = 1;
+ pthread_join(stackthread, NULL);
+
+ // destroy session layer
+ en50221_sl_destroy(sl);
+
+ // destroy transport layer
+ en50221_tl_destroy(tl);
+
+ return 0;
+}
+
+int test_lookup_callback(void *arg, uint8_t slot_id, uint32_t requested_resource_id,
+ en50221_sl_resource_callback *callback_out, void **arg_out, uint32_t *connected_resource_id)
+{
+ (void)arg;
+ (void)callback_out;
+ (void)arg_out;
+ (void)connected_resource_id;
+
+ struct en50221_app_public_resource_id resid;
+
+ if (en50221_app_decode_public_resource_id(&resid, requested_resource_id)) {
+ printf("Public resource lookup callback %i %i %i %i\n", slot_id,
+ resid.resource_class, resid.resource_type, resid.resource_version);
+ } else {
+ printf("Private resource lookup callback %i %08x\n", slot_id, requested_resource_id);
+ }
+
+ return -1;
+}
+
+int test_session_callback(void *arg, int reason, uint8_t slot_id, uint16_t session_number, uint32_t resource_id)
+{
+ (void)arg;
+
+ printf("Session callback %i %i %i %04x\n", slot_id, session_number, reason, resource_id);
+
+ return -1;
+}
+
+void *stackthread_func(void* arg) {
+ struct en50221_transport_layer *tl = arg;
+ int lasterror = 0;
+
+ while(!shutdown_stackthread) {
+ int error;
+ if ((error = en50221_tl_poll(tl)) != 0) {
+ if (error != lasterror) {
+ fprintf(stderr, "Error reported by stack slot:%i error:%i\n",
+ en50221_tl_get_error_slot(tl),
+ en50221_tl_get_error(tl));
+ }
+ lasterror = error;
+ }
+ }
+
+ shutdown_stackthread = 0;
+ return 0;
+}
diff --git a/test/libdvben50221/test-transport.c b/test/libdvben50221/test-transport.c
new file mode 100644
index 0000000..fdfd98a
--- /dev/null
+++ b/test/libdvben50221/test-transport.c
@@ -0,0 +1,144 @@
+/*
+ en50221 encoder An implementation for libdvb
+ an implementation for the en50221 transport layer
+
+ Copyright (C) 2004, 2005 Manu Abraham (manu@kromtek.com)
+ Copyright (C) 2005 Julian Scheel (julian at jusst dot de)
+ Copyright (C) 2006 Andrew de Quincey (adq_dvb@lidskialf.net)
+
+ This library is free software; you can redistribute it and/or modify
+ it under the terms of the GNU Lesser General Public License as
+ published by the Free Software Foundation; either version 2.1 of
+ the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include <stdio.h>
+#include <unistd.h>
+#include <libdvben50221/en50221_transport.h>
+#include <libdvbapi/dvbca.h>
+#include <pthread.h>
+
+void *stackthread_func(void* arg);
+void test_callback(void *arg, int reason,
+ uint8_t *data, uint32_t data_length,
+ uint8_t slot_id, uint8_t connection_id);
+
+int shutdown_stackthread = 0;
+
+#define DEFAULT_SLOT 0
+
+int main(int argc, char * argv[])
+{
+ (void)argc;
+ (void)argv;
+
+ int i;
+ pthread_t stackthread;
+
+ // create transport layer
+ struct en50221_transport_layer *tl = en50221_tl_create(5, 32);
+ if (tl == NULL) {
+ fprintf(stderr, "Failed to create transport layer\n");
+ exit(1);
+ }
+
+ // find CAMs
+ int slot_count = 0;
+ int cafd= -1;
+ for(i=0; i<20; i++) {
+ if ((cafd = dvbca_open(i, 0)) > 0) {
+ if (dvbca_get_cam_state(cafd, DEFAULT_SLOT) == DVBCA_CAMSTATE_MISSING) {
+ close(cafd);
+ continue;
+ }
+
+ // reset it and wait
+ dvbca_reset(cafd, DEFAULT_SLOT);
+ printf("Found a CAM on adapter%i... waiting...\n", i);
+ while(dvbca_get_cam_state(cafd, DEFAULT_SLOT) != DVBCA_CAMSTATE_READY) {
+ usleep(1000);
+ }
+
+ // register it with the CA stack
+ int slot_id = 0;
+ if ((slot_id = en50221_tl_register_slot(tl, cafd, DEFAULT_SLOT, 1000, 100)) < 0) {
+ fprintf(stderr, "Slot registration failed\n");
+ exit(1);
+ }
+ printf("slotid: %i\n", slot_id);
+ slot_count++;
+ }
+ }
+
+ // start another thread to running the stack
+ pthread_create(&stackthread, NULL, stackthread_func, tl);
+
+ // register callback
+ en50221_tl_register_callback(tl, test_callback, tl);
+
+ // create a new connection
+ for(i=0; i<slot_count; i++) {
+ int tc = en50221_tl_new_tc(tl, i);
+ printf("tcid: %i\n", tc);
+ }
+
+ // wait
+ printf("Press a key to exit\n");
+ getchar();
+
+ // destroy slots
+ for(i=0; i<slot_count; i++) {
+ en50221_tl_destroy_slot(tl, i);
+ }
+ shutdown_stackthread = 1;
+ pthread_join(stackthread, NULL);
+
+ // destroy transport layer
+ en50221_tl_destroy(tl);
+
+ return 0;
+}
+
+void test_callback(void *arg, int reason,
+ uint8_t *data, uint32_t data_length,
+ uint8_t slot_id, uint8_t connection_id)
+{
+ (void) arg;
+
+ printf("-----------------------------------\n");
+ printf("CALLBACK SLOTID:%i %i %i\n", slot_id, connection_id, reason);
+
+ uint32_t i;
+ for(i=0; i< data_length; i++) {
+ printf("%02x %02x\n", i, data[i]);
+ }
+}
+
+void *stackthread_func(void* arg) {
+ struct en50221_transport_layer *tl = arg;
+ int lasterror = 0;
+
+ while(!shutdown_stackthread) {
+ int error;
+ if ((error = en50221_tl_poll(tl)) != 0) {
+ if (error != lasterror) {
+ fprintf(stderr, "Error reported by stack slot:%i error:%i\n",
+ en50221_tl_get_error_slot(tl),
+ en50221_tl_get_error(tl));
+ }
+ lasterror = error;
+ }
+ }
+
+ shutdown_stackthread = 0;
+ return 0;
+}