diff options
57 files changed, 3511 insertions, 2821 deletions
diff --git a/p2pvr/.p2config b/p2pvr/.p2config new file mode 100644 index 0000000..8c4269f --- /dev/null +++ b/p2pvr/.p2config @@ -0,0 +1,6 @@ +library = libp2pvrdaemon.so +daemon.type = p2pvrdaemon +common.filelog.level = 9 +common.filelog.path = /tmp/p2daemon.log +common.consolelogLevel = 9 +p2pvr.globaldevices.carddaemon = Devices:default -h defiant -p 10001 diff --git a/p2pvr/Jamfile.jam b/p2pvr/Jamfile.jam index 5d63f0d..d709f2d 100644 --- a/p2pvr/Jamfile.jam +++ b/p2pvr/Jamfile.jam @@ -1,2 +1,25 @@ -build-project scanner ; -build-project ice ; +import package ; + +alias glibmm : : : : + <cflags>"`pkg-config --cflags glibmm-2.4`" + <linkflags>"`pkg-config --libs glibmm-2.4`" + ; +alias p2common : glibmm : : : + <include>/usr/include/project2/common + <include>/usr/include/project2/lib + <linkflags>"-lp2common" +; +alias p2sql : glibmm : : : + <include>/usr/include/project2/sql + <linkflags>"-lp2sql" +; +alias p2daemonlib : glibmm : : : + <cflags>"-I /usr/include/project2/daemon/lib" + <linkflags>"-lp2daemonlib" +; +build-project daemon ; +build-project carddaemon ; + +install debuginstall : lib carddaemon daemon ice : <location>./testing ; +package.install install : : : carddaemon daemon ; + diff --git a/p2pvr/carddaemon/Jamfile.jam b/p2pvr/carddaemon/Jamfile.jam new file mode 100644 index 0000000..9b4aa83 --- /dev/null +++ b/p2pvr/carddaemon/Jamfile.jam @@ -0,0 +1,10 @@ +lib boost_filesystem ; +lib boost_system ; + +lib p2pvrcarddaemon : + [ glob *.cpp ] + : + <library>..//p2daemonlib + <library>../ice//p2pvrice + <library>../lib//p2pvrlib + ; diff --git a/p2pvr/carddaemon/carddaemon.cpp b/p2pvr/carddaemon/carddaemon.cpp new file mode 100644 index 0000000..f75109e --- /dev/null +++ b/p2pvr/carddaemon/carddaemon.cpp @@ -0,0 +1,53 @@ +#include <daemon.h> +#include <options.h> +#include <logger.h> +#include <Ice/Ice.h> +#include "localDevices.h" + +class P2PvrCardDaemon : public Daemon { + public: + P2PvrCardDaemon(int argc, char ** argv) : + ic(Ice::initialize(argc, argv)) + { + } + + ~P2PvrCardDaemon() + { + ic->destroy(); + } + + void run() const + { + Logger()->messagebf(LOG_INFO, "Creating adapter (%s, %s)", Adapter, Endpoint); + auto adapter = ic->createObjectAdapterWithEndpoints(Adapter, Endpoint); + P2PVR::LocalDevicesPrx::checkedCast(adapter->add(new LocalDevices(), ic->stringToIdentity(Identity))); + adapter->activate(); + ic->waitForShutdown(); + } + + void shutdown() const + { + ic->shutdown(); + } + INITOPTIONS; + + private: + Ice::CommunicatorPtr ic; + + static std::string Adapter; + static std::string Endpoint; + static std::string Identity; +}; + +std::string P2PvrCardDaemon::Adapter; +std::string P2PvrCardDaemon::Endpoint; +std::string P2PvrCardDaemon::Identity; + +DECLARE_GENERIC_LOADER("p2pvrcarddaemon", DaemonLoader, P2PvrCardDaemon); + +DECLARE_OPTIONS(P2PvrCardDaemon, "P2PVR Card Daemon") +("p2pvr.carddaemon.iceadapter", Options::value(&Adapter, "DefaultAdapter"), "ICE Adapter name") +("p2pvr.carddaemon.iceendpoint", Options::value(&Endpoint, "default -p 10001"), "ICE Endpoint address") +("p2pvr.carddaemon.iceidentity", Options::value(&Identity, "Devices"), "ICE Interface identity") +END_OPTIONS(P2PvrCardDaemon); + diff --git a/p2pvr/cron/epg.xml b/p2pvr/cron/epg.xml deleted file mode 100644 index 8fa9828..0000000 --- a/p2pvr/cron/epg.xml +++ /dev/null @@ -1,35 +0,0 @@ -<?xml version="1.0"?> -<block name="importSchedule" xmlns:p2="http://project2.randomdan.homeip.net"> - <p2:library path="libp2pvr-scan-p2.so" /> - <p2:epgrows name="schedule" demux="/dev/dvb/adapter0/demux0" /> - <p2:view name="showSchedule" source="schedule" rootname="sched" recordname="show"> - <columns> - <title source="parent" attribute="title" depth="1" /> - <titleLang source="parent" attribute="titleLang" depth="1" /> - <subtitle source="parent" attribute="subtitle" depth="1" /> - <serviceID source="parent" attribute="serviceID" depth="1" /> - <descLang source="parent" attribute="descLang" depth="1" /> - <desc1 source="parent" attribute="desc1" depth="1" /> - <desc2 source="parent" attribute="desc2" depth="1" /> - <desc3 source="parent" attribute="desc3" depth="1" /> - <videoAspect source="parent" attribute="videoAspect" depth="1" /> - <videoFrameRate source="parent" attribute="videoFrameRate" depth="1" /> - <videoHD source="parent" attribute="videoHD" depth="1" /> - <audioChannels source="parent" attribute="audioChannels" depth="1" /> - <language source="parent" attribute="language" depth="1" /> - <teletextSubtitleLang source="parent" attribute="teletextSubtitleLang" depth="1" /> - <category source="parent" attribute="category" depth="1" /> - <dvbRating source="parent" attribute="dvbRating" depth="1" /> - <contentItemID source="parent" attribute="contentItemID" depth="1" /> - <contentRecommendation source="parent" attribute="contentRecommendation" depth="1" /> - <contentSeriesID source="parent" attribute="contentSeriesID" depth="1" /> - <startTime source="parent" attribute="startTime" depth="1" /> - <stopTime source="parent" attribute="stopTime" depth="1" /> - <eventID source="parent" attribute="eventID" depth="1" /> - <episode source="parent" attribute="episode" depth="1" /> - <episodes source="parent" attribute="episodes" depth="1" /> - <year source="parent" attribute="year" depth="1" /> - <flags source="parent" attribute="flags" depth="1" /> - </columns> - </p2:view> -</block> diff --git a/p2pvr/cron/importEpg.xml b/p2pvr/cron/importEpg.xml deleted file mode 100644 index c3858f5..0000000 --- a/p2pvr/cron/importEpg.xml +++ /dev/null @@ -1,67 +0,0 @@ -<?xml version="1.0"?> -<block name="importSchedule" xmlns:p2="http://project2.randomdan.homeip.net"> - <p2:library path="libp2pvr-scan-p2.so" /> - <p2:epgrows name="schedule" demux="/dev/dvb/adapter0/demux0" /> - <p2:sqlmerge name="mergeSchedule" datasource="postgres" targettable="programs"> - <p2:iterate name="programs" source="schedule"> - <p2:sqlmergeinsert name="insertProgram"> - <parameters> - <title source="parent" attribute="title" depth="1" /> - <titleLang source="parent" attribute="titleLang" depth="1" /> - <subtitle source="parent" attribute="subtitle" depth="1" /> - <serviceID source="parent" attribute="serviceID" depth="1" /> - <descLang source="parent" attribute="descLang" depth="1" /> - <desc1 source="parent" attribute="desc1" depth="1" /> - <desc2 source="parent" attribute="desc2" depth="1" /> - <desc3 source="parent" attribute="desc3" depth="1" /> - <videoAspect source="parent" attribute="videoAspect" depth="1" /> - <videoFrameRate source="parent" attribute="videoFrameRate" depth="1" /> - <videoHD source="parent" attribute="videoHD" depth="1" /> - <audioChannels source="parent" attribute="audioChannels" depth="1" /> - <language source="parent" attribute="language" depth="1" /> - <teletextSubtitleLang source="parent" attribute="teletextSubtitleLang" depth="1" /> - <category source="parent" attribute="category" depth="1" /> - <dvbRating source="parent" attribute="dvbRating" depth="1" /> - <contentItemID source="parent" attribute="contentItemID" depth="1" /> - <contentRecommendation source="parent" attribute="contentRecommendation" depth="1" /> - <contentSeriesID source="parent" attribute="contentSeriesID" depth="1" /> - <startTime source="parent" attribute="startTime" depth="1" /> - <stopTime source="parent" attribute="stopTime" depth="1" /> - <eventID source="parent" attribute="eventID" depth="1" /> - <episode source="parent" attribute="episode" depth="1" /> - <episodes source="parent" attribute="episodes" depth="1" /> - <year source="parent" attribute="year" depth="1" /> - <flags source="parent" attribute="flags" depth="1" /> - </parameters> - </p2:sqlmergeinsert> - </p2:iterate> - <columns> - <title /> - <titleLang /> - <subtitle /> - <serviceID key="true" /> - <eventID key="true" /> - <descLang /> - <desc1 /> - <desc2 /> - <desc3 /> - <videoAspect /> - <videoFrameRate /> - <videoHD /> - <audioChannels /> - <language /> - <teletextSubtitleLang /> - <category /> - <dvbRating /> - <contentItemID /> - <contentRecommendation /> - <contentSeriesID /> - <startTime /> - <stopTime /> - <episode /> - <episodes /> - <year /> - <flags /> - </columns> - </p2:sqlmerge> -</block> diff --git a/p2pvr/cron/importServices.xml b/p2pvr/cron/importServices.xml deleted file mode 100644 index d914d15..0000000 --- a/p2pvr/cron/importServices.xml +++ /dev/null @@ -1,28 +0,0 @@ -<?xml version="1.0"?> -<block name="importServices" xmlns:p2="http://project2.randomdan.homeip.net"> - <p2:library path="libp2pvr-scan-p2.so" /> - <p2:servicerows name="services" demux="/dev/dvb/adapter0/demux0" /> - <p2:sqlmerge name="mergeServices" datasource="postgres" targettable="services"> - <p2:iterate name="programs" source="services"> - <p2:sqlmergeinsert name="insertProgram"> - <parameters> - <serviceID source="parent" attribute="serviceID" depth="1" /> - <name source="parent" attribute="name" depth="1" /> - <providerName source="parent" attribute="providerName" depth="1" /> - <transportID source="parent" attribute="transportID" depth="1" /> - <type source="parent" attribute="type" depth="1" /> - <defaultAuthority source="parent" attribute="defaultAuthority" depth="1" /> - </parameters> - </p2:sqlmergeinsert> - </p2:iterate> - <columns> - <serviceID key="true" /> - <name /> - <providerName /> - <transportID /> - <type /> - <defaultAuthority /> - </columns> - </p2:sqlmerge> -</block> - diff --git a/p2pvr/cron/services.xml b/p2pvr/cron/services.xml deleted file mode 100644 index bdd038e..0000000 --- a/p2pvr/cron/services.xml +++ /dev/null @@ -1,16 +0,0 @@ -<?xml version="1.0"?> -<block name="showServices" xmlns:p2="http://project2.randomdan.homeip.net"> - <p2:library path="libp2pvr-scan-p2.so" /> - <p2:servicerows name="services" demux="/dev/dvb/adapter0/demux0" /> - <p2:view name="showServices" source="services" rootname="services" recordname="service"> - <columns> - <serviceID source="parent" attribute="serviceID" depth="1" /> - <name source="parent" attribute="name" depth="1" /> - <providerName source="parent" attribute="providerName" depth="1" /> - <transportID source="parent" attribute="transportID" depth="1" /> - <type source="parent" attribute="type" depth="1" /> - <defaultAuthority source="parent" attribute="defaultAuthority" depth="1" /> - </columns> - </p2:view> -</block> - diff --git a/p2pvr/daemon/Jamfile.jam b/p2pvr/daemon/Jamfile.jam new file mode 100644 index 0000000..7379c7a --- /dev/null +++ b/p2pvr/daemon/Jamfile.jam @@ -0,0 +1,10 @@ +lib Ice ; +lib IceUtil ; + +lib p2pvrdaemon : + [ glob *.cpp ] + : + <library>..//p2daemonlib + <library>../ice//p2pvrice + <library>../lib//p2pvrlib + ; diff --git a/p2pvr/daemon/daemon.cpp b/p2pvr/daemon/daemon.cpp new file mode 100644 index 0000000..de470d3 --- /dev/null +++ b/p2pvr/daemon/daemon.cpp @@ -0,0 +1,64 @@ +#include <daemon.h> +#include <options.h> +#include <Ice/Ice.h> +#include "localDevices.h" +#include "globalDevices.h" +#include "maintenance.h" +#include "si.h" +#include <logger.h> + +#include <linux/dvb/frontend.h> + +class P2PvrDaemon : public Daemon { + public: + P2PvrDaemon(int argc, char ** argv) : + ic(Ice::initialize(argc, argv)) + { + } + + ~P2PvrDaemon() + { + ic->destroy(); + } + + void run() const + { + Logger()->messagebf(LOG_INFO, "Creating adapter (%s, %s)", Adapter, Endpoint); + auto adapter = ic->createObjectAdapterWithEndpoints(Adapter, Endpoint); + adapter->add(new LocalDevices(), ic->stringToIdentity("Devices")); + adapter->add(new GlobalDevices(), ic->stringToIdentity("GlobalDevices")); + adapter->add(new Maintenance(), ic->stringToIdentity("Maintenance")); + adapter->add(new SI(), ic->stringToIdentity("SI")); + adapter->activate(); + + auto maint = P2PVR::MaintenancePrx::checkedCast(adapter->createProxy(ic->stringToIdentity("Maintenance"))); + maint->UpdateTransports(FE_OFDM); + maint->UpdateServices(FE_OFDM); + maint->UpdateEvents(FE_OFDM); + + //ic->waitForShutdown(); + } + + void shutdown() const + { + ic->shutdown(); + } + INITOPTIONS; + + private: + Ice::CommunicatorPtr ic; + + static std::string Adapter; + static std::string Endpoint; +}; + +std::string P2PvrDaemon::Adapter; +std::string P2PvrDaemon::Endpoint; + +DECLARE_GENERIC_LOADER("p2pvrdaemon", DaemonLoader, P2PvrDaemon); + +DECLARE_OPTIONS(P2PvrDaemon, "P2PVR Daemon") +("p2pvr.daemon.iceadapter", Options::value(&Adapter, "DefaultAdapter"), "ICE Adapter name") +("p2pvr.daemon.iceendpoint", Options::value(&Endpoint, "default -p 10000"), "ICE Endpoint address") +END_OPTIONS(P2PvrDaemon); + diff --git a/p2pvr/datasources/postgres.xml b/p2pvr/datasources/postgres.xml index 7d7440e..c538a8c 100644 --- a/p2pvr/datasources/postgres.xml +++ b/p2pvr/datasources/postgres.xml @@ -1,8 +1,4 @@ <?xml version="1.0"?> <project2:rdbmsdatasource xmlns:project2="http://project2.randomdan.homeip.net" name="postgres"> - <readonly preferlocal="true"> - <dsn host="defiant" provider="postgresql" dsn="host=defiant sslmode=disable user=p2tv dbname=gentoo options='-c search_path=p2tv,public'" /> - <dsn host="firebrand" provider="postgresql" dsn="host=firebrand sslmode=disable user=p2tv dbname=gentoo options='-c search_path=p2tv,public'" /> - </readonly> - <masterdsn host="defiant" provider="postgresql" dsn="host=defiant sslmode=disable user=p2tv dbname=gentoo options='-c search_path=p2tv,public'" /> + <masterdsn provider="postgresql" dsn="user=gentoo dbname=p2pvr" /> </project2:rdbmsdatasource> diff --git a/p2pvr/datasources/schema.sql b/p2pvr/datasources/schema.sql new file mode 100644 index 0000000..c628bf0 --- /dev/null +++ b/p2pvr/datasources/schema.sql @@ -0,0 +1,382 @@ +-- +-- PostgreSQL database dump +-- + +SET statement_timeout = 0; +SET lock_timeout = 0; +SET client_encoding = 'UTF8'; +SET standard_conforming_strings = on; +SET check_function_bodies = false; +SET client_min_messages = warning; + +-- +-- Name: plpgsql; Type: EXTENSION; Schema: -; Owner: +-- + +CREATE EXTENSION IF NOT EXISTS plpgsql WITH SCHEMA pg_catalog; + + +-- +-- Name: EXTENSION plpgsql; Type: COMMENT; Schema: -; Owner: +-- + +COMMENT ON EXTENSION plpgsql IS 'PL/pgSQL procedural language'; + + +SET search_path = public, pg_catalog; + +SET default_tablespace = ''; + +SET default_with_oids = false; + +-- +-- Name: delivery_dvbc; Type: TABLE; Schema: public; Owner: gentoo; Tablespace: +-- + +CREATE TABLE delivery_dvbc ( + frequency bigint NOT NULL, + transportstreamid integer NOT NULL, + fecouter smallint, + modulation smallint, + symbolrate integer, + fecinner smallint +); + + +ALTER TABLE public.delivery_dvbc OWNER TO gentoo; + +-- +-- Name: delivery_dvbs; Type: TABLE; Schema: public; Owner: gentoo; Tablespace: +-- + +CREATE TABLE delivery_dvbs ( + frequency bigint NOT NULL, + transportstreamid integer NOT NULL, + orbitalposition integer, + westeastflag boolean, + polarization smallint, + rolloff smallint, + modulationsystem boolean, + modulationtype smallint, + symbolrate integer, + fecinner smallint +); + + +ALTER TABLE public.delivery_dvbs OWNER TO gentoo; + +-- +-- Name: delivery_dvbt; Type: TABLE; Schema: public; Owner: gentoo; Tablespace: +-- + +CREATE TABLE delivery_dvbt ( + frequency bigint NOT NULL, + transportstreamid integer NOT NULL, + bandwidth smallint, + priority boolean, + timeslicing boolean, + mpefec boolean, + constellation smallint, + hierarchy smallint, + coderatehp smallint, + coderatelp smallint, + guardinterval smallint, + transmissionmode smallint, + otherfrequencyflag boolean +); + + +ALTER TABLE public.delivery_dvbt OWNER TO gentoo; + +-- +-- Name: event_schedule; Type: TABLE; Schema: public; Owner: gentoo; Tablespace: +-- + +CREATE TABLE event_schedule ( + serviceid integer NOT NULL, + eventid integer NOT NULL, + scheduleid integer NOT NULL +); + + +ALTER TABLE public.event_schedule OWNER TO gentoo; + +-- +-- Name: events; Type: TABLE; Schema: public; Owner: gentoo; Tablespace: +-- + +CREATE TABLE events ( + serviceid integer NOT NULL, + eventid integer NOT NULL, + title text, + titlelang text, + subtitle text, + description text, + descriptionlang text, + videoaspect smallint, + videoframerate smallint, + videohd boolean, + audiochannels smallint, + audiolanguage text, + subtitlelanguage text, + category smallint, + subcategory smallint, + usercategory smallint, + dvbrating smallint, + starttime timestamp without time zone, + stoptime timestamp without time zone, + episode smallint, + episodes smallint, + year smallint, + flags text +); + + +ALTER TABLE public.events OWNER TO gentoo; + +-- +-- Name: networks; Type: TABLE; Schema: public; Owner: gentoo; Tablespace: +-- + +CREATE TABLE networks ( + networkid integer NOT NULL, + name text NOT NULL +); + + +ALTER TABLE public.networks OWNER TO gentoo; + +-- +-- Name: schedules; Type: TABLE; Schema: public; Owner: gentoo; Tablespace: +-- + +CREATE TABLE schedules ( + scheduleid integer NOT NULL, + serviceid integer, + eventid integer, + title text, + search text +); + + +ALTER TABLE public.schedules OWNER TO gentoo; + +-- +-- Name: schedules_scheduleid_seq; Type: SEQUENCE; Schema: public; Owner: gentoo +-- + +CREATE SEQUENCE schedules_scheduleid_seq + START WITH 1 + INCREMENT BY 1 + NO MINVALUE + NO MAXVALUE + CACHE 1; + + +ALTER TABLE public.schedules_scheduleid_seq OWNER TO gentoo; + +-- +-- Name: schedules_scheduleid_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: gentoo +-- + +ALTER SEQUENCE schedules_scheduleid_seq OWNED BY schedules.scheduleid; + + +-- +-- Name: services; Type: TABLE; Schema: public; Owner: gentoo; Tablespace: +-- + +CREATE TABLE services ( + serviceid integer NOT NULL, + name text, + providername text, + type smallint, + defaultauthority text, + runningstatus smallint, + eitschedule boolean, + eitpresentfollowing boolean, + freecamode boolean, + transportstreamid integer NOT NULL +); + + +ALTER TABLE public.services OWNER TO gentoo; + +-- +-- Name: transportstreams; Type: TABLE; Schema: public; Owner: gentoo; Tablespace: +-- + +CREATE TABLE transportstreams ( + transportstreamid integer NOT NULL, + networkid integer NOT NULL, + originalnetworkid integer +); + + +ALTER TABLE public.transportstreams OWNER TO gentoo; + +-- +-- Name: scheduleid; Type: DEFAULT; Schema: public; Owner: gentoo +-- + +ALTER TABLE ONLY schedules ALTER COLUMN scheduleid SET DEFAULT nextval('schedules_scheduleid_seq'::regclass); + + +-- +-- Name: pk_delivery_dvbc; Type: CONSTRAINT; Schema: public; Owner: gentoo; Tablespace: +-- + +ALTER TABLE ONLY delivery_dvbc + ADD CONSTRAINT pk_delivery_dvbc PRIMARY KEY (frequency); + + +-- +-- Name: pk_delivery_dvbs; Type: CONSTRAINT; Schema: public; Owner: gentoo; Tablespace: +-- + +ALTER TABLE ONLY delivery_dvbs + ADD CONSTRAINT pk_delivery_dvbs PRIMARY KEY (frequency); + + +-- +-- Name: pk_delivery_dvbt; Type: CONSTRAINT; Schema: public; Owner: gentoo; Tablespace: +-- + +ALTER TABLE ONLY delivery_dvbt + ADD CONSTRAINT pk_delivery_dvbt PRIMARY KEY (frequency); + + +-- +-- Name: pk_events; Type: CONSTRAINT; Schema: public; Owner: gentoo; Tablespace: +-- + +ALTER TABLE ONLY events + ADD CONSTRAINT pk_events PRIMARY KEY (serviceid, eventid); + + +-- +-- Name: pk_eventschedule; Type: CONSTRAINT; Schema: public; Owner: gentoo; Tablespace: +-- + +ALTER TABLE ONLY event_schedule + ADD CONSTRAINT pk_eventschedule PRIMARY KEY (eventid, scheduleid); + + +-- +-- Name: pk_networks; Type: CONSTRAINT; Schema: public; Owner: gentoo; Tablespace: +-- + +ALTER TABLE ONLY networks + ADD CONSTRAINT pk_networks PRIMARY KEY (networkid); + + +-- +-- Name: pk_schedules; Type: CONSTRAINT; Schema: public; Owner: gentoo; Tablespace: +-- + +ALTER TABLE ONLY schedules + ADD CONSTRAINT pk_schedules PRIMARY KEY (scheduleid); + + +-- +-- Name: pk_services; Type: CONSTRAINT; Schema: public; Owner: gentoo; Tablespace: +-- + +ALTER TABLE ONLY services + ADD CONSTRAINT pk_services PRIMARY KEY (serviceid); + + +-- +-- Name: pk_transportstreams; Type: CONSTRAINT; Schema: public; Owner: gentoo; Tablespace: +-- + +ALTER TABLE ONLY transportstreams + ADD CONSTRAINT pk_transportstreams PRIMARY KEY (transportstreamid); + + +-- +-- Name: fk_delivery_dvbc_transportstream; Type: FK CONSTRAINT; Schema: public; Owner: gentoo +-- + +ALTER TABLE ONLY delivery_dvbc + ADD CONSTRAINT fk_delivery_dvbc_transportstream FOREIGN KEY (transportstreamid) REFERENCES transportstreams(transportstreamid) ON UPDATE CASCADE ON DELETE CASCADE; + + +-- +-- Name: fk_delivery_dvbs_transportstream; Type: FK CONSTRAINT; Schema: public; Owner: gentoo +-- + +ALTER TABLE ONLY delivery_dvbs + ADD CONSTRAINT fk_delivery_dvbs_transportstream FOREIGN KEY (transportstreamid) REFERENCES transportstreams(transportstreamid) ON UPDATE CASCADE ON DELETE CASCADE; + + +-- +-- Name: fk_delivery_dvbt_transportstream; Type: FK CONSTRAINT; Schema: public; Owner: gentoo +-- + +ALTER TABLE ONLY delivery_dvbt + ADD CONSTRAINT fk_delivery_dvbt_transportstream FOREIGN KEY (transportstreamid) REFERENCES transportstreams(transportstreamid) ON UPDATE CASCADE ON DELETE CASCADE; + + +-- +-- Name: fk_eventschedule; Type: FK CONSTRAINT; Schema: public; Owner: gentoo +-- + +ALTER TABLE ONLY event_schedule + ADD CONSTRAINT fk_eventschedule FOREIGN KEY (serviceid, eventid) REFERENCES events(serviceid, eventid) ON DELETE CASCADE; + + +-- +-- Name: fk_eventschedule_schedule; Type: FK CONSTRAINT; Schema: public; Owner: gentoo +-- + +ALTER TABLE ONLY event_schedule + ADD CONSTRAINT fk_eventschedule_schedule FOREIGN KEY (scheduleid) REFERENCES schedules(scheduleid) ON UPDATE CASCADE ON DELETE CASCADE; + + +-- +-- Name: fk_schedule_event; Type: FK CONSTRAINT; Schema: public; Owner: gentoo +-- + +ALTER TABLE ONLY schedules + ADD CONSTRAINT fk_schedule_event FOREIGN KEY (serviceid, eventid) REFERENCES events(serviceid, eventid) ON DELETE CASCADE; + + +-- +-- Name: fk_schedule_service; Type: FK CONSTRAINT; Schema: public; Owner: gentoo +-- + +ALTER TABLE ONLY schedules + ADD CONSTRAINT fk_schedule_service FOREIGN KEY (serviceid) REFERENCES services(serviceid) ON DELETE CASCADE; + + +-- +-- Name: fk_services_transportstreams; Type: FK CONSTRAINT; Schema: public; Owner: gentoo +-- + +ALTER TABLE ONLY services + ADD CONSTRAINT fk_services_transportstreams FOREIGN KEY (transportstreamid) REFERENCES transportstreams(transportstreamid) ON UPDATE CASCADE ON DELETE CASCADE; + + +-- +-- Name: fk_transportstreams_network; Type: FK CONSTRAINT; Schema: public; Owner: gentoo +-- + +ALTER TABLE ONLY transportstreams + ADD CONSTRAINT fk_transportstreams_network FOREIGN KEY (networkid) REFERENCES networks(networkid) ON UPDATE CASCADE ON DELETE CASCADE; + + +-- +-- Name: public; Type: ACL; Schema: -; Owner: postgres +-- + +REVOKE ALL ON SCHEMA public FROM PUBLIC; +REVOKE ALL ON SCHEMA public FROM postgres; +GRANT ALL ON SCHEMA public TO postgres; +GRANT ALL ON SCHEMA public TO PUBLIC; + + +-- +-- PostgreSQL database dump complete +-- + diff --git a/p2pvr/doc/en_300468v011101p.pdf b/p2pvr/doc/en_300468v011101p.pdf Binary files differnew file mode 100644 index 0000000..6aae6b2 --- /dev/null +++ b/p2pvr/doc/en_300468v011101p.pdf diff --git a/p2pvr/ice/Jamfile.jam b/p2pvr/ice/Jamfile.jam index 9055b2e..219c508 100644 --- a/p2pvr/ice/Jamfile.jam +++ b/p2pvr/ice/Jamfile.jam @@ -1,13 +1,16 @@ -import package ; - -lib Ice : : <name>Ice ; -lib IceUtil : : <name>IceUtil ; -lib pthread : : <name>pthread ; +lib Ice ; +lib IceUtil ; +lib pthread ; lib p2pvrice : [ glob *.ice ] : <library>Ice <library>IceUtil <library>pthread + : : + <include>. + <library>Ice + <library>IceUtil + <library>pthread ; diff --git a/p2pvr/ice/commonHelpers.h b/p2pvr/ice/commonHelpers.h new file mode 100644 index 0000000..b54523e --- /dev/null +++ b/p2pvr/ice/commonHelpers.h @@ -0,0 +1,22 @@ +#ifndef ICE_COMMON_HELPERS_H +#define ICE_COMMON_HELPERS_H + +#include <p2pvr.h> +#include <ostream> + +namespace Common { + template<typename C, typename T> + std::basic_ostream<C, T> & + operator<<(std::basic_ostream<C, T> & o, const Common::DateTime & dt) + { + o << std::setw(4) << std::setfill('0') << dt.Year + << "-" << std::setw(2) << std::setfill('0') << dt.Month + << "-" << std::setw(2) << std::setfill('0') << dt.Day + << "T" << std::setw(2) << std::setfill('0') << dt.Hour + << ":" << std::setw(2) << std::setfill('0') << dt.Minute; + return o; + } +} + +#endif + diff --git a/p2pvr/ice/p2pvr.ice b/p2pvr/ice/p2pvr.ice index aaa01bf..250cc37 100644 --- a/p2pvr/ice/p2pvr.ice +++ b/p2pvr/ice/p2pvr.ice @@ -1,40 +1,232 @@ -module P2TV { +module Common { + struct DateTime { + short Year; + short Month; + short Day; + short Hour; + short Minute; + }; + + struct TimeOfDay { + short Hour; + short Minute; + }; +}; + +// This attempts to define an ICE representation of domain objects contained +// within the DVB SI (Digital Video Broadcasting specification for Service +// Information - EN 300 468 v1.11.1) + +module DVBSI { + // Descriptors + class Delivery { + long Frequency; + }; + + class SatelliteDelivery extends Delivery { + int OrbitalPosition; + bool WestEastFlag; + short Polarization; + short RollOff; + bool ModulationSystem; + short ModulationType; + int SymbolRate; + short FecInner; + }; + + class CableDelivery extends Delivery { + short FecOuter; + short Modulation; + int SymbolRate; + short FecInner; + }; + + class TerrestrialDelivery extends Delivery { + short Bandwidth; + bool Priority; + bool TimeSlicing; + bool MpeFec; + short Constellation; + short Hierarchy; + short CodeRateHP; + short CodeRateLP; + short GuardInterval; + short TransmissionMode; + bool OtherFrequencyFlag; + }; + + struct NetworkService { + int ServiceId; + short ServiceType; + }; + sequence<NetworkService> NetworkServiceList; + + class NetworkTransportStream { + int TransportStreamId; + int OriginalNetworkId; + SatelliteDelivery Satellite; + CableDelivery Cable; + TerrestrialDelivery Terrestrial; + NetworkServiceList Services; + }; + sequence<NetworkTransportStream> NetworkTransportStreams; + + class Network { + int NetworkId; + optional(1) string Name; + NetworkTransportStreams TransportStreams; + }; + + class BouquetTransportStream { + int TransportStreamId; + int OriginalNetworkId; + }; + sequence <BouquetTransportStream> BouquetTransportStreamList; + + class Bouquet { + int BouquetId; + optional(1) string Name; + optional(2) string DefaultAuthority; + BouquetTransportStreamList Streams; + }; + + class Service { + int ServiceId; + bool EitSchedule; + bool EitPresentFollowing; + short RunningStatus; + bool FreeCaMode; + optional(1) string ProviderName; + optional(2) string Name; + optional(3) short Type; + optional(4) string DefaultAuthority; + }; + sequence<Service> ServiceList; + + class TransportStream { + int TransportStreamId; + int OriginalNetworkId; + ServiceList Services; + }; + + class EitInformation { + int ServiceId; + int TransportStreamId; + int OriginalNetworkId; + }; + + class Event { + int ServiceId; + int EventId; + string Title; + string TitleLang; + optional(1) string Subtitle; + optional(2) string Description; + optional(3) string DescriptionLang; + Common::DateTime StartTime; + Common::DateTime StopTime; + optional(4) short Episode; + optional(5) short Episodes; + optional(6) short Year; + optional(7) string Flags; + optional(8) short DvbRating; + optional(9) short VideoAspect; + optional(10) short VideoFrameRate; + optional(11) bool VideoHD; + optional(12) short AudioChannels; + optional(13) string AudioLanguage; + optional(14) string SubtitleLanguage; + optional(15) short Category; + optional(16) short SubCategory; + optional(17) short UserCategory; + }; +}; +module P2PVR { + exception DeviceError { + string Device; + string Message; + int Errno; + }; + exception IncorrectDeliveryType { }; + + // Event in the database, it has a unique Id. + class Program extends DVBSI::Event { + int ProgramId; + }; + sequence<Program> ProgramList; + + // Something that we have recorded. struct Recording { - int recordingId; + int RecordingId; string Title; string Subtitle; string Description; - long startTime; - long endTime; - long fileSize; - int serviceId; + Common::DateTime StartTime; + Common::DateTime EndTime; + long FileSize; + int ServiceId; }; sequence<Recording> RecordingList; - struct Schedule { - int scheduleId; + // Something that defines what we would like to record. + class Schedule { + int ScheduleId; + optional(1) string Title; + optional(2) string Subtitle; + optional(3) int ServiceId; + optional(4) Common::TimeOfDay Time; + optional(5) string Search; + bool Repeats; }; sequence<Schedule> ScheduleList; - - struct Program { - int programId; - int serviceId; - int eventId; - string Title; - string Subtitle; - string Description; - long startTime; - long endTime; + + sequence<byte> Data; + sequence<short> PacketIds; + + interface RawDataClient { + bool NewData(Data bytes); + }; + + interface Tuner { + idempotent int GetStatus(); + + idempotent void SendNetworkInformation(RawDataClient * client); + idempotent void SendBouquetAssociations(RawDataClient * client); + idempotent void SendServiceDescriptions(RawDataClient * client); + idempotent void SendEventInformation(RawDataClient * client); + + int StartSendingTS(PacketIds pids, RawDataClient * client); + idempotent void StopSendingTS(int handle); + }; + interface PrivateTuner extends Tuner { + idempotent void TuneTo(DVBSI::Delivery d); + idempotent void ScanAndSendNetworkInformation(RawDataClient * client); }; - sequence<Program> ProgramList; - struct Service { - int serviceId; - string name; - string authority; + interface Devices { + // Get a tuner that is tuned to <del>, acquire and tune to <del> if required. + Tuner * GetTunerSpecific(DVBSI::Delivery del, long until); + // Get any tuner that is tuned, acquire and tune to <del> if required. + Tuner * GetTunerAny(short type, DVBSI::Delivery del, long until); + // Get a private tuner, not shared or sharable + PrivateTuner * GetPrivateTuner(short type, long until); + // Release a tuner when no longer required. + idempotent void ReleaseTuner(Tuner * t); + }; + + interface LocalDevices extends Devices { + idempotent void Scan(); + idempotent void Add(string frontend); + idempotent void Remove(string frontend); }; - sequence<Service> ServiceList; + interface Maintenance { + idempotent void UpdateAll(); + idempotent void UpdateTransports(short type); + idempotent void UpdateServices(short type); + idempotent void UpdateEvents(short type); + }; + interface Recordings { idempotent void DeleteRecording(int recordingId); idempotent RecordingList GetRecordings(); @@ -47,10 +239,10 @@ module P2TV { idempotent void DoReschedule(); }; - interface EPG { - idempotent ServiceList GetServices(); - idempotent ProgramList GetPrograms(int serviceId, int limit); - idempotent ProgramList GetNowAndNext(); + sequence<DVBSI::Delivery> Deliveries; + interface SI { + // Get any delivery suitable for SI reading + idempotent Deliveries GetAllDeliveries(short type); }; }; diff --git a/p2pvr/lib/Jamfile.jam b/p2pvr/lib/Jamfile.jam new file mode 100644 index 0000000..b05e572 --- /dev/null +++ b/p2pvr/lib/Jamfile.jam @@ -0,0 +1,18 @@ +lib boost_system ; +lib boost_filesystem ; + +lib p2pvrlib : + [ glob-tree *.cpp ] + ../../libmisc/misc.cpp + : + <library>boost_system + <library>boost_filesystem + <library>../ice//p2pvrice + <library>..//p2common + <library>..//p2sql + <implicit-dependency>../ice//p2pvrice + : : + <library>boost_filesystem + <implicit-dependency>../ice//p2pvrice + <include>. + ; diff --git a/p2pvr/lib/containerCreator.h b/p2pvr/lib/containerCreator.h new file mode 100644 index 0000000..aed2479 --- /dev/null +++ b/p2pvr/lib/containerCreator.h @@ -0,0 +1,32 @@ +#ifndef CONTAINERCREATOR_H +#define CONTAINERCREATOR_H + +#include <boost/function.hpp> + +template <typename T, typename V> +class ContainerCreator { + public: + ContainerCreator(T & c) : container(c) { } + + void populate( + boost::function<bool()> fetch, + boost::function<VariableType(unsigned int)> get, + boost::function<unsigned int()> columns) + { + while (fetch()) { + auto v = new V; + container.push_back(v); + ObjectRowState<IceInternal::Handle<V>> rs; + const auto columnCount = columns(); + for (unsigned int c = 0; c < columnCount; c++) { + rs.fields[c] = get(c); + } + UnbindColumns<IceInternal::Handle<V>>(rs, v); + } + } + private: + T & container; +}; + +#endif + diff --git a/p2pvr/lib/containerIterator.h b/p2pvr/lib/containerIterator.h new file mode 100644 index 0000000..1c4e6bf --- /dev/null +++ b/p2pvr/lib/containerIterator.h @@ -0,0 +1,41 @@ +#ifndef CONTAINERITERATOR_H +#define CONTAINERITERATOR_H + +#include <iHaveSubTasks.h> +#include <boost/foreach.hpp> +#include "objectRowState.h" + +template <typename T> +class ContainerIterator : public IHaveSubTasks { + public: + template <typename ... Parents> + ContainerIterator(const T * con, const Parents & ... p) : + SourceObject(__PRETTY_FUNCTION__), + IHaveSubTasks(NULL), + binder(boost::bind(&BindColumns<typename T::value_type, Parents...>, _1, _2, p...)), + container(con) + { + } + void execute(ExecContext * ec) const + { + ObjectRowState<typename T::value_type> rs; + BOOST_FOREACH(const auto & i, *container) { + binder(rs, i); + rs.process(boost::bind(&ContainerIterator::executeChildren, this, ec)); + } + } + + private: + boost::function<void(RowState &, const typename T::value_type &)> binder; + const T * container; + + void executeChildren(ExecContext * ec) const + { + BOOST_FOREACH(const Tasks::value_type & sq, normal) { + sq->execute(ec); + } + } +}; + +#endif + diff --git a/p2pvr/lib/dvbsiHelpers.cpp b/p2pvr/lib/dvbsiHelpers.cpp new file mode 100644 index 0000000..3dcbdcc --- /dev/null +++ b/p2pvr/lib/dvbsiHelpers.cpp @@ -0,0 +1,190 @@ +#include "dvbsiHelpers.h" +#include "p2Helpers.h" + +template<> +void +CreateColumns<DVBSI::NetworkPtr>(const ColumnCreator & cc) +{ + cc("networkId", true); + cc("name", false); +} + +template<> +void +BindColumns(RowState & rs, const DVBSI::NetworkPtr & network) +{ + rs.fields[0] << network->NetworkId; + rs.fields[1] << network->Name; +} + +template<> +void +CreateColumns<DVBSI::NetworkTransportStreamPtr>(const ColumnCreator & cc) +{ + cc("transportStreamId", true); + cc("networkId", false); + cc("originalNetworkId", false); +} + +template<> +void +BindColumns(RowState & rs, const DVBSI::NetworkTransportStreamPtr & ts, const DVBSI::NetworkPtr & network) +{ + rs.fields[0] << ts->TransportStreamId; + rs.fields[1] << network->NetworkId; + rs.fields[2] << ts->OriginalNetworkId; +} + +template<> +void +CreateColumns<DVBSI::NetworkService>(const ColumnCreator & cc) +{ + cc("serviceId", true); + cc("type", false); + cc("transportStreamId", false); +} + +template<> +void +BindColumns(RowState & rs, const DVBSI::NetworkService & s, const DVBSI::NetworkTransportStreamPtr & ts) +{ + rs.fields[0] << s.ServiceId; + rs.fields[1] << s.ServiceType; + rs.fields[2] << ts->TransportStreamId; +} + +template<> +void +CreateColumns<DVBSI::ServicePtr>(const ColumnCreator & cc) +{ + cc("serviceId", true); + cc("transportStreamId", true); + cc("name", false); + cc("providerName", false); + cc("defaultAuthority", false); +} + +template<> +void +BindColumns(RowState & rs, const DVBSI::ServicePtr & s, const DVBSI::TransportStreamPtr & ts) +{ + rs.fields[0] << s->ServiceId; + rs.fields[1] << ts->TransportStreamId; + rs.fields[2] << s->Name; + rs.fields[4] << s->ProviderName; + rs.fields[4] << s->DefaultAuthority; +} + +template<> +void +CreateColumns<DVBSI::EventPtr>(const ColumnCreator & cc) +{ + cc("serviceId", true); + cc("eventId", true); + cc("title", false); + cc("titleLang", false); + cc("subtitle", false); + cc("description", false); + cc("descriptionLang", false); + cc("videoAspect", false); + cc("videoFrameRate", false); + cc("videoHd", false); + cc("audioChannels", false); + cc("audioLanguage", false); + cc("subtitleLanguage", false); + cc("category", false); + cc("subCategory", false); + cc("userCategory", false); + cc("dvbRating", false); + cc("startTime", false); + cc("stopTime", false); + cc("episode", false); + cc("episodes", false); + cc("year", false); + cc("flags", false); +} + +template<> +void +BindColumns(RowState & rs, const DVBSI::EventPtr & e) +{ + rs.fields[0] << e->ServiceId; + rs.fields[1] << e->EventId; + rs.fields[2] << e->Title; + rs.fields[3] << e->TitleLang; + rs.fields[4] << e->Subtitle; + rs.fields[5] << e->Description; + rs.fields[6] << e->DescriptionLang; + rs.fields[7] << e->VideoAspect; + rs.fields[8] << e->VideoFrameRate; + rs.fields[9] << e->VideoHD; + rs.fields[10] << e->AudioChannels; + rs.fields[11] << e->AudioLanguage; + rs.fields[12] << e->SubtitleLanguage; + rs.fields[13] << e->Category; + rs.fields[14] << e->SubCategory; + rs.fields[15] << e->UserCategory; + rs.fields[16] << e->DvbRating; + rs.fields[17] << e->StartTime; + rs.fields[18] << e->StopTime; + rs.fields[19] << e->Episode; + rs.fields[20] << e->Episodes; + rs.fields[21] << e->Year; + rs.fields[22] << e->Flags; +} + +template<> +void +CreateColumns<DVBSI::TerrestrialDeliveryPtr>(const ColumnCreator & cc) +{ + cc("frequency", false); + cc("transportStreamId", true); + cc("bandwidth", false); + cc("priority", false); + cc("timeSlicing", false); + cc("mpeFec", false); + cc("constellation", false); + cc("hierarchy", false); + cc("codeRateHP", false); + cc("codeRateLP", false); + cc("guardInterval", false); + cc("transmissionMode", false); + cc("otherFrequencyFlag", false); +} + +template<> +void +BindColumns(RowState & rs, const DVBSI::TerrestrialDeliveryPtr & s, const DVBSI::NetworkTransportStreamPtr & ts) +{ + rs.fields[0] << s->Frequency; + rs.fields[1] << ts->TransportStreamId; + rs.fields[2] << s->Bandwidth; + rs.fields[3] << s->Priority; + rs.fields[4] << s->TimeSlicing; + rs.fields[5] << s->MpeFec; + rs.fields[6] << s->Constellation; + rs.fields[7] << s->Hierarchy; + rs.fields[8] << s->CodeRateHP; + rs.fields[9] << s->CodeRateLP; + rs.fields[10] << s->GuardInterval; + rs.fields[11] << s->TransmissionMode; + rs.fields[12] << s->OtherFrequencyFlag; +} +template<> +void +UnbindColumns(RowState & rs, DVBSI::TerrestrialDeliveryPtr const & s) +{ + rs.fields[0] >> s->Frequency; + rs.fields[2] >> s->Bandwidth; + rs.fields[3] >> s->Priority; + rs.fields[4] >> s->TimeSlicing; + rs.fields[5] >> s->MpeFec; + rs.fields[6] >> s->Constellation; + rs.fields[7] >> s->Hierarchy; + rs.fields[8] >> s->CodeRateHP; + rs.fields[9] >> s->CodeRateLP; + rs.fields[10] >> s->GuardInterval; + rs.fields[11] >> s->TransmissionMode; + rs.fields[12] >> s->OtherFrequencyFlag; +} + diff --git a/p2pvr/lib/dvbsiHelpers.h b/p2pvr/lib/dvbsiHelpers.h new file mode 100644 index 0000000..49cb404 --- /dev/null +++ b/p2pvr/lib/dvbsiHelpers.h @@ -0,0 +1,60 @@ +#ifndef ICE_DVBSI_HELPERS_H +#define ICE_DVBSI_HELPERS_H + +#include <p2pvr.h> +#include "objectRowState.h" + +template<> +void +CreateColumns<DVBSI::NetworkPtr>(const ColumnCreator & cc); + +template<> +void +BindColumns(RowState & rs, const DVBSI::NetworkPtr & network); + +template<> +void +CreateColumns<DVBSI::NetworkTransportStreamPtr>(const ColumnCreator & cc); + +template<> +void +BindColumns(RowState & rs, const DVBSI::NetworkTransportStreamPtr & ts, const DVBSI::NetworkPtr & network); + +template<> +void +CreateColumns<DVBSI::NetworkService>(const ColumnCreator & cc); + +template<> +void +BindColumns(RowState & rs, const DVBSI::NetworkService & s, const DVBSI::NetworkTransportStreamPtr & ts); + +template<> +void +CreateColumns<DVBSI::ServicePtr>(const ColumnCreator & cc); + +template<> +void +BindColumns(RowState & rs, const DVBSI::ServicePtr & s, const DVBSI::TransportStreamPtr & ts); + +template<> +void +CreateColumns<DVBSI::EventPtr>(const ColumnCreator & cc); + +template<> +void +BindColumns(RowState & rs, const DVBSI::EventPtr & e); + +template<> +void +CreateColumns<DVBSI::TerrestrialDeliveryPtr>(const ColumnCreator & cc); + +template<> +void +BindColumns(RowState & rs, const DVBSI::TerrestrialDeliveryPtr & e, const DVBSI::TransportStreamPtr & ts); + +template<> +void +UnbindColumns(RowState & rs, const DVBSI::TerrestrialDeliveryPtr & s); + +#endif + diff --git a/p2pvr/lib/fileHandle.cpp b/p2pvr/lib/fileHandle.cpp new file mode 100644 index 0000000..08575b3 --- /dev/null +++ b/p2pvr/lib/fileHandle.cpp @@ -0,0 +1,27 @@ +#include "fileHandle.h" +#include <unistd.h> +#include <stdexcept> + +class InvalidFileHandle : public std::runtime_error { + public: + InvalidFileHandle() : std::runtime_error("Invalid file handle") { } +}; + +FileHandle::FileHandle(int f) : + fd(f) +{ + if (fd < 0) { + throw InvalidFileHandle(); + } +} + +FileHandle::~FileHandle() +{ + close(fd); +} + +FileHandle::operator int() const +{ + return fd; +} + diff --git a/p2pvr/lib/fileHandle.h b/p2pvr/lib/fileHandle.h new file mode 100644 index 0000000..3c8d45e --- /dev/null +++ b/p2pvr/lib/fileHandle.h @@ -0,0 +1,19 @@ +#ifndef FILEHANDLE_H +#define FILEHANDLE_H + +class FileHandle { + public: + FileHandle(int fd); + ~FileHandle(); + + FileHandle(const FileHandle &) = delete; + void operator=(const FileHandle &) = delete; + + operator int() const; + + private: + const int fd; +}; + +#endif + diff --git a/p2pvr/lib/frontend.cpp b/p2pvr/lib/frontend.cpp new file mode 100644 index 0000000..1044f6f --- /dev/null +++ b/p2pvr/lib/frontend.cpp @@ -0,0 +1,35 @@ +#include "frontend.h" +#include "tuner.h" +#include <logger.h> +#include <sys/ioctl.h> +#include <linux/dvb/frontend.h> + +Frontend::Frontend(Tuner * t, int fd, const struct dvb_frontend_info & i) : + tuner(t), + frontendFD(fd), + fe_info(i) +{ +} + +Frontend::~Frontend() +{ + close(frontendFD); +} + +const struct dvb_frontend_info & +Frontend::Info() const +{ + return fe_info; +} + +fe_status +Frontend::GetStatus() const +{ + fe_status_t status; + if (ioctl(frontendFD, FE_READ_STATUS, &status) < 0) { + Logger()->messagebf(LOG_ERR, "Reading frontend %s status failed (%s:%d)", tuner->Device(), strerror(errno), errno); + throw P2PVR::DeviceError(tuner->Device(), strerror(errno), errno); + } + return status; +} + diff --git a/p2pvr/lib/frontend.h b/p2pvr/lib/frontend.h new file mode 100644 index 0000000..994abfa --- /dev/null +++ b/p2pvr/lib/frontend.h @@ -0,0 +1,32 @@ +#ifndef P2PVR_FRONTEND_H +#define P2PVR_FRONTEND_H + +#include <linux/dvb/frontend.h> +#include <genLoader.h> +#include <p2pvr.h> + +class Tuner; + +class Frontend { + public: + typedef boost::function<bool(long)> OnFrequencyFound; + Frontend(Tuner *, int fd, const struct dvb_frontend_info &); + virtual ~Frontend(); + + fe_status_t GetStatus() const; + virtual void TuneTo(const DVBSI::DeliveryPtr &) const = 0; + virtual void FrequencyScan(const OnFrequencyFound & off) const = 0; + virtual std::string Type() const = 0; + const struct dvb_frontend_info & Info() const; + + protected: + const Tuner * tuner; + const int frontendFD; + const struct dvb_frontend_info fe_info; +}; + +typedef GenLoader<Frontend, fe_type, Tuner *, int, const struct dvb_frontend_info &> FrontendLoader; +typedef boost::shared_ptr<Frontend> FrontendPtr; + +#endif + diff --git a/p2pvr/lib/frontends/ofdm.cpp b/p2pvr/lib/frontends/ofdm.cpp new file mode 100644 index 0000000..8e2b23c --- /dev/null +++ b/p2pvr/lib/frontends/ofdm.cpp @@ -0,0 +1,145 @@ +#include "../frontend.h" +#include "../tuner.h" +#include <sys/ioctl.h> +#include <logger.h> +#include <linux/dvb/frontend.h> + +#define FREQ_OFFSET_MIN 0 +#define FREQ_OFFSET_MAX 4 + +class Frontend_OFDM : public Frontend { + public: + Frontend_OFDM(Tuner * t, int fd, const struct dvb_frontend_info & i) : Frontend(t, fd, i) { } + + void TuneTo(const DVBSI::DeliveryPtr & mp) const + { + auto td = DVBSI::TerrestrialDeliveryPtr::dynamicCast(mp); + if (!td) { + throw P2PVR::IncorrectDeliveryType(); + } + dvb_frontend_parameters feparams; + memset(&feparams, 0, sizeof(dvb_frontend_parameters)); + feparams.frequency = td->Frequency; + feparams.inversion = INVERSION_OFF; + feparams.u.ofdm.bandwidth = (fe_bandwidth)td->Bandwidth; + feparams.u.ofdm.code_rate_HP = (fe_code_rate_t)td->CodeRateHP; + feparams.u.ofdm.code_rate_LP = (fe_code_rate_t)td->CodeRateLP; + feparams.u.ofdm.constellation = (fe_modulation_t)td->Constellation; + feparams.u.ofdm.transmission_mode = (fe_transmit_mode)td->TransmissionMode; + feparams.u.ofdm.guard_interval = (fe_guard_interval_t)td->GuardInterval; + feparams.u.ofdm.hierarchy_information = (fe_hierarchy_t)td->Hierarchy; + SetParameters(feparams); + } + + dvb_frontend_parameters GetParameters() const + { + dvb_frontend_parameters feparams; + memset(&feparams, 0, sizeof(dvb_frontend_parameters)); + if (ioctl(frontendFD, FE_GET_FRONTEND, &feparams) < 0) { + Logger()->messagebf(LOG_ERR, "Reading frontend parameters failed (%s:%d)", tuner->Device(), strerror(errno), errno); + throw P2PVR::DeviceError(tuner->Device(), strerror(errno), errno); + } + return feparams; + } + + void SetParameters(const dvb_frontend_parameters & feparams) const + { + if (ioctl(frontendFD, FE_SET_FRONTEND, &feparams) < 0) { + Logger()->messagebf(LOG_ERR, "Tuning of device %s failed (%s:%d)", tuner->Device(), strerror(errno), errno); + throw P2PVR::DeviceError(tuner->Device(), strerror(errno), errno); + } + } + + std::string Type() const + { + return "OFDM (DVB-T)"; + } + + enum Country { DVBT_AU, DVBT_DE, DVBT_FR, DVBT_GB }; + + static uint32_t FrequencyForCountry(Country country, int channel) + { + switch (country) { + case DVBT_AU: //AUSTRALIA, 7MHz step list + switch (channel) { + case 5 ... 12: return 142500000; + case 21 ... 69: return 333500000; + } + case DVBT_DE: //GERMANY + case DVBT_FR: //FRANCE, +/- offset 166kHz & +offset 332kHz & +offset 498kHz + case DVBT_GB: //UNITED KINGDOM, +/- offset + switch (channel) { + case 5 ... 12: return 142500000; // VHF unused in FRANCE, skip those in offset loop + case 21 ... 69: return 306000000; + } + } + return 0; + } + static uint32_t FrequencyStepForCountry(Country country, int channel) + { + switch (country) { + case DVBT_AU: + return 7000000; // dvb-t australia, 7MHz step + case DVBT_DE: + case DVBT_FR: + case DVBT_GB: + switch (channel) { // dvb-t europe, 7MHz VHF ch5..12, all other 8MHz + case 5 ... 12: return 7000000; + case 21 ... 69: return 8000000; + } + } + return 0; + } + static uint32_t ChannelFrequencyForCountry(Country country, int channel, int) + { + return FrequencyForCountry(country, channel) + (channel * FrequencyStepForCountry(country, channel)); + } + + void FrequencyScan(const OnFrequencyFound & onFrequencyFound) const + { + struct dvb_frontend_parameters feparams; + memset(&feparams, 0, sizeof(dvb_frontend_parameters)); + feparams.inversion = (fe_info.caps & FE_CAN_INVERSION_AUTO ? INVERSION_AUTO : INVERSION_OFF); + feparams.u.ofdm.constellation = (fe_info.caps & FE_CAN_QAM_AUTO ? QAM_AUTO : QAM_64); + feparams.u.ofdm.hierarchy_information = HIERARCHY_NONE; + + for (int channel = 0; channel < 134; channel += 1) { + for (uint32_t offset = FREQ_OFFSET_MIN; offset <= 0/*FREQ_OFFSET_MAX*/; offset += 1) { + feparams.frequency = ChannelFrequencyForCountry(DVBT_GB, channel, offset); + if (feparams.frequency == 0) { + continue; + } + if (fe_info.frequency_min > feparams.frequency || fe_info.frequency_max < feparams.frequency) { + Logger()->messagebf(LOG_WARNING, "Channel %d, freq (%d Hz) outside card range", channel, feparams.frequency); + continue; + } + Logger()->messagebf(LOG_DEBUG, "Channel %d, Frequency %d Hz", channel, feparams.frequency); + SetParameters(feparams); + fe_status status; + // Wait for something + for (int x = 0; x < 150 && (status = GetStatus()) == 0; x += 100) { + usleep(1000); + } + // Was it useful? + if (!(status & (FE_HAS_SIGNAL | FE_HAS_CARRIER))) { + continue; + } + // Wait for lock + for (int x = 0; x < 500 && ((status = GetStatus()) & FE_HAS_LOCK) == 0; x += 100) { + usleep(10000); + } + // Did we get lock? + if (status & FE_HAS_LOCK) { + Logger()->messagebf(LOG_INFO, "Found multiplex at %d Hz", feparams.frequency); + Logger()->messagebf(LOG_DEBUG, "frequency %d", feparams.frequency); + if (onFrequencyFound(feparams.frequency)) { + return; + } + } + } + } + } +}; + +DECLARE_GENERIC_LOADER(FE_OFDM, FrontendLoader, Frontend_OFDM); + diff --git a/p2pvr/lib/globalDevices.cpp b/p2pvr/lib/globalDevices.cpp new file mode 100644 index 0000000..8dfe77d --- /dev/null +++ b/p2pvr/lib/globalDevices.cpp @@ -0,0 +1,59 @@ +#include "globalDevices.h" +#include <Ice/Ice.h> + +std::vector<std::string> GlobalDevices::Devices; + +DECLARE_OPTIONS(GlobalDevices, "P2PVR Devices") +("p2pvr.globaldevices.carddaemon", + Options::functions( + [](const VariableType & df) { Devices.push_back(df); }, + []{ Devices.clear(); }), + "ICE address of remote device pools (<adapter>:<endpoint>)") +END_OPTIONS(GlobalDevices); + +P2PVR::TunerPrx +GlobalDevices::GetTunerSpecific(const DVBSI::DeliveryPtr & delivery, Ice::Long until, const Ice::Current & ice) +{ + auto ic = ice.adapter->getCommunicator(); + BOOST_FOREACH(const auto & pool, Devices) { + auto poolprx = P2PVR::DevicesPrx::checkedCast(ic->stringToProxy(pool)); + auto tuner = poolprx->GetTunerSpecific(delivery, until); + if (tuner) return tuner; + } + return NULL; +} + +P2PVR::TunerPrx +GlobalDevices::GetTunerAny(short type, const DVBSI::DeliveryPtr & delivery, Ice::Long until, const Ice::Current & ice) +{ + auto ic = ice.adapter->getCommunicator(); + BOOST_FOREACH(const auto & pool, Devices) { + auto poolprx = P2PVR::DevicesPrx::checkedCast(ic->stringToProxy(pool)); + auto tuner = poolprx->GetTunerAny(type, delivery, until); + if (tuner) return tuner; + } + return NULL; +} + +P2PVR::PrivateTunerPrx +GlobalDevices::GetPrivateTuner(short type, Ice::Long until, const Ice::Current & ice) +{ + auto ic = ice.adapter->getCommunicator(); + BOOST_FOREACH(const auto & pool, Devices) { + auto poolprx = P2PVR::DevicesPrx::checkedCast(ic->stringToProxy(pool)); + auto tuner = poolprx->GetPrivateTuner(type, until); + if (tuner) return tuner; + } + return NULL; +} + +void +GlobalDevices::ReleaseTuner(const P2PVR::TunerPrx & tuner, const Ice::Current & ice) +{ + auto ic = ice.adapter->getCommunicator(); + BOOST_FOREACH(const auto & pool, Devices) { + auto poolprx = P2PVR::DevicesPrx::checkedCast(ic->stringToProxy(pool)); + poolprx->ReleaseTuner(tuner); + } +} + diff --git a/p2pvr/lib/globalDevices.h b/p2pvr/lib/globalDevices.h new file mode 100644 index 0000000..0cf9636 --- /dev/null +++ b/p2pvr/lib/globalDevices.h @@ -0,0 +1,24 @@ +#ifndef GLOBALDEVICES_H +#define GLOBALDEVICES_H + +// Global devices implements a device collection (P2PVR::Devices) for any devices known +// throughout the system through other Devices interfaces + +#include <p2pvr.h> +#include <options.h> + +class GlobalDevices : public P2PVR::Devices { + public: + P2PVR::TunerPrx GetTunerSpecific(const DVBSI::DeliveryPtr &, Ice::Long until, const Ice::Current &); + P2PVR::TunerPrx GetTunerAny(short type, const DVBSI::DeliveryPtr &, Ice::Long until, const Ice::Current &); + P2PVR::PrivateTunerPrx GetPrivateTuner(short type, Ice::Long until, const Ice::Current &); + void ReleaseTuner(const P2PVR::TunerPrx &, const Ice::Current &); + + INITOPTIONS; + private: + static std::vector<std::string> Devices; +}; + +#endif + + diff --git a/p2pvr/lib/localDevices.cpp b/p2pvr/lib/localDevices.cpp new file mode 100644 index 0000000..330271a --- /dev/null +++ b/p2pvr/lib/localDevices.cpp @@ -0,0 +1,151 @@ +#include "localDevices.h" +#include <Ice/Ice.h> +#include "tuner.h" +#include <logger.h> + +LocalDevices::Devices LocalDevices::devices; +std::mutex LocalDevices::lock; + +DECLARE_OPTIONS(LocalDevices, "P2PVR Devices") +("p2pvr.localdevices.frontend", + Options::functions( + [](const VariableType & df) { devices.insert(Devices::value_type(df.as<std::string>(), OpenTunerPtr())); }, + []{ devices.clear(); }), + "Frontend of DVB devices to use (/dev/dvb/adapterX/frontendY)") +END_OPTIONS(LocalDevices); + +P2PVR::TunerPrx +LocalDevices::GetTunerSpecific(const DVBSI::DeliveryPtr & delivery, Ice::Long until, const Ice::Current & ice) +{ + std::lock_guard<std::mutex> g(lock); + Logger()->messagebf(LOG_DEBUG, "%s: Searching for an open sharable tuner (frequency %d)", __PRETTY_FUNCTION__, delivery->Frequency); + auto openTuner = std::find_if(devices.begin(), devices.end(), [delivery](const Devices::value_type & ot) { + return ot.second && !ot.second->openedPrivate && ot.second->delivery && ot.second->delivery->Frequency == delivery->Frequency; + }); + if (openTuner != devices.end()) { + openTuner->second->until = std::max(openTuner->second->until, time(NULL) + until); + openTuner->second->clients += 1; + return openTuner->second->tuner; + } + + openTuner = std::find_if(devices.begin(), devices.end(), [](const Devices::value_type & ot) { return !ot.second; }); + if (openTuner == devices.end()) { + Logger()->messagebf(LOG_DEBUG, "%s: None suitable and none free (frequency %d)", + __PRETTY_FUNCTION__, delivery->Frequency); + return NULL; + } + + Logger()->messagebf(LOG_DEBUG, "%s: Opening a sharable tuner (frequency %d, frontend %s)", + __PRETTY_FUNCTION__, delivery->Frequency, openTuner->first); + auto tuner = P2PVR::PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(new Tuner(openTuner->first))); + openTuner->second = OpenTunerPtr(new OpenTuner(delivery, tuner, until, false)); + tuner->TuneTo(delivery); + + Logger()->messagebf(LOG_DEBUG, "%s: Tuned, returning (frequency %d, frontend %s)", + __PRETTY_FUNCTION__, delivery->Frequency, openTuner->first); + return tuner; +} + +P2PVR::TunerPrx +LocalDevices::GetTunerAny(short , const DVBSI::DeliveryPtr & delivery, Ice::Long until, const Ice::Current & ice) +{ + std::lock_guard<std::mutex> g(lock); + Logger()->messagebf(LOG_DEBUG, "%s: Searching for an open sharable tuner any frequency", __PRETTY_FUNCTION__); + auto openTuner = std::find_if(devices.begin(), devices.end(), [delivery](const Devices::value_type & ot) { + return ot.second && !ot.second->openedPrivate && ot.second->delivery; + }); + if (openTuner != devices.end()) { + openTuner->second->until = std::max(openTuner->second->until, time(NULL) + until); + openTuner->second->clients += 1; + return openTuner->second->tuner; + } + + openTuner = std::find_if(devices.begin(), devices.end(), [](const Devices::value_type & ot) { return !ot.second; }); + if (openTuner == devices.end()) { + Logger()->messagebf(LOG_DEBUG, "%s: None suitable and none free (frequency %d)", + __PRETTY_FUNCTION__, delivery->Frequency); + return NULL; + } + + Logger()->messagebf(LOG_DEBUG, "%s: Opening a sharable tuner (frequency %d, frontend %s)", + __PRETTY_FUNCTION__, delivery->Frequency, openTuner->first); + auto tuner = P2PVR::PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(new Tuner(openTuner->first))); + openTuner->second = OpenTunerPtr(new OpenTuner(delivery, tuner, until, false)); + tuner->TuneTo(delivery); + + Logger()->messagebf(LOG_DEBUG, "%s: Tuned, returning (frequency %d, frontend %s)", + __PRETTY_FUNCTION__, delivery->Frequency, openTuner->first); + return tuner; +} + +P2PVR::PrivateTunerPrx +LocalDevices::GetPrivateTuner(short , Ice::Long until, const Ice::Current & ice) +{ + std::lock_guard<std::mutex> g(lock); + Logger()->messagebf(LOG_DEBUG, "%s: Opening a private tuner", __PRETTY_FUNCTION__); + auto openTuner = std::find_if(devices.begin(), devices.end(), [](const Devices::value_type & ot) { return !ot.second; }); + if (openTuner == devices.end()) { + Logger()->messagebf(LOG_DEBUG, "%s: None free", __PRETTY_FUNCTION__); + return NULL; + } + + Logger()->messagebf(LOG_DEBUG, "%s: Opening a private tuner (frontend %s)", + __PRETTY_FUNCTION__, openTuner->first); + auto tuner = P2PVR::PrivateTunerPrx::checkedCast(ice.adapter->addWithUUID(new Tuner(openTuner->first))); + openTuner->second = OpenTunerPtr(new OpenTuner(NULL, tuner, until, true)); + + return tuner; +} + +void +LocalDevices::ReleaseTuner(const P2PVR::TunerPrx & tuner, const Ice::Current & ice) +{ + std::lock_guard<std::mutex> g(lock); + Logger()->messagebf(LOG_DEBUG, "%s", __PRETTY_FUNCTION__); + auto openTuner = std::find_if(devices.begin(), devices.end(), [tuner](const Devices::value_type & ot) { + return ot.second && ot.second->tuner == tuner; + }); + auto id = tuner->ice_getIdentity(); + if (ice.adapter->find(id)) { + ice.adapter->remove(id); + } + if (openTuner == devices.end()) { + Logger()->messagebf(LOG_DEBUG, "%s: Not one of mine", __PRETTY_FUNCTION__); + return; + } + Logger()->messagebf(LOG_DEBUG, "%s: Locally owned deivce %s", __PRETTY_FUNCTION__, openTuner->first); + openTuner->second->clients -= 1; + if (openTuner->second->clients == 0) { + openTuner->second.reset(); + } +} + +void +LocalDevices::Scan(const Ice::Current &) +{ + std::lock_guard<std::mutex> g(lock); +} + +void +LocalDevices::Add(const std::string & frontend, const Ice::Current &) +{ + std::lock_guard<std::mutex> g(lock); + devices.insert(Devices::value_type(frontend, OpenTunerPtr())); +} + +void +LocalDevices::Remove(const std::string & frontend, const Ice::Current &) +{ + std::lock_guard<std::mutex> g(lock); + devices.erase(frontend); +} + +LocalDevices::OpenTuner::OpenTuner(DVBSI::DeliveryPtr d, P2PVR::PrivateTunerPrx t, Ice::Long u, bool op) : + openedPrivate(op), + delivery(d), + tuner(t), + until(u), + clients(1) +{ +} + diff --git a/p2pvr/lib/localDevices.h b/p2pvr/lib/localDevices.h new file mode 100644 index 0000000..a16443c --- /dev/null +++ b/p2pvr/lib/localDevices.h @@ -0,0 +1,42 @@ +#ifndef LOCALDEVICES_H +#define LOCALDEVICES_H + +// Local devices implements a device collection (P2PVR::Devices) for any devices physically +// attached to the local machine; that is, can be accessed directly through /dev/dvb/adapterX + +#include <p2pvr.h> +#include <options.h> +#include <mutex> + +class LocalDevices : public P2PVR::LocalDevices { + public: + P2PVR::TunerPrx GetTunerSpecific(const DVBSI::DeliveryPtr &, Ice::Long until, const Ice::Current &); + P2PVR::TunerPrx GetTunerAny(short type, const DVBSI::DeliveryPtr &, Ice::Long until, const Ice::Current &); + P2PVR::PrivateTunerPrx GetPrivateTuner(short type, Ice::Long until, const Ice::Current &); + void ReleaseTuner(const P2PVR::TunerPrx &, const Ice::Current &); + + void Scan(const Ice::Current &); + void Add(const std::string & frontend, const Ice::Current &); + void Remove(const std::string & frontend, const Ice::Current &); + + INITOPTIONS; + private: + class OpenTuner { + public: + OpenTuner(DVBSI::DeliveryPtr, P2PVR::PrivateTunerPrx, Ice::Long, bool); + + const bool openedPrivate; + const DVBSI::DeliveryPtr delivery; + const P2PVR::PrivateTunerPrx tuner; + + Ice::Long until; + unsigned int clients; + }; + typedef boost::shared_ptr<OpenTuner> OpenTunerPtr; + typedef std::map<std::string, OpenTunerPtr> Devices; + static Devices devices; + static std::mutex lock; +}; + +#endif + diff --git a/p2pvr/lib/maintenance.cpp b/p2pvr/lib/maintenance.cpp new file mode 100644 index 0000000..71ddf60 --- /dev/null +++ b/p2pvr/lib/maintenance.cpp @@ -0,0 +1,288 @@ +#include "maintenance.h" +#include "siParsers/network.h" +#include "siParsers/event.h" +#include "siParsers/service.h" +#include <Ice/Ice.h> +#include <stdexcept> +#include <iomanip> +#include <logger.h> +#include <sqlMergeTask.h> +#include <commonObjects.h> +#include <commonHelpers.h> +#include "p2Helpers.h" +#include "dvbsiHelpers.h" +#include "containerIterator.h" +#include "singleIterator.h" +#include "temporaryIceAdapterObject.h" + +#include <linux/dvb/frontend.h> + +void +SqlMergeColumnsInserter(SqlMergeTask * merge, const std::string & name, bool key) +{ + merge->cols.insert(new SqlMergeTask::TargetColumn(name, key)); + if (key) { + merge->keys.insert(name); + } +} + +class SiNetworkInformationMerger : public SiNetworkInformationParser { + public: + SiNetworkInformationMerger(CommonObjects * co) : commonObjects(co) { } + + void HandleTable(DVBSI::NetworkPtr n) + { + Logger()->messagebf(LOG_DEBUG, "Network Id: %d Name: %s", n->NetworkId, *n->Name); + BOOST_FOREACH(const auto & ts, n->TransportStreams) { + Logger()->messagebf(LOG_DEBUG, "\tTransport Stream Id: %d Original Network Id: %d", ts->TransportStreamId, ts->OriginalNetworkId); + BOOST_FOREACH(const auto & s, ts->Services) { + Logger()->messagebf(LOG_DEBUG, "\t\tService Id: %d Service Type: %d", s.ServiceId, s.ServiceType); + } + if (ts->Terrestrial) { + Logger()->messagebf(LOG_DEBUG, "\t\tDVB-T: Frequency: %d", ts->Terrestrial->Frequency); + } + } + + SqlMergeTask mergeNetwork("postgres", "networks"); + CreateColumns<DVBSI::NetworkPtr>(boost::bind(SqlMergeColumnsInserter, &mergeNetwork, _1, _2)); + std::vector<DVBSI::NetworkPtr> networks = { n }; + mergeNetwork.sources.insert(new ContainerIterator<std::vector<DVBSI::NetworkPtr>>(&networks)); + mergeNetwork.loadComplete(commonObjects); + mergeNetwork.execute(NULL); + + SqlMergeTask mergeTransports("postgres", "transportstreams"); + CreateColumns<DVBSI::NetworkTransportStreamPtr>(boost::bind(SqlMergeColumnsInserter, &mergeTransports, _1, _2)); + mergeTransports.sources.insert(new ContainerIterator<DVBSI::NetworkTransportStreams>(&n->TransportStreams, n)); + mergeTransports.loadComplete(commonObjects); + mergeTransports.execute(NULL); + + SqlMergeTask mergeDvbt("postgres", "delivery_dvbt"); + CreateColumns<DVBSI::TerrestrialDeliveryPtr>(boost::bind(SqlMergeColumnsInserter, &mergeDvbt, _1, _2)); + BOOST_FOREACH(const auto & s, n->TransportStreams) { + if (s->Terrestrial) { + mergeDvbt.sources.insert(new SingleIterator<DVBSI::TerrestrialDeliveryPtr>(&s->Terrestrial, s)); + } + } + mergeDvbt.loadComplete(commonObjects); + mergeDvbt.execute(NULL); + + SqlMergeTask mergeServices("postgres", "services"); + CreateColumns<DVBSI::NetworkService>(boost::bind(SqlMergeColumnsInserter, &mergeServices, _1, _2)); + BOOST_FOREACH(const auto & s, n->TransportStreams) { + mergeServices.sources.insert(new ContainerIterator<DVBSI::NetworkServiceList>(&s->Services, s)); + } + mergeServices.loadComplete(commonObjects); + mergeServices.execute(NULL); + } + private: + CommonObjects * commonObjects; +}; + +class SiServicesMerger : public SiServicesParser { + public: + SiServicesMerger(CommonObjects * co) : commonObjects(co) { } + + void HandleTable(DVBSI::TransportStreamPtr ts) + { + Logger()->messagebf(LOG_DEBUG, "Transport Stream Id: %d Original Network Id: %s", ts->TransportStreamId, ts->OriginalNetworkId); + BOOST_FOREACH(const auto & s, ts->Services) { + Logger()->messagebf(LOG_DEBUG, "\tService Id: %d Name: %s Type: %d, Provider: %s, DefaultAuthority: %s, RunningStatus %d FreeCaMode %d", + s->ServiceId, (s->Name ? *s->Name : "?"), (s->Type ? *s->Type : -1), + (s->ProviderName ? *s->ProviderName : "?"), (s->DefaultAuthority ? *s->DefaultAuthority : "?"), + s->RunningStatus, s->FreeCaMode); + } + + SqlMergeTask mergeServices("postgres", "services"); + CreateColumns<DVBSI::ServicePtr>(boost::bind(SqlMergeColumnsInserter, &mergeServices, _1, _2)); + // Don't change the list of services available from the network + mergeServices.doDelete = VariableType(false); + mergeServices.doInsert = VariableType(false); + mergeServices.sources.insert(new ContainerIterator<DVBSI::ServiceList>(&ts->Services, ts)); + mergeServices.loadComplete(commonObjects); + mergeServices.execute(NULL); + } + + private: + CommonObjects * commonObjects; +}; + +class SiEventsHandler : public SiEpgParser { + public: + SiEventsHandler(const RowProcessorCallback & cb) : + callBack(cb) {} + + void HandleTable(DVBSI::EventPtr e) + { + Logger()->messagebf(LOG_DEBUG, "Service Id: %d Program Id: %d Title: %s Time: %s - %s", + e->ServiceId, e->EventId, e->Title, e->StartTime, e->StopTime); + BindColumns<DVBSI::EventPtr>(rowState, e); + rowState.process(callBack); + } + + private: + ObjectRowState<DVBSI::EventPtr> rowState; + const RowProcessorCallback callBack; +}; + +void +Maintenance::UpdateAll(const Ice::Current & ice) +{ + UpdateAll(FE_OFDM, ice); + UpdateAll(FE_QPSK, ice); + UpdateAll(FE_ATSC, ice); + UpdateAll(FE_QAM, ice); +} + +void +Maintenance::UpdateAll(short type, const Ice::Current & ice) +{ + UpdateTransports(type, ice); + UpdateServices(type, ice); + UpdateEvents(type, ice); +} + +void +Maintenance::UpdateTransports(short type, const Ice::Current & ice) +{ + auto ic = ice.adapter->getCommunicator(); + UpdateTransports(type, ic, ice.adapter); +} + +void +Maintenance::UpdateTransports(short type, Ice::CommunicatorPtr ic, Ice::ObjectAdapterPtr adapter) +{ + auto devs = P2PVR::DevicesPrx::checkedCast(adapter->createProxy(ic->stringToIdentity("GlobalDevices"))); + auto si = P2PVR::SIPrx::checkedCast(adapter->createProxy(ic->stringToIdentity("SI"))); + auto siparser = new SiNetworkInformationMerger(this); + TemporarayIceAdapterObject<P2PVR::RawDataClient> parser(adapter, siparser); + + if (!devs) { + throw std::runtime_error("bad proxy(s)"); + } + const auto transports = si->GetAllDeliveries(FE_OFDM); + // Attempt to just download fresh data + BOOST_FOREACH(const auto & transport, transports) { + P2PVR::TunerPrx tuner; + try { + tuner = devs->GetTunerAny(type, transport, time(NULL) + 300); + } + catch (...) { + Logger()->messagebf(LOG_WARNING, "%s: Failed to get a suitable tuner", __PRETTY_FUNCTION__); + continue; + } + if (!tuner) { + continue; + } + try { + tuner->SendNetworkInformation(parser); + devs->ReleaseTuner(tuner); + BOOST_FOREACH(const CommonObjects::DataSources::value_type & ds, CommonObjects::datasources) { + ds.second->commit(); + } + return; + } + catch (const std::exception & ex) { + Logger()->messagebf(LOG_WARNING, "%s: Failed to fetch network information: %s", __PRETTY_FUNCTION__, ex.what()); + devs->ReleaseTuner(tuner); + throw; + } + catch (...) { + Logger()->messagebf(LOG_WARNING, "%s: Failed to fetch network information", __PRETTY_FUNCTION__); + devs->ReleaseTuner(tuner); + throw; + } + } + // If we can't do that, do a complete scan + auto tuner = devs->GetPrivateTuner(type, time(NULL) + 300); + tuner->ScanAndSendNetworkInformation(parser); + devs->ReleaseTuner(tuner); +} + +void +Maintenance::UpdateServices(short type, const Ice::Current & ice) +{ + auto ic = ice.adapter->getCommunicator(); + auto devs = P2PVR::DevicesPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("GlobalDevices"))); + auto si = P2PVR::SIPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("SI"))); + + if (!devs || !si) { + throw std::runtime_error("bad proxy(s)"); + } + + auto siparser = new SiServicesMerger(this); + TemporarayIceAdapterObject<P2PVR::RawDataClient> parser(ice.adapter, siparser); + + const auto deliveries = si->GetAllDeliveries(type); + if (deliveries.empty()) { + throw std::runtime_error("no delivery methods"); + } + + Logger()->messagebf(LOG_DEBUG, "%s: Getting a tuner", __PRETTY_FUNCTION__); + auto tuner = devs->GetTunerAny(type, deliveries.front(), time(NULL) + 90); + Logger()->messagebf(LOG_DEBUG, "%s: Fetching service list", __PRETTY_FUNCTION__); + tuner->SendServiceDescriptions(parser); + Logger()->messagebf(LOG_INFO, "%s: Updated service list", __PRETTY_FUNCTION__); + devs->ReleaseTuner(tuner); + BOOST_FOREACH(const CommonObjects::DataSources::value_type & ds, CommonObjects::datasources) { + ds.second->commit(); + } +} + +class SiEventsMerger : public IHaveSubTasks { + public: + SiEventsMerger(short t, const Ice::Current & i) : + SourceObject(__PRETTY_FUNCTION__), + IHaveSubTasks(NULL), + type(t), + ice(i) { } + + void execute(ExecContext * ec) const + { + auto ic = ice.adapter->getCommunicator(); + auto devs = P2PVR::DevicesPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("GlobalDevices"))); + auto si = P2PVR::SIPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("SI"))); + + if (!devs || !si) { + throw std::runtime_error("bad proxy(s)"); + } + + TemporarayIceAdapterObject<P2PVR::RawDataClient> parser(ice.adapter, + new SiEventsHandler(boost::bind(&SiEventsMerger::executeChildren, this, ec))); + + const auto deliveries = si->GetAllDeliveries(type); + if (deliveries.empty()) { + throw std::runtime_error("no delivery methods"); + } + + Logger()->messagebf(LOG_DEBUG, "%s: Getting a tuner", __PRETTY_FUNCTION__); + auto tuner = devs->GetTunerAny(type, deliveries.front(), time(NULL) + 600); + Logger()->messagebf(LOG_DEBUG, "%s: Fetching events", __PRETTY_FUNCTION__); + tuner->SendEventInformation(parser); + devs->ReleaseTuner(tuner); + } + + private: + const short type; + const Ice::Current & ice; + + void executeChildren(ExecContext * ec) const + { + BOOST_FOREACH(const Tasks::value_type & sq, normal) { + sq->execute(ec); + } + } +}; + +void +Maintenance::UpdateEvents(short type, const Ice::Current & ice) +{ + SqlMergeTask mergeEvents("postgres", "events"); + CreateColumns<DVBSI::EventPtr>(boost::bind(SqlMergeColumnsInserter, &mergeEvents, _1, _2)); + mergeEvents.sources.insert(new SiEventsMerger(type, ice)); + mergeEvents.loadComplete(this); + mergeEvents.execute(NULL); + BOOST_FOREACH(const CommonObjects::DataSources::value_type & ds, CommonObjects::datasources) { + ds.second->commit(); + } + Logger()->messagebf(LOG_INFO, "%s: Updated events", __PRETTY_FUNCTION__); +} diff --git a/p2pvr/lib/maintenance.h b/p2pvr/lib/maintenance.h new file mode 100644 index 0000000..b3773cf --- /dev/null +++ b/p2pvr/lib/maintenance.h @@ -0,0 +1,18 @@ +#ifndef P2PVR_MAINTENANCE_H +#define P2PVR_MAINTENANCE_H + +#include <p2pvr.h> +#include <commonObjects.h> + +class Maintenance : public P2PVR::Maintenance, public virtual CommonObjects { + public: + void UpdateAll(const Ice::Current &); + void UpdateAll(short type, const Ice::Current &); + void UpdateTransports(short type, const Ice::Current &); + void UpdateTransports(short type, Ice::CommunicatorPtr, Ice::ObjectAdapterPtr); + void UpdateServices(short type, const Ice::Current &); + void UpdateEvents(short type, const Ice::Current &); +}; + +#endif + diff --git a/p2pvr/lib/objectRowState.h b/p2pvr/lib/objectRowState.h new file mode 100644 index 0000000..9d53d43 --- /dev/null +++ b/p2pvr/lib/objectRowState.h @@ -0,0 +1,43 @@ +#ifndef OBJECT_ROW_STATE_H +#define OBJECT_ROW_STATE_H + +#include <boost/function.hpp> +#include <string> +#include <rowSet.h> + +typedef boost::function<void(const std::string &, bool)> ColumnCreator; + +template <typename V, typename... Parents> +void BindColumns(RowState &, const V &, const Parents & ...); + +template <typename V> +void UnbindColumns(RowState &, const V &); + +template <typename V> +void CreateColumns(const ColumnCreator &); + +template <typename T> +class ObjectRowState : public RowState { + public: + ObjectRowState() : + columns(ColumnCreatorHelper()) + { + fields.resize(columns.size()); + } + const Columns & getColumns() const { return columns; } + + private: + Columns ColumnCreatorHelper() + { + int index = 0; + Columns columns; + CreateColumns<T>([&columns, &index](const std::string & name, bool) { + columns.insert(new Column(index++, name)); + }); + return columns; + } + Columns columns; +}; + +#endif + diff --git a/p2pvr/lib/p2Helpers.cpp b/p2pvr/lib/p2Helpers.cpp new file mode 100644 index 0000000..b564e3b --- /dev/null +++ b/p2pvr/lib/p2Helpers.cpp @@ -0,0 +1,18 @@ +#include "p2Helpers.h" + +template <> +VariableType & +operator<<<Common::DateTime>(VariableType & vt, const Common::DateTime & dt) +{ + vt = boost::posix_time::ptime(boost::gregorian::date(dt.Year, dt.Month, dt.Day), + boost::posix_time::time_duration(dt.Hour, dt.Minute, 0)); + return vt; +} + +template <> +VariableType & +operator>>(VariableType & vt, short int & v) +{ + v = (int)vt; + return vt; +} diff --git a/p2pvr/lib/p2Helpers.h b/p2pvr/lib/p2Helpers.h new file mode 100644 index 0000000..7f2f577 --- /dev/null +++ b/p2pvr/lib/p2Helpers.h @@ -0,0 +1,46 @@ +#ifndef ICE_P2_HELPERS_H +#define ICE_P2_HELPERS_H + +#include <variableType.h> +#include <p2pvr.h> + +template <typename T> +VariableType & +operator>>(VariableType & vt, T & v) +{ + v = vt; + return vt; +} + +template <> +VariableType & +operator>>(VariableType & vt, short int & v); + +template <typename T> +VariableType & +operator<<(VariableType & vt, const T & v) +{ + vt = v; + return vt; +} + +template <> +VariableType & +operator<<<Common::DateTime>(VariableType & vt, const Common::DateTime & dt); + +template <typename T> +VariableType & +operator<<(VariableType & vt, const IceUtil::Optional<T> & v) +{ + if (v) { + vt << *v; + } + else { + vt = Null(); + } + return vt; +} + + +#endif + diff --git a/p2pvr/lib/si.cpp b/p2pvr/lib/si.cpp new file mode 100644 index 0000000..45fa793 --- /dev/null +++ b/p2pvr/lib/si.cpp @@ -0,0 +1,33 @@ +#include "si.h" +#include "dvbsiHelpers.h" +#include "containerCreator.h" +#include <linux/dvb/frontend.h> +#include <rdbmsDataSource.h> +#include <sqlHandleAsVariableType.h> +#include <selectcommand.h> +#include <logger.h> + +typedef boost::shared_ptr<DB::SelectCommand> SelectPtr; + +P2PVR::Deliveries +SI::GetAllDeliveries(short type, const Ice::Current &) +{ + auto db = dataSource<RdbmsDataSource>("postgres"); + SelectPtr sel; + switch (type) { + case FE_OFDM: + sel = SelectPtr(db->getReadonly().newSelectCommand("SELECT * FROM delivery_dvbt")); + break; + } + Logger()->messagebf(LOG_DEBUG, "%s: ", __PRETTY_FUNCTION__); + P2PVR::Deliveries rtn; + ContainerCreator<P2PVR::Deliveries, DVBSI::TerrestrialDelivery> cc(rtn); + cc.populate(boost::bind(&DB::SelectCommand::fetch, sel), [sel](unsigned int c) { + HandleAsVariableType h; + const DB::Column & col = (*sel)[c]; + col.apply(h); + return h.variable; + }, boost::bind(&DB::SelectCommand::columnCount, sel)); + return rtn; +} + diff --git a/p2pvr/lib/si.h b/p2pvr/lib/si.h new file mode 100644 index 0000000..2740c8e --- /dev/null +++ b/p2pvr/lib/si.h @@ -0,0 +1,13 @@ +#ifndef P2PVR_SI_H +#define P2PVR_SI_H + +#include <p2pvr.h> +#include <commonObjects.h> + +class SI : public P2PVR::SI, public virtual CommonObjects { + public: + P2PVR::Deliveries GetAllDeliveries(short type, const Ice::Current&); +}; + +#endif + diff --git a/p2pvr/lib/siParsers/event.cpp b/p2pvr/lib/siParsers/event.cpp new file mode 100644 index 0000000..6e5446d --- /dev/null +++ b/p2pvr/lib/siParsers/event.cpp @@ -0,0 +1,250 @@ +#include <time.h> +#include <glibmm/regex.h> +#include <boost/regex.hpp> +#include <boost/date_time/posix_time/posix_time_types.hpp> +#include <boost/date_time/gregorian_calendar.hpp> +#include <boost/algorithm/string/predicate.hpp> +#include <boost/algorithm/string/trim.hpp> +#include <boost/bind.hpp> +#include <boost/foreach.hpp> +#include <boost/lexical_cast.hpp> +#include <boost/tuple/tuple_comparison.hpp> +#include "event.h" + +struct ShortEvent { + char lang_code[3]; + uint8_t event_name_length; + u_char data[]; +} __attribute__((packed)); + +struct Component { +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + u_char :4; + u_char stream_content :4; +#else + u_char stream_content :4; + u_char :4; +#endif + u_char component_type /*:8*/; + u_char component_tag /*:8*/; + char lang_code[3]; +} __attribute__((packed)); + +struct Content { +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + uint8_t content_nibble_level_1 :4; + uint8_t content_nibble_level_2 :4; +#else + uint8_t content_nibble_level_2 :4; + uint8_t content_nibble_level_1 :4; +#endif + uint8_t user_byte; +}; + +struct ParentalRating { + char country_code[3]; + uint8_t rating; +} __attribute__((packed)); + +struct EventDescriptor { + uint16_t EventId; + uint16_t mjd; + uint8_t start_time_h; + uint8_t start_time_m; + uint8_t start_time_s; + uint8_t duration_h; + uint8_t duration_m; + uint8_t duration_s; +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + u_char RunningStatus : 3; + u_char FreeCaMode : 1; + u_char descriptors_length_hi : 4; +#else + u_char descriptors_length_hi : 4; + u_char FreeCaMode : 1; + u_char RunningStatus : 3; +#endif + u_char descriptors_length_lo; + u_char data[]; +} __attribute__((packed)); + +static Glib::RefPtr<Glib::Regex> episodeRegex = Glib::Regex::create("(?:[ (]+|^)(?:\\w+ )?([0-9]+)(?: of |/)([0-9]+)[.)]+"); +static Glib::RefPtr<Glib::Regex> yearRegex = Glib::Regex::create("\\(([0-9]{4})[ )]+"); +static Glib::RefPtr<Glib::Regex> flagsRegex = Glib::Regex::create("[ []+([A-Z,]+)\\]"); + +void +SiEpgParser::parseDescriptor_ShortEvent(DVBSI::EventPtr current, const u_char * data) +{ + auto * evtdesc = reinterpret_cast<const struct ShortEvent *>(data); + StrPtr title, subtitle, desc; + + current->TitleLang = std::string(evtdesc->lang_code, 3); + + size_t evtlen = evtdesc->event_name_length; + if (evtlen) { + title = convert((const char *)evtdesc->data, evtlen); + } + + size_t dsclen = evtdesc->data[evtlen]; + if (dsclen) { + subtitle = convert((const char *)evtdesc->data + evtlen + 1, dsclen); + } + + if (subtitle) { + Glib::MatchInfo matches; + if (episodeRegex->match(*subtitle, matches)) { + current->Episode = boost::lexical_cast<int>(matches.fetch(1)); + current->Episodes = boost::lexical_cast<int>(matches.fetch(2)); + *subtitle = episodeRegex->replace_literal(*subtitle, 0, "", Glib::REGEX_MATCH_NOTEMPTY); + } + if (yearRegex->match(*subtitle, matches)) { + current->Year = boost::lexical_cast<int>(matches.fetch(1)); + *subtitle = yearRegex->replace_literal(*subtitle, 0, "", Glib::REGEX_MATCH_NOTEMPTY); + } + if (flagsRegex->match(*subtitle, matches)) { + current->Flags = matches.fetch(1); + *subtitle = yearRegex->replace_literal(*subtitle, 0, "", Glib::REGEX_MATCH_NOTEMPTY); + } + } + if (title && subtitle) { + if (boost::algorithm::ends_with(*title, "...") && boost::algorithm::starts_with(*subtitle, "...")) { + title->resize(title->length() - 3); + *title += " "; + size_t dot = subtitle->find('.', 4); + if (dot == Glib::ustring::npos) { + title->append(*subtitle, 3, subtitle->length() - 3); + } + else { + title->append(*subtitle, 3, dot - 3); + subtitle->erase(0, dot + 2); + } + } + size_t colon = subtitle->find(':'); + if (colon != Glib::ustring::npos) { + desc = StrPtr(new Glib::ustring(*subtitle, colon + 1, subtitle->length() - colon)); + subtitle->resize(colon); + } + else { + colon = title->find(':'); + desc = subtitle; + if (colon != Glib::ustring::npos) { + subtitle = StrPtr(new Glib::ustring(*title, colon + 1, title->length() - colon)); + title->resize(colon); + } + else { + subtitle.reset(); + } + } + } + if (title) { + boost::algorithm::trim_if(*title, isspace); + current->Title = *title; + } + if (subtitle) { + boost::algorithm::trim_if(*subtitle, isspace); + if (!subtitle->empty()) { + current->Subtitle = *subtitle; + } + } + if (desc) { + boost::algorithm::trim_if(*desc, isspace); + if (!desc->empty()) { + current->Description = *desc; + } + } +} + +void +SiEpgParser::parseDescriptor_Component(DVBSI::EventPtr current, const u_char * data) +{ + auto * dc = reinterpret_cast<const struct Component *>(data); + + switch (dc->stream_content) { + case 0x01: // Video Info + current->VideoHD = ((dc->component_type - 1) & 0x08) ? 1 : 0; + current->VideoFrameRate = ((dc->component_type - 1) & 0x04) ? 30 : 25; + current->VideoAspect = ((dc->component_type - 1) & 0x03); + break; + case 0x02: // Audio Info + current->AudioChannels = dc->component_type; + current->AudioLanguage = Glib::ustring(dc->lang_code, 3); + break; + case 0x03: // Teletext Info + current->SubtitleLanguage = Glib::ustring(dc->lang_code, 3); + break; + } +} + +void +SiEpgParser::parseDescriptor_Content(DVBSI::EventPtr current, const u_char * data) +{ + auto nc = reinterpret_cast<const Content *>(data); + current->Category = nc->content_nibble_level_1; + current->SubCategory = nc->content_nibble_level_2; + current->UserCategory = nc->user_byte; +} + +void +SiEpgParser::parseDescriptor_ParentalRating(DVBSI::EventPtr current, const u_char * data) +{ + auto * pr = reinterpret_cast<const ParentalRating *>(data); + switch (pr->rating) { + case 0x01 ... 0x0F: + current->DvbRating = pr->rating + 3; + break; + case 0x00: /*undefined*/ + case 0x10 ... 0xFF: /*broadcaster defined*/ + current->DvbRating = NULL; + break; + } +} + +bool +SiEpgParser::CheckTableId(u_char tableId) const +{ + return ((tableId >= 0x50 && tableId <= 0x5f) || (tableId >= 0x60 && tableId <= 0x6f)); +} + +void +SiEpgParser::HandleTable(DVBSI::EitInformationPtr) +{ +} + +Common::DateTime & +operator<<(Common::DateTime & dt, const boost::posix_time::ptime & pt) +{ + dt.Year = pt.date().year(); + dt.Month = pt.date().month(); + dt.Day = pt.date().day(); + dt.Hour = pt.time_of_day().hours(); + dt.Minute = pt.time_of_day().minutes(); + return dt; +} + +void +SiEpgParser::ParseSiTable(const EventInformation * eit, DVBSI::EitInformationPtr ei) +{ + ei->ServiceId = ntohs(eit->header.content_id); + ei->TransportStreamId = ntohs(eit->TransportStreamId); + ei->OriginalNetworkId = ntohs(eit->OriginalNetworkId); + LoopOver<EventDescriptor>(eit->data, HILO(eit->header.section_length) - 15, [this,ei](const EventDescriptor * ed) { + DVBSI::EventPtr e = new DVBSI::Event(); + e->EventId = ntohs(ed->EventId); + e->ServiceId = ei->ServiceId; + // <ew> + boost::gregorian::date startDate(boost::gregorian::gregorian_calendar::from_modjulian_day_number(ntohs(ed->mjd))); + boost::posix_time::ptime time(startDate); + time += boost::posix_time::time_duration(BcdCharToInt(ed->start_time_h), BcdCharToInt(ed->start_time_m), BcdCharToInt(ed->start_time_s)); + e->StartTime << time; + time += boost::posix_time::time_duration(BcdCharToInt(ed->duration_h), BcdCharToInt(ed->duration_m), BcdCharToInt(ed->duration_s)); + e->StopTime << time; + // </ew> + ParseDescriptors(ed->data, HILO(ed->descriptors_length), + 0x4d, boost::bind(&SiEpgParser::parseDescriptor_ShortEvent, e, _1), + 0x50, boost::bind(&SiEpgParser::parseDescriptor_Component, e, _1), + 0x54, boost::bind(&SiEpgParser::parseDescriptor_Content, e, _1), + 0x55, boost::bind(&SiEpgParser::parseDescriptor_ParentalRating, e, _1)); + HandleTable(e); + }); +} + diff --git a/p2pvr/lib/siParsers/event.h b/p2pvr/lib/siParsers/event.h new file mode 100644 index 0000000..0528d98 --- /dev/null +++ b/p2pvr/lib/siParsers/event.h @@ -0,0 +1,35 @@ +#ifndef EPGROWS_H +#define EPGROWS_H + +#include "table.h" +#include <p2pvr.h> + +struct EventInformation { + SiTableHeader header; + uint16_t TransportStreamId; + uint16_t OriginalNetworkId; + uint8_t SegmentLastSectionNumber; + uint8_t LastTableId; + u_char data[]; +} __attribute__((packed)); + +class SiEpgParser : public SiTableParser<EventInformation, DVBSI::EitInformationPtr, int> { + protected: + bool CheckTableId(u_char tableId) const; + int SectionNumberShift() const { return 3; } + uint8_t FirstTableId(const EventInformation * ei) { return (ei->header.tableid >= 0x60 ? 0x60 : 0x50); } + uint8_t LastTableId(const EventInformation * ei) { return ei->LastTableId; } + void ParseSiTable(const EventInformation * eit, DVBSI::EitInformationPtr); + void HandleTable(DVBSI::EitInformationPtr); + virtual void HandleTable(DVBSI::EventPtr) = 0; + + private: + static void parseStartTimeAndDuration(DVBSI::EventPtr, const u_char * data); + static void parseDescriptor_ShortEvent(DVBSI::EventPtr, const u_char * data); + static void parseDescriptor_Component(DVBSI::EventPtr, const u_char * data); + static void parseDescriptor_Content(DVBSI::EventPtr, const u_char * data); + static void parseDescriptor_ParentalRating(DVBSI::EventPtr, const u_char * data); +}; + +#endif + diff --git a/p2pvr/lib/siParsers/network.cpp b/p2pvr/lib/siParsers/network.cpp new file mode 100644 index 0000000..9f7434a --- /dev/null +++ b/p2pvr/lib/siParsers/network.cpp @@ -0,0 +1,219 @@ +#include "network.h" +#include <boost/bind.hpp> + +struct NetworkStreamsHeader { +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + u_char reserved1 :4; + u_char transport_stream_loop_length_hi :4; +#else + u_char transport_stream_loop_length_hi :4; + u_char reserved1 :4; +#endif + u_char transport_stream_loop_length_lo; + u_char data[]; +} __attribute__((packed)); + +struct TransportStream { + uint16_t transportStreamId; + uint16_t originalNetworkId; +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + u_char reserved1 :4; + u_char descriptors_length_hi :4; +#else + u_char descriptors_length_hi :4; + u_char reserved1 :4; +#endif + u_char descriptors_length_lo; + u_char data[]; +} __attribute__((packed)); + +struct TerrestrialDeliveryDescriptor { + uint32_t Frequency; +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + uint8_t Bandwidth : 3; + uint8_t Priority : 1; + uint8_t TimeSlicing : 1; + uint8_t MpeFec : 1; + uint8_t _reserved1 : 2; +#else + uint8_t _reserved1 : 2; + uint8_t MpeFec : 1; + uint8_t TimeSlicing : 1; + uint8_t Priority : 1; + uint8_t Bandwidth : 3; +#endif +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + uint8_t Constellation : 2; + uint8_t Hierarchy : 3; + uint8_t CodeRateHP : 3; +#else + uint8_t CodeRateHP : 3; + uint8_t Hierarchy : 3; + uint8_t Constellation : 2; +#endif +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + uint8_t CodeRateLP : 3; + uint8_t GuardInterval : 2; + uint8_t TransmissionMode : 2; + uint8_t OtherFrequencyFlag : 1; +#else + uint8_t OtherFrequencyFlag : 1; + uint8_t TransmissionMode : 2; + uint8_t GuardInterval : 2; + uint8_t CodeRateLP : 3; +#endif + uint32_t _reserved2; +} __attribute__((packed)); + +struct CableDeliveryDescriptor { + uint32_t Frequency; + uint8_t _reserved2; +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + uint8_t _reserved1 : 4; + uint8_t FecOuter : 4; +#else + uint8_t FecOuter : 4; + uint8_t _reserved1 : 4; +#endif + uint8_t Modulation; + uint8_t SymbolRate1; + uint8_t SymbolRate2; + uint8_t SymbolRate3; +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + uint8_t SymbolRate4 : 4; + uint8_t FecInner : 4; +#else + uint8_t FecInner : 4; + uint8_t SymbolRate4 : 4; +#endif +} __attribute__((packed)); + +struct SatelliteDeliveryDescriptor { + uint32_t Frequency; + uint16_t OrbitalPosition; +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + uint8_t WestEastFlag : 1; + uint8_t Polarization : 2; + uint8_t RollOff : 2; + uint8_t ModulationSystem : 1; + uint8_t ModulationType : 2; +#else + uint8_t ModulationType : 2; + uint8_t ModulationSystem : 1; + uint8_t RollOff : 2; + uint8_t Polarization : 2; + uint8_t WestEastFlag : 1; +#endif + uint8_t SymbolRate1; + uint8_t SymbolRate2; + uint8_t SymbolRate3; +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + uint8_t SymbolRate4 : 4; + uint8_t FecInner : 4; +#else + uint8_t FecInner : 4; + uint8_t SymbolRate4 : 4; +#endif +} __attribute__((packed)); + +struct ServiceListDescriptor { + uint16_t ServiceId; + uint8_t ServiceType; +} __attribute__((packed)); + +bool +SiNetworkInformationParser::CheckTableId(u_char tableId) const +{ + return (tableId == 0x40 || tableId == 0x041); +} + +void +SiNetworkInformationParser::ParseSiTable(const struct NetworkInformation * nit, DVBSI::NetworkPtr n) +{ + n->NetworkId = ntohs(nit->header.content_id); + auto nsh = ParseDescriptors<NetworkStreamsHeader>(nit->data, HILO(nit->network_descriptor_length), + 0x40, boost::bind(&SiNetworkInformationParser::parseDescriptor_NetworkName, n, _1, _2)); + LoopOver<TransportStream>(nsh->data, HILO(nsh->transport_stream_loop_length), [this,n](const TransportStream * ts) { + DVBSI::NetworkTransportStreamPtr nts = new DVBSI::NetworkTransportStream(); + nts->TransportStreamId = ntohs(ts->transportStreamId); + nts->OriginalNetworkId = ntohs(ts->originalNetworkId); + ParseDescriptors(ts->data, HILO(ts->descriptors_length), + 0x41, boost::bind(&SiNetworkInformationParser::parseDescriptor_ServiceList, nts, _1, _2), + 0x43, boost::bind(&SiNetworkInformationParser::parseDescriptor_SatelliteDelivery, nts, _1, _2), + 0x44, boost::bind(&SiNetworkInformationParser::parseDescriptor_CableDelivery, nts, _1, _2), + 0x5a, boost::bind(&SiNetworkInformationParser::parseDescriptor_TerrestrialDelivery, nts, _1, _2)); + n->TransportStreams.push_back(nts); + }); +} + +void +SiNetworkInformationParser::parseDescriptor_NetworkName(DVBSI::NetworkPtr n, const u_char * p, size_t len) +{ + n->Name = *convert((const char *)p, len); +} + +void +SiNetworkInformationParser::parseDescriptor_TerrestrialDelivery(DVBSI::NetworkTransportStreamPtr nts, const u_char * data, size_t len) +{ + assert(len == sizeof(TerrestrialDeliveryDescriptor)); + auto tdd = reinterpret_cast<const TerrestrialDeliveryDescriptor *>(data); + DVBSI::TerrestrialDeliveryPtr td = new DVBSI::TerrestrialDelivery; + td->Frequency = ((uint64_t)ntohl(tdd->Frequency)) * 10; + td->Bandwidth = tdd->Bandwidth; + td->Priority = tdd->Priority; + td->TimeSlicing = tdd->TimeSlicing; + td->MpeFec = tdd->MpeFec; + td->Constellation = tdd->Constellation; + td->Hierarchy = tdd->Hierarchy; + td->CodeRateHP = tdd->CodeRateHP; + td->CodeRateLP = tdd->CodeRateLP; + td->GuardInterval = tdd->GuardInterval; + td->TransmissionMode = tdd->TransmissionMode; + td->OtherFrequencyFlag = tdd->OtherFrequencyFlag; + nts->Terrestrial = td; +} + +void +SiNetworkInformationParser::parseDescriptor_CableDelivery(DVBSI::NetworkTransportStreamPtr nts, const u_char * data, size_t len) +{ + assert(len == sizeof(CableDeliveryDescriptor)); + auto cdd = reinterpret_cast<const CableDeliveryDescriptor *>(data); + DVBSI::CableDeliveryPtr cd = new DVBSI::CableDelivery; + cd->Frequency = ((uint64_t)ntohl(cdd->Frequency)) * 10; + cd->FecOuter = cdd->FecOuter; + cd->Modulation = cdd->Modulation; + cd->SymbolRate = HILO4(cdd->SymbolRate); + cd->FecInner = cdd->FecInner; + nts->Cable = cd; +} + +void +SiNetworkInformationParser::parseDescriptor_SatelliteDelivery(DVBSI::NetworkTransportStreamPtr nts, const u_char * data, size_t len) +{ + assert(len == sizeof(SatelliteDeliveryDescriptor)); + auto sdd = reinterpret_cast<const SatelliteDeliveryDescriptor *>(data); + DVBSI::SatelliteDeliveryPtr sd = new DVBSI::SatelliteDelivery; + sd->Frequency = ((uint64_t)ntohl(sdd->Frequency)) * 10; + sd->OrbitalPosition = ntohs(sdd->OrbitalPosition); + sd->WestEastFlag = sdd->WestEastFlag; + sd->Polarization = sdd->Polarization; + sd->RollOff = sdd->RollOff; + sd->ModulationSystem = sdd->ModulationSystem; + sd->ModulationType = sdd->ModulationType; + sd->SymbolRate = HILO4(sdd->SymbolRate); + sd->FecInner = sdd->FecInner; + nts->Satellite = sd; +} + +void +SiNetworkInformationParser::parseDescriptor_ServiceList(DVBSI::NetworkTransportStreamPtr nts, const u_char * data, size_t len) +{ + auto end = data + len; + while (data < end) { + auto d = reinterpret_cast<const ServiceListDescriptor *>(data); + nts->Services.push_back({ ntohs(d->ServiceId), d->ServiceType }); + data += sizeof(ServiceListDescriptor); + } +} + + diff --git a/p2pvr/lib/siParsers/network.h b/p2pvr/lib/siParsers/network.h new file mode 100644 index 0000000..6cf3b50 --- /dev/null +++ b/p2pvr/lib/siParsers/network.h @@ -0,0 +1,35 @@ +#ifndef NETWORKINFORMATIONPARSER_H +#define NETWORKINFORMATIONPARSER_H + +#include "table.h" +#include <p2pvr.h> + +struct NetworkInformation { + SiTableHeader header; +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + u_char reserved2 :4; + u_char network_descriptor_length_hi :4; +#else + u_char network_descriptor_length_hi :4; + u_char reserved2 :4; +#endif + u_char network_descriptor_length_lo /*:8*/; + u_char data[]; +} __attribute__((packed)); + +class SiNetworkInformationParser : public SiTableParser<NetworkInformation, DVBSI::NetworkPtr, u_char> { + protected: + bool CheckTableId(u_char tableId) const; + void ParseSiTable(const struct NetworkInformation * nit, DVBSI::NetworkPtr); + + private: + static void parseDescriptor_NetworkName(DVBSI::NetworkPtr, const u_char *data, size_t len); + static void parseDescriptor_ServiceList(DVBSI::NetworkTransportStreamPtr, const u_char *data, size_t len); + static void parseDescriptor_TerrestrialDelivery(DVBSI::NetworkTransportStreamPtr, const u_char *data, size_t len); + static void parseDescriptor_SatelliteDelivery(DVBSI::NetworkTransportStreamPtr, const u_char *data, size_t len); + static void parseDescriptor_CableDelivery(DVBSI::NetworkTransportStreamPtr, const u_char *data, size_t len); +}; + +#endif + + diff --git a/p2pvr/lib/siParsers/service.cpp b/p2pvr/lib/siParsers/service.cpp new file mode 100644 index 0000000..b8092af --- /dev/null +++ b/p2pvr/lib/siParsers/service.cpp @@ -0,0 +1,68 @@ +#include "service.h" +#include <boost/bind.hpp> + +struct ServiceDescriptor { + uint16_t ServiceId; +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + u_char _reserved1 : 6; + u_char EitSchedule : 1; + u_char EitPresentFollowing : 1; +#else + u_char EitPresentFollowing : 1; + u_char EitSchedule : 1; + u_char _reserved1 : 6; +#endif +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + u_char RunningStatus : 3; + u_char FreeCaMode : 1; + u_char descriptors_length_hi : 4; +#else + u_char descriptors_length_hi : 4; + u_char FreeCaMode : 1; + u_char RunningStatus : 3; +#endif + u_char descriptors_length_lo; + u_char data[]; +} __attribute__((packed)); + +bool +SiServicesParser::CheckTableId(u_char tableId) const +{ + return (tableId == 0x42 || tableId == 0x46); +} + +void +SiServicesParser::ParseSiTable(const TransportStreamDescriptor * tsd, DVBSI::TransportStreamPtr ts) +{ + ts->TransportStreamId = ntohs(tsd->header.content_id); + ts->OriginalNetworkId = ntohs(tsd->original_network_id); + LoopOver<ServiceDescriptor>(tsd->data, HILO(tsd->header.section_length) - 12, [this,ts](const ServiceDescriptor * sd) { + DVBSI::ServicePtr s = new DVBSI::Service(); + s->ServiceId = ntohs(sd->ServiceId); + s->EitSchedule = sd->EitSchedule; + s->EitPresentFollowing = sd->EitPresentFollowing; + s->RunningStatus = sd->RunningStatus; + s->FreeCaMode = sd->FreeCaMode; + ParseDescriptors(sd->data, HILO(sd->descriptors_length), + 0x48, boost::bind(&SiServicesParser::parseDescriptor_Service, s, _1, _2), + 0x73, boost::bind(&SiServicesParser::parseDescriptor_DefaultAuthority, s, _1, _2)); + ts->Services.push_back(s); + }); +} + +void +SiServicesParser::parseDescriptor_Service(DVBSI::ServicePtr s, const u_char * p, size_t) +{ + s->Type = p[0]; + if (p[1]) { + s->ProviderName = *convert((const char *)(p + 2), p[1]); + } + s->Name = *convert((const char *)(p + 3 + p[1]), p[2 + p[1]]); +} + +void +SiServicesParser::parseDescriptor_DefaultAuthority(DVBSI::ServicePtr s, const u_char * p, size_t len) +{ + s->DefaultAuthority = *convert((const char *)p, len); +} + diff --git a/p2pvr/lib/siParsers/service.h b/p2pvr/lib/siParsers/service.h new file mode 100644 index 0000000..65cdbdb --- /dev/null +++ b/p2pvr/lib/siParsers/service.h @@ -0,0 +1,25 @@ +#ifndef SERVICEROWS_H +#define SERVICEROWS_H + +#include "table.h" +#include <p2pvr.h> + +struct TransportStreamDescriptor { + SiTableHeader header; + uint16_t original_network_id; + uint8_t _reserved1; + u_char data[]; +} __attribute__((packed)); + +class SiServicesParser : public SiTableParser<TransportStreamDescriptor, DVBSI::TransportStreamPtr, int> { + protected: + bool CheckTableId(u_char tableId) const; + void ParseSiTable(const struct TransportStreamDescriptor * nit, DVBSI::TransportStreamPtr); + + private: + static void parseDescriptor_Service(DVBSI::ServicePtr, const u_char *data, size_t len); + static void parseDescriptor_DefaultAuthority(DVBSI::ServicePtr, const u_char *data, size_t len); +}; + +#endif + diff --git a/p2pvr/lib/siParsers/table.cpp b/p2pvr/lib/siParsers/table.cpp new file mode 100644 index 0000000..48efd0a --- /dev/null +++ b/p2pvr/lib/siParsers/table.cpp @@ -0,0 +1,76 @@ +#include "table.h" +#include <string.h> +#include <stdio.h> +#include <glibmm.h> +#include <exceptions.h> +#include <logger.h> + +SimpleMessageException(ErrorReadingData); +SimpleMessageException(TimeoutReadingData); +SimpleMessageException(DemuxOpenFailure); + +const std::string SiTableParserBase::ISO10646("ISO-10646"); +const std::string SiTableParserBase::EitEncoding("ISO6937"); +const std::string SiTableParserBase::UTF8("UTF8"); + +SiTableParserBase::SiTableParserBase() : + startTime(time(NULL)), + incomplete(0) +{ +} + +SiTableParserBase::~SiTableParserBase() +{ +} + +bool +SiTableParserBase::NewData(const P2PVR::Data & bytes, const Ice::Current&) +{ + //Logger()->messagebf(LOG_DEBUG, "%s: Got %d bytes", __PRETTY_FUNCTION__, bytes.size()); + return ParseInfoTable(&bytes.front(), bytes.size()); +} + +SiTableParserBase::StrPtr +SiTableParserBase::convert(const char * txt, size_t len) +{ + if (len == 0) { + return boost::shared_ptr<Glib::ustring>(new Glib::ustring()); + } + char enc[20]; + switch (*txt) { + default: + EitEncoding.copy(enc, EitEncoding.length()); + enc[EitEncoding.length()] = '\0'; + break; + case 0x01 ... 0x05: + snprintf(enc, sizeof(enc), "ISO-8859-%d\n", txt[0] + 4); + txt += 1; + len -= 1; + break; + case 0x10: + snprintf(enc, sizeof(enc), "ISO-8859-%02x%02x\n", txt[1], txt[2]); + txt += 3; + len -= 3; + break; + case 0x11: + ISO10646.copy(enc, ISO10646.length()); + enc[ISO10646.length()] = '\0'; + break; + case 0x1F: + // Values for the first byte of "0x00", "0x06" to "0x0F", and "0x12" to "0x1F" are reserved for future use. + //fprintf(stderr, "Reserved encoding: %02x\n", txt[0]); + //fprintf(stderr, "%d: %.*s\n", txt[1], len - 2, txt + 2); + case 0x06 ... 0x0F: + case 0x12 ... 0x1E: + case 0x00: // empty string + return boost::shared_ptr<Glib::ustring>(new Glib::ustring()); + } + size_t used = 0, newlen = 0; + GError * err = NULL; + boost::shared_ptr<gchar> utf8 = boost::shared_ptr<gchar>(g_convert(txt, len, "utf-8", enc, &used, &newlen, &err), g_free); + if (err) { + throw Glib::ConvertError(err); + } + return boost::shared_ptr<Glib::ustring>(new Glib::ustring(utf8.get())); +} + diff --git a/p2pvr/lib/siParsers/table.h b/p2pvr/lib/siParsers/table.h new file mode 100644 index 0000000..be40813 --- /dev/null +++ b/p2pvr/lib/siParsers/table.h @@ -0,0 +1,185 @@ +#ifndef DVBSIREADERHELPER_H +#define DVBSIREADERHELPER_H + +#include <glibmm/ustring.h> +#include <boost/shared_ptr.hpp> +#include <boost/function.hpp> +#include <boost/tuple/tuple.hpp> +#include <boost/tuple/tuple_comparison.hpp> +#include <arpa/inet.h> +#include <p2pvr.h> +#include <logger.h> + +typedef unsigned char u_char; + +#define HILO(x) (x##_hi << 8 | x##_lo) +#define HILO2(x) (x##1 << 8 | x##2) +#define HILO3(x) (x##1 << 16 | x##2 << 8 | x##3) +#define HILO4(x) (x##4 << 24 | x##2 << 16 | x##3 << 8 | x##4) +#define BcdCharToInt(x) (10*((x & 0xF0)>>4) + (x & 0xF)) + +class SiTableParserBase : public P2PVR::RawDataClient { + protected: + SiTableParserBase(); + virtual ~SiTableParserBase() = 0; + + typedef boost::shared_ptr<Glib::ustring> StrPtr; + + bool NewData(const P2PVR::Data & bytes, const Ice::Current&); + + static StrPtr convert(const char * txt, size_t len); + + static const std::string ISO10646; + static const std::string EitEncoding; + static const std::string UTF8; + protected: + virtual bool ParseInfoTable(const u_char * data, size_t len) = 0; + time_t startTime; + unsigned int incomplete; +}; + +struct SiTableHeaderBase { + uint8_t tableid; +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + u_char section_syntax_indicator :1; + u_char reserved2 :3; + u_char section_length_hi :4; +#else + u_char section_length_hi :4; + u_char reserved2 :3; + u_char section_syntax_indicator :1; +#endif + uint16_t section_length_lo :8; +} __attribute__((packed)); + +struct SiTableHeader : public SiTableHeaderBase { + uint16_t content_id; +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ + u_char reserved1 :2; + u_char version_number :5; + u_char current_next_indicator :1; +#else + u_char current_next_indicator :1; + u_char version_number :5; + u_char reserved1 :2; +#endif + uint8_t section_number; + uint8_t last_section_number; +} __attribute__((packed)); + +struct SiDescriptorHeader { + u_char tag; + u_char length; + u_char data[]; +} __attribute__((packed)); + +template <class TableType, class TargetType, class Key> +class SiTableParser : public SiTableParserBase { + protected: + typedef std::set<uint8_t> Sections; // Section numbers + typedef boost::tuple<uint8_t, Sections> TargetSections; // Last section number | Seen section numbers + typedef std::map<uint8_t, TargetSections> TableTargetSections; // TableID -> Needed references + typedef boost::tuple<TargetType, TableTargetSections> ContentType; // TemplateData | Needed references + typedef std::map<uint16_t, ContentType> Contents; // ContentID -> data + + virtual int SectionNumberShift() const { return 0; } + virtual uint8_t LastTableId(const TableType * t) { return t->header.tableid; } + virtual uint8_t FirstTableId(const TableType * t) { return t->header.tableid; } + + bool ParseInfoTable(const u_char * data, size_t len) + { + const u_char * dataEnd = data + len; + while (data < dataEnd) { + auto siTable = reinterpret_cast<const TableType *>(data); + if (siTable->header.current_next_indicator == 1 // current only, please. + && CheckTableId(siTable->header.tableid)) { // only tables we're interested in, please. + uint16_t contentId = ntohs(siTable->header.content_id); + ContentType & content = contents[contentId]; + uint8_t sectionNumber = siTable->header.section_number >> SectionNumberShift(); + TableTargetSections & targetTableSections = boost::get<1>(content); + TargetSections & targetSections = targetTableSections[siTable->header.tableid]; + boost::get<0>(targetSections) = siTable->header.last_section_number >> SectionNumberShift(); + Sections & seen = boost::get<1>(targetSections); + if (seen.find(sectionNumber) == seen.end()) { + auto & obj = boost::get<0>(content); + if (!obj) { + obj = new typename TargetType::element_type(); + incomplete += 1; + } + ParseSiTable(siTable, obj); + seen.insert(sectionNumber); + bool complete = true; + for (int tid = FirstTableId(siTable); tid <= LastTableId(siTable); tid += 1) { + TableTargetSections::const_iterator tts = targetTableSections.find(tid); + if (tts == targetTableSections.end()) { + complete = false; + break; + } + if (boost::get<1>(tts->second).size() <= boost::get<0>(tts->second)) { + complete = false; + break; + } + } + if (complete) { + HandleTable(obj); + obj = NULL; + incomplete -= 1; + } + } + } + data += HILO(siTable->header.section_length) + 4; + } + return ((incomplete == 0) && (startTime < (time(NULL) - 10))); + } + + static void ParseDescriptor(const SiDescriptorHeader * descriptor) + { + (void)descriptor; + // Logger()->messagef(LOG_DEBUG, "Dropped descriptor with tag 0x%02x", descriptor->tag); + return; + } + + template <typename ... OtherParers> + static void ParseDescriptor(const SiDescriptorHeader * descriptor, u_char tag, boost::function<void(const u_char *, size_t)> parser, OtherParers ... otherParers) + { + if (tag == descriptor->tag) { + parser(descriptor->data, descriptor->length); + } + else { + ParseDescriptor(descriptor, otherParers...); + } + } + + template <typename NextData = void, typename ... Parsers> + static const NextData * ParseDescriptors(const u_char * data, size_t len, Parsers ... parsers) + { + auto end = data + len; + while (data < end) { + auto descriptor = reinterpret_cast<const SiDescriptorHeader *>(data); + ParseDescriptor(descriptor, parsers...); + data += descriptor->length + 2; + } + return reinterpret_cast<const NextData *>(end); + } + + template<typename LoopContent> + static void LoopOver(const u_char * data, size_t len, boost::function<void(const LoopContent *)> parser) + { + auto end = data + len; + while (data < end) { + auto loopData = reinterpret_cast<const LoopContent *>(data); + parser(loopData); + data += HILO(loopData->descriptors_length) + (loopData->data - data); + } + } + + virtual bool CheckTableId(u_char tableId) const = 0; + virtual void ParseSiTable(const TableType *, TargetType) = 0; + virtual void HandleTable(TargetType table) = 0; + + private: + mutable Contents contents; +}; + +#endif + diff --git a/p2pvr/lib/singleIterator.h b/p2pvr/lib/singleIterator.h new file mode 100644 index 0000000..232ad91 --- /dev/null +++ b/p2pvr/lib/singleIterator.h @@ -0,0 +1,39 @@ +#ifndef SINGLEITERATOR_H +#define SINGLEITERATOR_H + +#include <iHaveSubTasks.h> +#include <boost/foreach.hpp> +#include "objectRowState.h" + +template <typename T> +class SingleIterator : public IHaveSubTasks { + public: + template <typename ... Parents> + SingleIterator(const T * i, const Parents & ... p) : + SourceObject(__PRETTY_FUNCTION__), + IHaveSubTasks(NULL), + binder(boost::bind(&BindColumns<T, Parents...>, _1, _2, p...)), + item(i) + { + } + void execute(ExecContext * ec) const + { + ObjectRowState<T> rs; + binder(rs, *item); + rs.process(boost::bind(&SingleIterator::executeChildren, this, ec)); + } + + private: + boost::function<void(RowState &, const T &)> binder; + const T * item; + + void executeChildren(ExecContext * ec) const + { + BOOST_FOREACH(const Tasks::value_type & sq, normal) { + sq->execute(ec); + } + } +}; + +#endif + diff --git a/p2pvr/lib/temporaryIceAdapterObject.h b/p2pvr/lib/temporaryIceAdapterObject.h new file mode 100644 index 0000000..db4b340 --- /dev/null +++ b/p2pvr/lib/temporaryIceAdapterObject.h @@ -0,0 +1,39 @@ +#ifndef TEMPORARYICEADAPTER_H +#define TEMPORARYICEADAPTER_H + +template <typename Object> +class TemporarayIceAdapterObject { + public: + TemporarayIceAdapterObject(Ice::ObjectAdapterPtr a, Object * object) : + adapter(a), + proxy(Object::ProxyType::checkedCast(adapter->addWithUUID(object))) + { + if (!proxy) { + } + } + + ~TemporarayIceAdapterObject() + { + adapter->remove(proxy->ice_getIdentity()); + } + + TemporarayIceAdapterObject(const TemporarayIceAdapterObject &) = delete; + void operator=(const TemporarayIceAdapterObject &) = delete; + + operator typename Object::ProxyType() const + { + return proxy; + } + + typename Object::ProxyType operator->() const + { + return proxy; + } + + private: + Ice::ObjectAdapterPtr adapter; + typename Object::ProxyType proxy; +}; + +#endif + diff --git a/p2pvr/lib/tuner.cpp b/p2pvr/lib/tuner.cpp new file mode 100644 index 0000000..e508152 --- /dev/null +++ b/p2pvr/lib/tuner.cpp @@ -0,0 +1,355 @@ +#include "tuner.h" +#include <fcntl.h> +#include <Ice/Ice.h> +#include <sys/ioctl.h> +#include <poll.h> +#include <logger.h> +#include <misc.h> +#include <plugable.h> +#include <linux/dvb/frontend.h> +#include <linux/dvb/dmx.h> +#include <boost/crc.hpp> +#include <boost/tuple/tuple.hpp> +#include "fileHandle.h" +#include "siParsers/table.h" + +class FrontendNotSupported : public NotSupported { + public: + FrontendNotSupported(fe_type t) : NotSupported(stringbf("Frontend not supported: %s", t)) + { } +}; + +Tuner::Tuner(const boost::filesystem::path & df) : + deviceFrontend(df), + deviceRoot(df.branch_path()), + timeout(20000), + backgroundThread(NULL) +{ + int fd = open(deviceFrontend.string().c_str(), O_RDWR); + if (fd < 0) { + throw P2PVR::DeviceError(deviceFrontend.string(), strerror(errno), errno); + } + try { + struct dvb_frontend_info fe_info; + if (ioctl(fd, FE_GET_INFO, &fe_info) < 0) { + throw P2PVR::DeviceError(deviceFrontend.string(), strerror(errno), errno); + } + frontend = FrontendPtr(FrontendLoader::createNew<FrontendNotSupported>(fe_info.type, this, fd, fe_info)); + } + catch (...) { + close(fd); + throw; + } + Logger()->messagebf(LOG_INFO, "%s: Attached to %s (%s, type %s)", __PRETTY_FUNCTION__, + deviceRoot, frontend->Info().name, frontend->Type()); +} + +Tuner::~Tuner() +{ + while (!backgroundClients.empty()) { + close(backgroundClients.begin()->first); + backgroundClients.erase(backgroundClients.begin()); + } + if (backgroundThread) { + backgroundThread->join(); + delete backgroundThread; + } +} + +void +Tuner::TuneTo(const DVBSI::DeliveryPtr & mp, const Ice::Current&) +{ + frontend->TuneTo(mp); +} + +int +Tuner::GetStatus(const Ice::Current &) +{ + return frontend->GetStatus(); +} + +std::string +Tuner::Device() const +{ + return deviceRoot.string(); +} + +int +Tuner::OpenDemux() const +{ + int demux = open((deviceRoot / "demux0").string().c_str(), O_RDWR | O_NONBLOCK); + if (demux < 0) { + throw P2PVR::DeviceError(deviceRoot.string(), strerror(errno), errno); + } + return demux; +} + +void +Tuner::ScanAndSendNetworkInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current & ice) +{ + frontend->FrequencyScan([this, &client, &ice](long) { + try { + SendNetworkInformation(client, ice); + return true; + } + catch (...) { + return false; + } + }); +} + +void +Tuner::SendNetworkInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current & ice) +{ + SendPID(0x10, client, ice); +} + +void +Tuner::SendBouquetAssociations(const P2PVR::RawDataClientPrx & client, const Ice::Current & ice) +{ + SendPID(0x11, client, ice); +} + +void +Tuner::SendServiceDescriptions(const P2PVR::RawDataClientPrx & client, const Ice::Current & ice) +{ + SendPID(0x11, client, ice); +} + +void +Tuner::SendEventInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current & ice) +{ + SendPID(0x12, client, ice); +} + +void +Tuner::SendPID(int pid, const P2PVR::RawDataClientPrx & client, const Ice::Current & ice) const +{ + Logger()->messagebf(LOG_DEBUG, "%s: pid = 0x%x", __PRETTY_FUNCTION__, pid); + + ice.con->createProxy(client->ice_getIdentity()); + FileHandle demux(OpenDemux()); + struct dmx_sct_filter_params sctFilterParams; + memset(&sctFilterParams, 0, sizeof(dmx_sct_filter_params)); + sctFilterParams.pid = pid; + sctFilterParams.flags = DMX_IMMEDIATE_START; + + if (ioctl(demux, DMX_SET_FILTER, &sctFilterParams) < 0) { + throw P2PVR::DeviceError("demux", strerror(errno), errno); + } + + ReadDemuxAndSend(demux, client); +} + +void +Tuner::ReadDemuxAndSend(int demux, const P2PVR::RawDataClientPrx & client) const +{ + Logger()->messagebf(LOG_DEBUG, "%s: begin", __PRETTY_FUNCTION__); + std::vector<Ice::AsyncResultPtr> asyncs; + struct pollfd ufd; + bool exitFlag = false; + do { + // Wait for data to appear + memset(&ufd, 0, sizeof(pollfd)); + ufd.fd = demux; + ufd.events = POLLIN; + if (poll(&ufd, 1, timeout) < 1) { + Logger()->messagebf(LOG_DEBUG, "%s: Timed out waiting for data", __PRETTY_FUNCTION__); + throw P2PVR::DeviceError("demux", "Timed out. Tuned to a multiplex?", 0); + } + + // Read it + P2PVR::Data buf(1 << 12); + int nr = read(demux, &buf.front(), buf.size()); + if (nr < 0) { + throw P2PVR::DeviceError("demux", strerror(errno), errno); + } + size_t n = nr; + buf.resize(n); + + // Verify it + if (n < sizeof(SiTableHeader)) { + Logger()->messagebf(LOG_WARNING, "Received data too small to be an SI table."); + } + auto * tab = (const SiTableHeader *)(&buf.front()); + size_t l = sizeof(SiTableHeaderBase) + HILO(tab->section_length); + if (n < l) { + Logger()->messagebf(LOG_WARNING, "Received data shorter than its defined length."); + continue; + } + if (n > l) { + Logger()->messagebf(LOG_WARNING, "Received data longer than its defined length."); + continue; + } + if (!crc32(buf)) { + Logger()->messagebf(LOG_WARNING, "Received data is corrupted (crc32 failed)."); + continue; + } + + asyncs.push_back(client->begin_NewData(buf)); + + asyncs.erase(std::remove_if(asyncs.begin(), asyncs.end(), [&exitFlag, &client](const Ice::AsyncResultPtr & a) { + if (a->isCompleted()) { + exitFlag = client->end_NewData(a); + return true; + } + return false; + }), asyncs.end()); + } while (!exitFlag); + BOOST_FOREACH(const auto & a, asyncs) { + client->end_NewData(a); + } + Logger()->messagebf(LOG_DEBUG, "%s: end", __PRETTY_FUNCTION__); +} + +int +Tuner::StartSendingTS(const P2PVR::PacketIds & pids, const P2PVR::RawDataClientPrx & client, const Ice::Current &) +{ + Logger()->message(LOG_DEBUG, __PRETTY_FUNCTION__); + if (pids.empty()) { + throw P2PVR::DeviceError("demux", "Packet Id list cannot be empty", 0); + } + + std::lock_guard<std::mutex> g(lock); + int demux = backgroundClients.insert(BackgroundClients::value_type(OpenDemux(), client)).first->first; + + struct dmx_pes_filter_params pesFilterParams; + memset(&pesFilterParams, 0, sizeof(struct dmx_pes_filter_params)); + Logger()->messagebf(LOG_ERR, "%s: DMX_SET_PES_FILTER for pid %d", __PRETTY_FUNCTION__, pids[0]); + pesFilterParams.pid = pids[0]; + pesFilterParams.input = DMX_IN_FRONTEND; + pesFilterParams.output = DMX_OUT_TSDEMUX_TAP; + pesFilterParams.pes_type = DMX_PES_OTHER; + pesFilterParams.flags = 0; + + if (ioctl(demux, DMX_SET_PES_FILTER, &pesFilterParams) < 0) { + backgroundClients.erase(demux); + Logger()->messagebf(LOG_ERR, "%s: DMX_SET_PES_FILTER failed (%d: %s)", __PRETTY_FUNCTION__, errno, strerror(errno)); + throw P2PVR::DeviceError("demux", strerror(errno), errno); + } + + for (unsigned int x = 1; x < pids.size(); x += 1) { + __u16 p = pids[x]; + Logger()->messagebf(LOG_ERR, "%s: DMX_ADD_PID for pid %d", __PRETTY_FUNCTION__, p); + if (ioctl(demux, DMX_ADD_PID, &p) < 0) { + backgroundClients.erase(demux); + Logger()->messagebf(LOG_ERR, "%s: DMX_ADD_PID failed (%d: %s)", __PRETTY_FUNCTION__, errno, strerror(errno)); + throw P2PVR::DeviceError("demux", strerror(errno), errno); + } + } + + if (ioctl(demux, DMX_START) < 0) { + backgroundClients.erase(demux); + Logger()->messagebf(LOG_ERR, "%s: DMX_START failed (%d: %s)", __PRETTY_FUNCTION__, errno, strerror(errno)); + throw P2PVR::DeviceError("demux", strerror(errno), errno); + } + + startSenderThread(); + return demux; +} + +void +Tuner::StopSendingTS(int handle, const Ice::Current &) +{ + Logger()->message(LOG_DEBUG, __PRETTY_FUNCTION__); + std::lock_guard<std::mutex> g(lock); + if (backgroundClients.find(handle) != backgroundClients.end()) { + close(handle); + backgroundClients.erase(handle); + } +} + +void +Tuner::startSenderThread() +{ + if (!backgroundThread) { + backgroundThread = new std::thread(&Tuner::senderThread, this); + } +} + +void +Tuner::senderThread() +{ + lock.lock(); + typedef boost::tuple<P2PVR::RawDataClientPrx, Ice::AsyncResultPtr, int> AsyncCall; + std::vector<AsyncCall> asyncs; + while (!backgroundClients.empty()) { + int n = backgroundClients.rbegin()->first + 1; + fd_set rfds; + FD_ZERO(&rfds); + BOOST_FOREACH(const auto & c, backgroundClients) { + FD_SET(c.first, &rfds); + } + lock.unlock(); + + struct timeval tv { 2, 0 }; + switch (select(n, &rfds, NULL, NULL, &tv)) { + case -1: // error + case 0: // nothing to read, but all is well + break; + default: + { // stuff to do + std::lock_guard<std::mutex> g(lock); + BOOST_FOREACH(const auto & c, backgroundClients) { + if (FD_ISSET(c.first, &rfds)) { + // Read it + P2PVR::Data buf(1 << 16); + int nr = read(c.first, &buf.front(), buf.size()); + if (nr < 0) { + close(c.first); + backgroundClients.erase(c.first); + break; // backgroundClients has changed, bailout and start again + } + size_t n = nr; + buf.resize(n); + // Send it + asyncs.push_back(AsyncCall(c.second, c.second->begin_NewData(buf), c.first)); + //c.second->NewData(buf); + } + } + } + break; + } + // Clean up finished async requests + asyncs.erase(std::remove_if(asyncs.begin(), asyncs.end(), [this](const AsyncCall & a) { + try { + if (a.get<1>()->isCompleted()) { + if (!a.get<0>()->end_NewData(a.get<1>())) { + close(a.get<2>()); + std::lock_guard<std::mutex> g(lock); + backgroundClients.erase(a.get<2>()); + } + return true; + } + return false; + } + catch (...) { + close(a.get<2>()); + std::lock_guard<std::mutex> g(lock); + backgroundClients.erase(a.get<2>()); + return true; + } + }), asyncs.end()); + lock.lock(); + } + Logger()->messagebf(LOG_DEBUG, "%s: Cleaning up", __PRETTY_FUNCTION__); + BOOST_FOREACH(const auto & a, asyncs) { + try { + a.get<0>()->end_NewData(a.get<1>()); + } + catch (...) { + } + } + backgroundThread = NULL; + Logger()->messagebf(LOG_DEBUG, "%s: Unlocking", __PRETTY_FUNCTION__); + lock.unlock(); +} + +bool +Tuner::crc32(const P2PVR::Data & buf) +{ + boost::crc_optimal<32, 0x0, 0xFFFFFFFF, 0x0, true, false> crc; + crc.process_bytes(&buf.front(), buf.size()); + return crc.checksum() == 0; +} + diff --git a/p2pvr/lib/tuner.h b/p2pvr/lib/tuner.h new file mode 100644 index 0000000..8111f1e --- /dev/null +++ b/p2pvr/lib/tuner.h @@ -0,0 +1,50 @@ +#ifndef P2PVR_TUNER_H +#define P2PVR_TUNER_H + +#include <p2pvr.h> +#include <boost/filesystem/path.hpp> +#include "frontend.h" +#include <map> +#include <thread> +#include <mutex> +#include <boost/bind.hpp> + +class Tuner : public P2PVR::PrivateTuner { + public: + Tuner(const boost::filesystem::path & deviceFrontend); + ~Tuner(); + + void TuneTo(const DVBSI::DeliveryPtr &, const Ice::Current&); + int GetStatus(const Ice::Current&); + std::string Device() const; + + void ScanAndSendNetworkInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current&); + void SendNetworkInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current&); + void SendBouquetAssociations(const P2PVR::RawDataClientPrx & client, const Ice::Current&); + void SendServiceDescriptions(const P2PVR::RawDataClientPrx & client, const Ice::Current&); + void SendEventInformation(const P2PVR::RawDataClientPrx & client, const Ice::Current&); + + int StartSendingTS(const P2PVR::PacketIds & pids, const P2PVR::RawDataClientPrx & client, const Ice::Current &); + void StopSendingTS(int handle, const Ice::Current &); + + private: + static bool crc32(const P2PVR::Data &); + int OpenDemux() const; + void SendPID(int pid, const P2PVR::RawDataClientPrx & client, const Ice::Current &) const; + void ReadDemuxAndSend(int fd, const P2PVR::RawDataClientPrx & client) const; + void startSenderThread(); + void senderThread(); + + const boost::filesystem::path deviceFrontend; + const boost::filesystem::path deviceRoot; + const int timeout; + typedef std::map<int, P2PVR::RawDataClientPrx> BackgroundClients; + BackgroundClients backgroundClients; + std::thread * backgroundThread; + std::mutex lock; + + FrontendPtr frontend; +}; + +#endif + diff --git a/p2pvr/scanner/Jamfile.jam b/p2pvr/scanner/Jamfile.jam deleted file mode 100644 index 768e86c..0000000 --- a/p2pvr/scanner/Jamfile.jam +++ /dev/null @@ -1,17 +0,0 @@ -alias glibmm : : : : - <cflags>"`pkg-config --cflags glibmm-2.4`" - <linkflags>"`pkg-config --libs glibmm-2.4`" - ; -project - : requirements - <variant>debug:<linkflags>-Wl,-z,defs <cflags>"-W -Wall -Werror -Wwrite-strings" - ; - -# Scanner - t -lib p2pvrscanner : - [ glob *.cpp ] - : - <library>../../project2/common//p2common - <library>glibmm - ; - diff --git a/p2pvr/scanner/dvbSiReaderHelper.cpp b/p2pvr/scanner/dvbSiReaderHelper.cpp deleted file mode 100644 index 88b025d..0000000 --- a/p2pvr/scanner/dvbSiReaderHelper.cpp +++ /dev/null @@ -1,133 +0,0 @@ -#include "dvbSiReaderHelper.h" -#include <errno.h> -#include <fcntl.h> -#include <string.h> -#include <stdio.h> -#include <glibmm.h> -#include <sys/poll.h> -#include "si_tables.h" -#include <boost/crc.hpp> - -SimpleMessageException(ErrorReadingData); -SimpleMessageException(TimeoutReadingData); -SimpleMessageException(DemuxOpenFailure); - -const std::string DvbSiParserHelper::ISO10646("ISO-10646"); -const std::string DvbSiParserHelper::EitEncoding("ISO6937"); -const std::string DvbSiParserHelper::UTF8("UTF8"); - -DvbSiReaderHelper::DvbSiReaderHelper(const ScriptNodePtr p) : - demux(p, "demux", "/dev/dvb/adapter0/demux0"), - timeout(p, "timeout", 10000), - fd_epg(0) -{ -} - -DvbSiReaderHelper::~DvbSiReaderHelper() -{ - closeInput(); -} - -void -DvbSiReaderHelper::openInput(ExecContext * ec) const -{ - if ((fd_epg = open(demux(ec), O_RDWR)) < 0) { - throw DemuxOpenFailure(strerror(errno)); - } - filterInput(fd_epg); -} - -void -DvbSiReaderHelper::closeInput() const -{ - if (fd_epg) { - close(fd_epg); - fd_epg = 0; - } -} - -DvbSiParserHelper::StrPtr -DvbSiParserHelper::convert(const char * txt, size_t len) -{ - if (len == 0) { - return boost::shared_ptr<Glib::ustring>(new Glib::ustring()); - } - char enc[20]; - switch (*txt) { - default: - EitEncoding.copy(enc, EitEncoding.length()); - enc[EitEncoding.length()] = '\0'; - break; - case 0x01 ... 0x05: - snprintf(enc, sizeof(enc), "ISO-8859-%d\n", txt[0] + 4); - txt += 1; - len -= 1; - break; - case 0x10: - snprintf(enc, sizeof(enc), "ISO-8859-%02x%02x\n", txt[1], txt[2]); - txt += 3; - len -= 3; - break; - case 0x11: - ISO10646.copy(enc, ISO10646.length()); - enc[ISO10646.length()] = '\0'; - break; - case 0x1F: - // Values for the first byte of "0x00", "0x06" to "0x0F", and "0x12" to "0x1F" are reserved for future use. - //fprintf(stderr, "Reserved encoding: %02x\n", txt[0]); - //fprintf(stderr, "%d: %.*s\n", txt[1], len - 2, txt + 2); - case 0x06 ... 0x0F: - case 0x12 ... 0x1E: - case 0x00: // empty string - return boost::shared_ptr<Glib::ustring>(new Glib::ustring()); - } - size_t used = 0, newlen = 0; - GError * err = NULL; - boost::shared_ptr<gchar> utf8 = boost::shared_ptr<gchar>(g_convert(txt, len, "utf-8", enc, &used, &newlen, &err), g_free); - if (err) { - throw Glib::ConvertError(err); - } - return boost::shared_ptr<Glib::ustring>(new Glib::ustring(utf8.get())); -} - -bool -_dvb_crc32(void * buf, size_t len) -{ - boost::crc_optimal<32, 0x0, 0xFFFFFFFF, 0x0, true, false> crc; - crc.process_bytes(buf, len); - return crc.checksum() == 0; -} - -void -DvbSiReaderHelper::readTables(const InfoTableParser & parseInfoTable) const -{ - u_char buf[1<<12]; - struct pollfd ufd; - memset(&ufd, 0, sizeof(pollfd)); - ufd.fd = fd_epg; - ufd.events = POLLIN; - size_t n; - int prtn = 0; - time_t lastuseful = time(NULL); - while (((prtn = poll(&ufd, 1, timeout(NULL))) == 1) && (n = read(fd_epg, buf, sizeof(buf)))) { - if (n < sizeof(struct si_tab)) - throw ErrorReadingData("Smaller that si_tab"); - struct si_tab *tab = (struct si_tab *)buf; - size_t l = sizeof(struct si_tab) + GetSectionLength(tab); - if (n < l) - throw ErrorReadingData("Smaller that section length"); - if (_dvb_crc32(buf, l)) { - if (parseInfoTable(buf, l)) { - time(&lastuseful); - } - else { - if (lastuseful < time(NULL) - 15) { - break; - } - } - } - } - if (prtn < 1) { - throw TimeoutReadingData("Tuned to a multiplex?"); - } -} diff --git a/p2pvr/scanner/dvbSiReaderHelper.h b/p2pvr/scanner/dvbSiReaderHelper.h deleted file mode 100644 index d0080f1..0000000 --- a/p2pvr/scanner/dvbSiReaderHelper.h +++ /dev/null @@ -1,40 +0,0 @@ -#ifndef DVBSIREADERHELPER_H -#define DVBSIREADERHELPER_H - -#include "scripts.h" -#include "variables.h" -#include <boost/function.hpp> - -class RowProcessor; - -class DvbSiReaderHelper { - public: - typedef boost::function<bool (const u_char *, size_t)> InfoTableParser; - - DvbSiReaderHelper(const ScriptNodePtr p); - ~DvbSiReaderHelper(); - - const Variable demux; - const Variable timeout; - - protected: - void openInput(ExecContext *) const; - virtual void filterInput(int fd) const = 0; - void readTables(const InfoTableParser &) const; - void closeInput() const; - - private: - mutable int fd_epg; -}; - -class DvbSiParserHelper { - protected: - typedef boost::shared_ptr<Glib::ustring> StrPtr; - static StrPtr convert(const char * txt, size_t len); - static const std::string ISO10646; - static const std::string EitEncoding; - static const std::string UTF8; -}; - -#endif - diff --git a/p2pvr/scanner/epgRows.cpp b/p2pvr/scanner/epgRows.cpp deleted file mode 100644 index e27769d..0000000 --- a/p2pvr/scanner/epgRows.cpp +++ /dev/null @@ -1,528 +0,0 @@ -/* - * tv_grab_dvb - dump dvb epg info in xmltv - * Version 0.2 - 20/04/2004 - First Public Release - * - * Copyright (C) 2004 Mark Bryars <dvb at darkskiez d0t co d0t uk> - * - * DVB code Mercilessly ripped off from dvddate - * dvbdate Copyright (C) Laurence Culhane 2002 <dvbdate@holmes.demon.co.uk> - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * 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 General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * Or, point your browser to http://www.gnu.org/copyleft/gpl.html - */ - -#include <stdio.h> -#include <stdlib.h> -#include <unistd.h> -#include <string.h> -#include <sys/ioctl.h> -#include <errno.h> -#include <stdint.h> -#include <time.h> -#include <glibmm/regex.h> -#include <boost/regex.hpp> -#include <boost/bind.hpp> -#include <boost/date_time/gregorian_calendar.hpp> -#include <boost/algorithm/string/predicate.hpp> -#include <boost/algorithm/string/trim.hpp> -#include <boost/foreach.hpp> -#include <boost/lexical_cast.hpp> - -#include <linux/dvb/dmx.h> -#include "si_tables.h" - -#include "rowProcessor.h" -#include "epgRows.h" -#include <boost/tuple/tuple_comparison.hpp> - -struct EpgProgram { - VariableType serviceID; - VariableType eventID; - VariableType title; - VariableType titleLang; - VariableType subtitle; - VariableType descLang; - VariableType desc1; - VariableType desc2; - VariableType desc3; - VariableType videoAspect; - VariableType videoFrameRate; - VariableType videoHD; - VariableType audioChannels; - VariableType language; - VariableType teletextSubtitleLang; - VariableType category; - VariableType dvbRating; - VariableType contentItemID; - VariableType contentSeriesID; - VariableType contentRecommendation; - VariableType startTime; - VariableType stopTime; - VariableType episode; - VariableType episodes; - VariableType year; - VariableType flags; -}; - -static Glib::ustring title("title"); -template <class C, class M> -const M & -getMember(M C::*t, C * p) { - return p->*t; -} -SimpleMessageException(NoSuchAttribute); - -void -EpgRows::loadComplete(const CommonObjects *) -{ -} - -EpgRowState::EpgRowState() : - current(NULL) -{ -} - -const Columns & -EpgRowState::getColumns() const -{ - return columns; -} - -#define returnAttr(name) if (attrName == #name) return boost::bind(getMember<EpgProgram, VariableType>, &EpgProgram::name, boost::ref(current)) -RowState::RowAttribute -EpgRowState::resolveAttr(const Glib::ustring & attrName) const { - returnAttr(serviceID); - returnAttr(eventID); - returnAttr(title); - returnAttr(titleLang); - returnAttr(subtitle); - returnAttr(descLang); - returnAttr(desc1); - returnAttr(desc2); - returnAttr(desc3); - returnAttr(videoAspect); - returnAttr(videoFrameRate); - returnAttr(videoHD); - returnAttr(audioChannels); - returnAttr(language); - returnAttr(teletextSubtitleLang); - returnAttr(category); - returnAttr(dvbRating); - returnAttr(contentItemID); - returnAttr(contentSeriesID); - returnAttr(contentRecommendation); - returnAttr(startTime); - returnAttr(stopTime); - returnAttr(episode); - returnAttr(episodes); - returnAttr(year); - returnAttr(flags); - throw NoSuchAttribute(attrName); -} - -DECLARE_LOADER("epgrows", EpgRows); - -EpgRows::EpgRows(const ScriptNodePtr p) : - RowSet(p), - DvbSiReaderHelper(p) -{ -} - -EpgRows::~EpgRows() -{ -} - -static int time_offset = 0; -static int chan_filter = 0; -static int chan_filter_mask = 0; -static Glib::RefPtr<Glib::Regex> episodeRegex = Glib::Regex::create("[ (]+(?:\\w+ )?([0-9]+)(?: of |/)([0-9]+)[.)]+"); -static Glib::RefPtr<Glib::Regex> yearRegex = Glib::Regex::create("\\(([0-9]{4})[ )]+"); -static Glib::RefPtr<Glib::Regex> flagsRegex = Glib::Regex::create("[ []+([A-Z,]+)\\]"); - -void -EpgRowState::parseEventDescription(const u_char * data, EpgProgram * current) const { - assert(GetDescriptorTag(data) == 0x4D); - const struct descr_short_event *evtdesc = reinterpret_cast<const struct descr_short_event *>(data); - - size_t evtlen = evtdesc->event_name_length; - StrPtr title, subtitle, desc; - if (evtlen) { - current->titleLang = Glib::ustring((const char *)&evtdesc->lang_code1, 3); - title = convert((const char *)evtdesc->data, evtlen); - } - - size_t dsclen = evtdesc->data[evtlen]; - if (dsclen) { - subtitle = convert((const char *)evtdesc->data + evtlen + 1, dsclen); - } - if (subtitle) { - Glib::MatchInfo matches; - if (episodeRegex->match(*subtitle, matches)) { - current->episode = boost::lexical_cast<int>(matches.fetch(1)); - current->episodes = boost::lexical_cast<int>(matches.fetch(2)); - *subtitle = episodeRegex->replace_literal(*subtitle, 0, "", Glib::REGEX_MATCH_NOTEMPTY); - } - if (yearRegex->match(*subtitle, matches)) { - current->year = boost::lexical_cast<int>(matches.fetch(1)); - *subtitle = yearRegex->replace_literal(*subtitle, 0, "", Glib::REGEX_MATCH_NOTEMPTY); - } - if (flagsRegex->match(*subtitle, matches)) { - current->flags = matches.fetch(1); - *subtitle = yearRegex->replace_literal(*subtitle, 0, "", Glib::REGEX_MATCH_NOTEMPTY); - } - } - if (title && subtitle) { - if (boost::algorithm::ends_with(*title, "...") && boost::algorithm::starts_with(*subtitle, "...")) { - title->resize(title->length() - 3); - *title += " "; - size_t dot = subtitle->find('.', 4); - if (dot == Glib::ustring::npos) { - title->append(*subtitle, 3, subtitle->length() - 3); - } - else { - title->append(*subtitle, 3, dot - 3); - subtitle->erase(0, dot + 2); - } - } - size_t colon = subtitle->find(':'); - if (colon != Glib::ustring::npos) { - desc = StrPtr(new Glib::ustring(*subtitle, colon + 1, subtitle->length() - colon)); - subtitle->resize(colon); - } - else { - colon = title->find(':'); - desc = subtitle; - if (colon != Glib::ustring::npos) { - subtitle = StrPtr(new Glib::ustring(*title, colon + 1, title->length() - colon)); - title->resize(colon); - } - else { - subtitle.reset(); - } - } - } - if (title) { - boost::algorithm::trim_if(*title, isspace); - current->title = *title; - } - if (subtitle) { - boost::algorithm::trim_if(*subtitle, isspace); - if (!subtitle->empty()) { - current->subtitle = *subtitle; - } - } - if (desc) { - boost::algorithm::trim_if(*desc, isspace); - if (!desc->empty()) { - current->desc1 = *desc; - } - } -} - -/* Parse 0x4E Extended Event Descriptor. {{{ */ -void -EpgRowState::parseLongEventDescription(const u_char * data, EpgProgram * current) const { - assert(GetDescriptorTag(data) == 0x4E); - const struct descr_extended_event *levt = reinterpret_cast<const struct descr_extended_event *>(data); - bool non_empty = (levt->descriptor_number || levt->last_descriptor_number || levt->length_of_items || levt->data[0]); - - if (non_empty && levt->descriptor_number == 0) { - current->descLang = Glib::ustring((const char *)&levt->lang_code1, 3); - - const u_char *p = reinterpret_cast<const u_char *>(&levt->data); -#ifndef NDEBUG - const void *data_end = data + DESCR_GEN_LEN + GetDescriptorLength(data); -#endif - while (p < levt->data + levt->length_of_items) { - const struct item_extended_event *name = reinterpret_cast<const struct item_extended_event *>(p); - size_t name_len = name->item_description_length; - assert(p + ITEM_EXTENDED_EVENT_LEN + name_len < data_end); - current->desc1 = *convert((const char *)name->data, name_len); - - p += ITEM_EXTENDED_EVENT_LEN + name_len; - - const struct item_extended_event *value = reinterpret_cast<const struct item_extended_event *>(p); - size_t value_len = value->item_description_length; - assert(p + ITEM_EXTENDED_EVENT_LEN + value_len < data_end); - current->desc2 = *convert((const char *)value->data, value_len); - - p += ITEM_EXTENDED_EVENT_LEN + value_len; - } - const struct item_extended_event *text = reinterpret_cast<const struct item_extended_event *>(p); - size_t len = text->item_description_length; - if (non_empty && len) { - current->desc3 = *convert((const char *)text->data, len); - } - - } -} /*}}}*/ - -/* Parse 0x50 Component Descriptor. {{{ - video is a flag, 1=> output the video information, 0=> output the - audio information. seen is a pointer to a counter to ensure we - only output the first one of each (XMLTV can't cope with more than - one) */ -void -EpgRowState::parseComponentDescription(const u_char * data, EpgProgram * current) const { - assert(GetDescriptorTag(data) == 0x50); - const struct descr_component *dc = reinterpret_cast<const struct descr_component *>(data); - - switch (dc->stream_content) { - case 0x01: // Video Info - current->videoHD = ((dc->component_type - 1) & 0x08) ? 1 : 0; - current->videoFrameRate = ((dc->component_type - 1) & 0x04) ? 30 : 25; - current->videoAspect = ((dc->component_type - 1) & 0x03); - break; - case 0x02: // Audio Info - current->audioChannels = dc->component_type; - current->language = Glib::ustring((const char *)&dc->lang_code1, 3); - break; - case 0x03: // Teletext Info - // FIXME: is there a suitable XMLTV output for this? - // if ((dc->component_type)&0x10) //subtitles - // if ((dc->component_type)&0x20) //subtitles for hard of hearing - current->teletextSubtitleLang = Glib::ustring((const char *)&dc->lang_code1, 3); - break; - // case 0x04: // AC3 info - } -} /*}}}*/ - -void -EpgRowState::parseContentDescription(const u_char * data, EpgProgram * current) const { - assert(GetDescriptorTag(data) == 0x54); - const struct descr_content * dc = reinterpret_cast<const struct descr_content *>(data); - for (const u_char * p = reinterpret_cast<const u_char*>(&dc->data); p < data + DESCR_GEN_LEN + dc->descriptor_length; p += NIBBLE_CONTENT_LEN) { - const struct nibble_content *nc = reinterpret_cast<const nibble_content *>(p); - int c1 = (nc->content_nibble_level_1 << 4) + nc->content_nibble_level_2; - // This is weird in the uk, they use user but not content, and almost the same values - current->category = c1 ? c1 : (nc->user_nibble_1 << 4) + nc->user_nibble_2; - } -} - -void -EpgRowState::parseRatingDescription(const u_char * data, EpgProgram * current) const { - assert(GetDescriptorTag(data) == 0x55); - const struct descr_parental_rating * pr = reinterpret_cast<const struct descr_parental_rating *>(data); - for (const u_char * p = reinterpret_cast<const u_char *>(&pr->data); p < data + DESCR_GEN_LEN + pr->descriptor_length; p += PARENTAL_RATING_ITEM_LEN) { - const struct parental_rating_item *pr = reinterpret_cast<const struct parental_rating_item *>(p); - switch (pr->rating) { - case 0x00: /*undefined*/ - break; - case 0x01 ... 0x0F: - current->dvbRating = pr->rating + 3; - break; - case 0x10 ... 0xFF: /*broadcaster defined*/ - break; - } - } -} - -int parsePrivateDataSpecifier(const u_char *data) { - assert(GetDescriptorTag(data) == 0x5F); - return GetPrivateDataSpecifier(data); -} - -/* Parse 0x76 Content Identifier Descriptor. {{{ */ -/* See ETSI TS 102 323, section 12 */ -void -EpgRowState::parseContentIdentifierDescription(const u_char * data, EpgProgram * current) const { - assert(GetDescriptorTag(data) == 0x76); - const struct descr_content_identifier *ci = reinterpret_cast<const struct descr_content_identifier *>(data); - for (const u_char * p = reinterpret_cast<const u_char *>(&ci->data); p < data + DESCR_GEN_LEN + ci->descriptor_length; p += DESCR_GEN_LEN + ci->descriptor_length) { - const struct descr_content_identifier_crid *crid = reinterpret_cast<const struct descr_content_identifier_crid *>(p); - - switch (crid->crid_location) - { - case 0x01: /* Carried in Content Identifier Table (CIT) */ - default: - break; - case 0x00: /* Carried explicitly within descriptor */ - struct descr_content_identifier_crid_local * crid_data = (descr_content_identifier_crid_local_t *)&crid->crid_ref_data; - size_t len = crid_data->crid_length; - switch (crid->crid_type) { - case 0x01: - case 0x31: - current->contentItemID = Glib::ustring((const char *)crid_data->crid_byte, len); - break; - case 0x02: - case 0x32: - current->contentSeriesID = Glib::ustring((const char *)crid_data->crid_byte, len); - break; - case 0x03: - case 0x33: - current->contentRecommendation = Glib::ustring((const char *)crid_data->crid_byte, len); - break; - } - break; - } - } -} /*}}}*/ - -/* Parse Descriptor. {{{ - * Tags should be output in this order: - -'title', 'sub-title', 'desc', 'credits', 'date', 'category', 'language', -'orig-language', 'length', 'icon', 'url', 'country', 'episode-num', -'video', 'audio', 'previously-shown', 'premiere', 'last-chance', -'new', 'subtitles', 'rating', 'star-rating' -*/ -void -EpgRowState::parseDescription(const u_char * data, size_t len, EpgProgram * current) const { - int pds = 0; - for (const u_char * p = data; p < data + len; p += DESCR_GEN_LEN + GetDescriptorLength(p)) { - const struct descr_gen *desc = reinterpret_cast<const struct descr_gen *>(p); - switch (GetDescriptorTag(desc)) { - case 0: - break; - case 0x4D: //short evt desc, [title] [sub-title] - // there can be multiple language versions of these - parseEventDescription(p, current); - break; - case 0x4E: //long evt descriptor [desc] - parseLongEventDescription(p, current); - break; - case 0x50: //component desc [language] [video] [audio] [subtitles] - parseComponentDescription(p, current); - break; - case 0x53: // CA Identifier Descriptor - break; - case 0x54: // content desc [category] - parseContentDescription(p, current); - break; - case 0x55: // Parental Rating Descriptor [rating] - parseRatingDescription(p, current); - break; - case 0x5f: // Private Data Specifier - pds = parsePrivateDataSpecifier(p); - break; - case 0x64: // Data broadcast desc - Text Desc for Data components - break; - case 0x69: // Programm Identification Label - break; - case 0x81: // TODO ??? - if (pds == 5) // ARD_ZDF_ORF - break; - case 0x82: // VPS (ARD, ZDF, ORF) - if (pds == 5) // ARD_ZDF_ORF - // TODO: <programme @vps-start="???"> - break; - case 0x4F: // Time Shifted Event - case 0x52: // Stream Identifier Descriptor - case 0x5E: // Multi Lingual Component Descriptor - case 0x83: // Logical Channel Descriptor (some kind of news-ticker on ARD-MHP-Data?) - case 0x84: // Preferred Name List Descriptor - case 0x85: // Preferred Name Identifier Descriptor - case 0x86: // Eacem Stream Identifier Descriptor - break; - case 0x76: // Content identifier descriptor - parseContentIdentifierDescription(p, current); - break; - default: - break; - } - } -} /*}}}*/ - -/* Check that program has at least a title as is required by xmltv.dtd. {{{ */ -static bool validateDescription(const u_char *data, size_t len) { - for (const u_char * p = data; p < data + len; p += DESCR_GEN_LEN + GetDescriptorLength(p)) { - const struct descr_gen *desc = reinterpret_cast<const struct descr_gen *>(p); - if (GetDescriptorTag(desc) == 0x4D) { - const struct descr_short_event *evtdesc = reinterpret_cast<const struct descr_short_event *>(p); - // make sure that title isn't empty - if (evtdesc->event_name_length) return true; - } - } - return false; -} /*}}}*/ - -bool -EpgRowState::parseInfoTable(const u_char *data, size_t len, const RowProcessorCallback & rp) { - const struct eit *e = reinterpret_cast<const struct eit *>(data); - - len -= 4; //remove CRC - - // For each event listing - bool found = false; - for (const u_char *p = reinterpret_cast<const u_char *>(&e->data); p < data + len; p += EIT_EVENT_LEN + GetEITDescriptorsLoopLength(p)) { - const struct eit_event *evt = reinterpret_cast<const struct eit_event *>(p); - SeenProgram sp(HILO(e->service_id), HILO(evt->event_id)); - if (seenPrograms.find(sp) != seenPrograms.end()) { - continue; - } - seenPrograms.insert(sp); - - // No program info at end! Just skip it - if (GetEITDescriptorsLoopLength(evt) == 0) { - continue; - } - - boost::gregorian::date startDate(boost::gregorian::gregorian_calendar::from_modjulian_day_number(HILO(evt->mjd))); - boost::posix_time::ptime startTime(startDate); - startTime += boost::posix_time::time_duration( - BcdCharToInt(evt->start_time_h) + time_offset, - BcdCharToInt(evt->start_time_m), - BcdCharToInt(evt->start_time_s)); - EpgProgram results; - current = &results; - results.startTime = startTime; - results.stopTime = startTime + boost::posix_time::time_duration( - BcdCharToInt(evt->duration_h), - BcdCharToInt(evt->duration_m), - BcdCharToInt(evt->duration_s)); - - // a program must have a title that isn't empty - if (!validateDescription(reinterpret_cast<const u_char *>(&evt->data), GetEITDescriptorsLoopLength(evt))) { - continue; - } - - - results.serviceID = HILO(e->service_id); - results.eventID = HILO(evt->event_id); - - parseDescription(reinterpret_cast<const u_char *>(&evt->data), GetEITDescriptorsLoopLength(evt), &results); - process(rp); - found = true; - } - return found; -} - -SimpleMessageException(DemuxSetFilterFailure); - -void -EpgRows::filterInput(int fd) const -{ - struct dmx_sct_filter_params sctFilterParams; - memset(&sctFilterParams, 0, sizeof(dmx_sct_filter_params)); - sctFilterParams.pid = 0x12; // EIT data - sctFilterParams.timeout = 0; - sctFilterParams.flags = DMX_IMMEDIATE_START; - sctFilterParams.filter.filter[0] = chan_filter; // 4e is now/next this multiplex, 4f others - sctFilterParams.filter.mask[0] = chan_filter_mask; - - if (ioctl(fd, DMX_SET_FILTER, &sctFilterParams) < 0) { - throw DemuxSetFilterFailure(strerror(errno)); - } -} - -void -EpgRows::execute(const Glib::ustring &, const RowProcessorCallback & rp, ExecContext * ec) const -{ - EpgRowState state; - openInput(ec); - readTables(boost::bind(&EpgRowState::parseInfoTable, &state, _1, _2, rp)); - closeInput(); -} - diff --git a/p2pvr/scanner/epgRows.h b/p2pvr/scanner/epgRows.h deleted file mode 100644 index 61c55ff..0000000 --- a/p2pvr/scanner/epgRows.h +++ /dev/null @@ -1,52 +0,0 @@ -#ifndef EPGROWS_H -#define EPGROWS_H - -#include "scripts.h" -#include "rowSet.h" -#include "variables.h" -#include "dvbSiReaderHelper.h" -#include <boost/tuple/tuple.hpp> - -class EpgProgram; - -class EpgRows : public RowSet, DvbSiReaderHelper { - public: - EpgRows(const ScriptNodePtr p); - ~EpgRows(); - - void execute(const Glib::ustring &, const RowProcessorCallback &, ExecContext *) const; - void loadComplete(const CommonObjects *); - - private: - void filterInput(int fd) const; -}; - -class EpgRowState : public RowState, DvbSiParserHelper { - public: - EpgRowState(); - const Columns & getColumns() const; - RowAttribute resolveAttr(const Glib::ustring & attrName) const; - - bool parseInfoTable(const u_char *data, size_t len, const RowProcessorCallback &); - - private: - void parseEventDescription(const u_char *data, EpgProgram * current) const; - void parseLongEventDescription(const u_char *data, EpgProgram * current) const; - void parseComponentDescription(const u_char *data, EpgProgram * current) const; - void parseContentDescription(const u_char *data, EpgProgram * current) const; - void parseRatingDescription(const u_char *data, EpgProgram * current) const; - void parseContentIdentifierDescription(const u_char *data, EpgProgram * current) const; - void parseDescription(const u_char * data, size_t len, EpgProgram * current) const; - - typedef boost::tuple<int, int> SeenProgram; - typedef std::set<SeenProgram> SeenPrograms; - SeenPrograms seenPrograms; - - Columns columns; - friend class EpgRows; - mutable EpgProgram * current; -}; - - -#endif - diff --git a/p2pvr/scanner/serviceRows.cpp b/p2pvr/scanner/serviceRows.cpp deleted file mode 100644 index e743858..0000000 --- a/p2pvr/scanner/serviceRows.cpp +++ /dev/null @@ -1,155 +0,0 @@ -#include <stdio.h> -#include <stdlib.h> -#include <unistd.h> -#include <string.h> -#include <sys/ioctl.h> -#include <errno.h> -#include <stdint.h> -#include <time.h> -#include <boost/bind.hpp> -#include <boost/date_time/gregorian_calendar.hpp> - -#include <linux/dvb/dmx.h> -#include "si_tables.h" - -#include "rowProcessor.h" -#include "serviceRows.h" - -class Service { - public: - VariableType serviceID; - VariableType name; - VariableType type; - VariableType providerName; - VariableType defaultAuthority; - VariableType transportID; -}; - -void -ServiceRows::loadComplete(const CommonObjects *) -{ -} - -ServiceRowState::ServiceRowState() : - current(NULL) -{ -} - -const Columns & -ServiceRowState::getColumns() const -{ - return columns; -} - -SimpleMessageException(NoSuchAttribute); -template <class C, class M> -const M & -getMember(M C::*t, C * p) { - return p->*t; -} -#define returnAttr(name) if (attrName == #name) return boost::bind(getMember<Service, VariableType>, &Service::name, boost::ref(current)) -RowState::RowAttribute -ServiceRowState::resolveAttr(const Glib::ustring & attrName) const { - returnAttr(serviceID); - returnAttr(name); - returnAttr(type); - returnAttr(providerName); - returnAttr(defaultAuthority); - returnAttr(transportID); - throw NoSuchAttribute(attrName); -} - -DECLARE_LOADER("servicerows", ServiceRows); - -ServiceRows::ServiceRows(const ScriptNodePtr e) : - RowSet(e), - DvbSiReaderHelper(e) -{ -} - -ServiceRows::~ServiceRows() -{ -} - -SimpleMessageException(DemuxSetFilterFailure); - -void -ServiceRows::filterInput(int fd) const -{ - struct dmx_sct_filter_params sctFilterParams; - memset(&sctFilterParams, 0, sizeof(dmx_sct_filter_params)); - sctFilterParams.pid = 0x11; // Service data - sctFilterParams.timeout = 0; - sctFilterParams.flags = DMX_IMMEDIATE_START; - - if (ioctl(fd, DMX_SET_FILTER, &sctFilterParams) < 0) { - throw DemuxSetFilterFailure(strerror(errno)); - } -} - -void -ServiceRows::execute(const Glib::ustring &, const RowProcessorCallback & rp, ExecContext * ec) const -{ - ServiceRowState state; - openInput(ec); - readTables(boost::bind(&ServiceRowState::parseInfoTable, &state, _1, _2, rp)); - closeInput(); -} - -bool -ServiceRowState::parseInfoTable(const u_char * data, size_t len, const RowProcessorCallback & rp) { - const struct sit *e = reinterpret_cast<const struct sit *>(data); - assert(e->tableid == 0x42 || e->tableid == 0x46); - len -= 4; //remove CRC - - // For each event listing - bool found = false; - for (const u_char * p = e->serviceData; p < data + len; ) { - const struct si * sid = reinterpret_cast<const struct si *>(p); - int sID = be16toh(sid->serviceid); - bool seen = (seenServices.find(sID) != seenServices.end()); - size_t dll = HILO(sid->desc_loop_len); - Service serv; - current = &serv; - for (p = sid->descData; p < sid->descData + dll; p += DESCR_GEN_LEN + GetDescriptorLength(p)) { - if (!seen) { - serv.serviceID = sID; - serv.transportID = be16toh(e->transport_stream_id); - const struct descr_gen *desc = reinterpret_cast<const struct descr_gen *>(p); - switch (GetDescriptorTag(desc)) { - case 0x48: // Service descriptor - parseServiceDescriptor(p, GetDescriptorLength(desc), &serv); - break; - case 0x73: // Service authority descriptor - parseServiceAuthDescriptor(p, GetDescriptorLength(desc), &serv); - break; - default: - break; - } - } - } - if (!seen) { - found = true; - seenServices.insert(sID); - process(rp); - } - } - return found; -} - -void -ServiceRowState::parseServiceDescriptor(const u_char * p, size_t, Service * current) const -{ - current->type = p[2]; - if (p[3]) { - current->providerName = *convert((const char *)(p + 4), p[3]); - } - current->name = *convert((const char *)(p + 5 + p[3]), p[4 + p[3]]); -} - -void -ServiceRowState::parseServiceAuthDescriptor(const u_char * p, size_t len, Service * current) const -{ - current->defaultAuthority = *convert((const char *)(p + 2), len); -} - diff --git a/p2pvr/scanner/serviceRows.h b/p2pvr/scanner/serviceRows.h deleted file mode 100644 index 36cbee7..0000000 --- a/p2pvr/scanner/serviceRows.h +++ /dev/null @@ -1,43 +0,0 @@ -#ifndef SERVICEROWS_H -#define SERVICEROWS_H - -#include "scripts.h" -#include "rowSet.h" -#include "variables.h" -#include "dvbSiReaderHelper.h" - -class Service; - -class ServiceRows : public RowSet, DvbSiReaderHelper { - public: - ServiceRows(const ScriptNodePtr p); - ~ServiceRows(); - - void execute(const Glib::ustring &, const RowProcessorCallback &, ExecContext *) const; - void loadComplete(const CommonObjects *); - - private: - void filterInput(int fd) const; -}; - -class ServiceRowState : public RowState, DvbSiParserHelper { - public: - ServiceRowState(); - const Columns & getColumns() const; - RowAttribute resolveAttr(const Glib::ustring & attrName) const; - bool parseInfoTable(const u_char *data, size_t len, const RowProcessorCallback &); - - private: - void parseServiceDescriptor(const u_char *data, size_t len, Service * current) const; - void parseServiceAuthDescriptor(const u_char *data, size_t len, Service * current) const; - - typedef std::set<int> SeenServices; - SeenServices seenServices; - - Columns columns; - friend class ServiceRows; - mutable Service * current; -}; - -#endif - diff --git a/p2pvr/scanner/si_tables.h b/p2pvr/scanner/si_tables.h deleted file mode 100644 index c48fdae..0000000 --- a/p2pvr/scanner/si_tables.h +++ /dev/null @@ -1,1667 +0,0 @@ -////////////////////////////////////////////////////////////// -/// /// -/// si_tables.h: definitions for data structures of the /// -/// incoming SI data stream /// -/// /// -////////////////////////////////////////////////////////////// - -// $Revision: 84 $ -// $Date: 2010-03-05 17:46:16 +0000 (Fri, 05 Mar 2010) $ -// $Author: cpaton $ -// -// (C) 2001-03 Rolf Hakenes <hakenes@hippomi.de>, under the -// GNU GPL with contribution of Oleg Assovski, -// www.satmania.com -// -// libsi is free software; you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation; either version 2, or (at your option) -// any later version. -// -// libsi 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 General Public License for more details. -// -// You may have received a copy of the GNU General Public License -// along with libsi; see the file COPYING. If not, write to the -// Free Software Foundation, Inc., 59 Temple Place - Suite 330, -// Boston, MA 02111-1307, USA. - -#include <stdint.h> - -#define HILO(x) (x##_hi << 8 | x##_lo) -#define HILO2(x) (x##1 << 8 | x##2) -#define HILO3(x) (x##1 << 16 | x##2 << 8 | x##3) -#define HILO4(x) (x##4 << 24 | x##2 << 16 | x##3 << 8 | x##4) - -#define MjdToEpochTime(x) ((HILO(x)-40587)*86400) -#define BcdTimeToSeconds(x) ((3600 * ((10*((x##_h & 0xF0)>>4)) + (x##_h & 0xF))) + \ - (60 * ((10*((x##_m & 0xF0)>>4)) + (x##_m & 0xF))) + \ - ((10*((x##_s & 0xF0)>>4)) + (x##_s & 0xF))) -#define BcdTimeToMinutes(x) ((60 * ((10*((x##_h & 0xF0)>>4)) + (x##_h & 0xF))) + \ - (((10*((x##_m & 0xF0)>>4)) + (x##_m & 0xF)))) -#define BcdCharToInt(x) (10*((x & 0xF0)>>4) + (x & 0xF)) -#define CheckBcdChar(x) ((((x & 0xF0)>>4) <= 9) && \ - ((x & 0x0F) <= 9)) -#define CheckBcdSignedChar(x) ((((x & 0xF0)>>4) >= 0) && (((x & 0xF0)>>4) <= 9) && \ - ((x & 0x0F) >= 0) && ((x & 0x0F) <= 9)) - -#define GetTableId(x) (((si_tab_t *)(x))->table_id) -#define GetSectionLength(x) HILO(((si_tab_t *)(x))->section_length) -typedef struct si_tab { - u_char table_id /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char section_syntax_indicator :1; - u_char dummy :1; // has to be 0 - u_char :2; - u_char section_length_hi :4; -#else - u_char section_length_hi :4; - u_char :2; - u_char dummy :1; // has to be 0 - u_char section_syntax_indicator :1; -#endif - u_char section_length_lo /*:8*/; -} si_tab_t; - -/* - * - * ETSI ISO/IEC 13818-1 specifies SI which is referred to as PSI. The PSI - * data provides information to enable automatic configuration of the - * receiver to demultiplex and decode the various streams of programs - * within the multiplex. The PSI data is structured as four types of table. - * The tables are transmitted in sections. - * - * 1) Program Association Table (PAT): - * - * - for each service in the multiplex, the PAT indicates the location - * (the Packet Identifier (PID) values of the Transport Stream (TS) - * packets) of the corresponding Program Map Table (PMT). - * It also gives the location of the Network Information Table (NIT). - * - */ -#define TableHasMoreSections(x) (((pat_t *)(x))->last_section_number > ((pat_t *)(x))->section_number) -#define GetSectionNumber(x) ((pat_t *)(x))->section_number -#define GetLastSectionNumber(x) ((pat_t *)(x))->last_section_number -#define GetServiceId(x) HILO(((eit_t *)(x))->service_id) -#define GetLastTableId(x) ((eit_t *)(x))->segment_last_table_id -#define GetSegmentLastSectionNumber(x) ((eit_t *)(x))->segment_last_section_number -typedef struct pat { - u_char table_id /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char section_syntax_indicator :1; - u_char dummy :1; // has to be 0 - u_char :2; - u_char section_length_hi :4; -#else - u_char section_length_hi :4; - u_char :2; - u_char dummy :1; // has to be 0 - u_char section_syntax_indicator :1; -#endif - u_char section_length_lo /*:8*/; - u_char transport_stream_id_hi /*:8*/; - u_char transport_stream_id_lo /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :2; - u_char version_number :5; - u_char current_next_indicator :1; -#else - u_char current_next_indicator :1; - u_char version_number :5; - u_char :2; -#endif - u_char section_number /*:8*/; - u_char last_section_number /*:8*/; -} pat_t; -#define PAT_LEN sizeof (pat_t) - -typedef struct pat_prog { - u_char program_number_hi /*:8*/; - u_char program_number_lo /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :3; - u_char network_pid_hi :5; -#else - u_char network_pid_hi :5; - u_char :3; -#endif - u_char network_pid_lo /*:8*/; - /* or program_map_pid (if prog_num=0)*/ -} pat_prog_t; -#define PAT_PROG_LEN sizeof (pat_prog_t) - -/* - * - * 2) Conditional Access Table (CAT): - * - * - the CAT provides information on the CA systems used in the - * multiplex; the information is private and dependent on the CA - * system, but includes the location of the EMM stream, when - * applicable. - * - */ -typedef struct cat { - u_char table_id /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char section_syntax_indicator :1; - u_char dummy :1; // has to be 0 - u_char :2; - u_char section_length_hi :4; -#else - u_char section_length_hi :4; - u_char :2; - u_char dummy :1; // has to be 0 - u_char section_syntax_indicator :1; -#endif - u_char section_length_lo /*:8*/; - u_char :8; - u_char :8; -#if BYTE_ORDER == BIG_ENDIAN - u_char :2; - u_char version_number :5; - u_char current_next_indicator :1; -#else - u_char current_next_indicator :1; - u_char version_number :5; - u_char :2; -#endif - u_char section_number /*:8*/; - u_char last_section_number /*:8*/; -} cat_t; -#define CAT_LEN sizeof (cat_t) - -/* - * - * 3) Program Map Table (PMT): - * - * - the PMT identifies and indicates the locations of the streams that - * make up each service, and the location of the Program Clock - * Reference fields for a service. - * - */ -typedef struct pmt { - u_char table_id /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char section_syntax_indicator :1; - u_char dummy :1; // has to be 0 - u_char :2; - u_char section_length_hi :4; -#else - u_char section_length_hi :4; - u_char :2; - u_char dummy :1; // has to be 0 - u_char section_syntax_indicator :1; -#endif - u_char section_length_lo /*:8*/; - u_char program_number_hi /*:8*/; - u_char program_number_lo /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :2; - u_char version_number :5; - u_char current_next_indicator :1; -#else - u_char current_next_indicator :1; - u_char version_number :5; - u_char :2; -#endif - u_char section_number /*:8*/; - u_char last_section_number /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :3; - u_char PCR_PID_hi :5; -#else - u_char PCR_PID_hi :5; - u_char :3; -#endif - u_char PCR_PID_lo /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :4; - u_char program_info_length_hi :4; -#else - u_char program_info_length_hi :4; - u_char :4; -#endif - u_char program_info_length_lo /*:8*/; - //descriptors -} pmt_t; -#define PMT_LEN sizeof (pmt_t) - -typedef struct pmt_info { - u_char stream_type /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :3; - u_char elementary_PID_hi :5; -#else - u_char elementary_PID_hi :5; - u_char :3; -#endif - u_char elementary_PID_lo /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :4; - u_char ES_info_length_hi :4; -#else - u_char ES_info_length_hi :4; - u_char :4; -#endif - u_char ES_info_length_lo /*:8*/; - // descriptors -} pmt_info_t; -#define PMT_INFO_LEN sizeof (pmt_info_t) - -/* - * - * 4) Network Information Table (NIT): - * - * - the NIT is intended to provide information about the physical - * network. The syntax and semantics of the NIT are defined in - * ETSI EN 300 468. - * - */ -typedef struct nit { - u_char table_id /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char section_syntax_indicator :1; - u_char :3; - u_char section_length_hi :4; -#else - u_char section_length_hi :4; - u_char :3; - u_char section_syntax_indicator :1; -#endif - u_char section_length_lo /*:8*/; - u_char network_id_hi /*:8*/; - u_char network_id_lo /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :2; - u_char version_number :5; - u_char current_next_indicator :1; -#else - u_char current_next_indicator :1; - u_char version_number :5; - u_char :2; -#endif - u_char section_number /*:8*/; - u_char last_section_number /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :4; - u_char network_descriptor_length_hi :4; -#else - u_char network_descriptor_length_hi :4; - u_char :4; -#endif - u_char network_descriptor_length_lo /*:8*/; - /* descriptors */ -} nit_t; -#define NIT_LEN sizeof (nit_t) - -typedef struct nit_mid { // after descriptors -#if BYTE_ORDER == BIG_ENDIAN - u_char :4; - u_char transport_stream_loop_length_hi :4; -#else - u_char transport_stream_loop_length_hi :4; - u_char :4; -#endif - u_char transport_stream_loop_length_lo /*:8*/; -} nit_mid_t; -#define SIZE_NIT_MID sizeof (nit_mid_t) - -typedef struct nit_end { - long CRC; -} nit_end_t; -#define SIZE_NIT_END sizeof (nit_end_t) - -typedef struct nit_ts { - u_char transport_stream_id_hi /*:8*/; - u_char transport_stream_id_lo /*:8*/; - u_char original_network_id_hi /*:8*/; - u_char original_network_id_lo /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :4; - u_char transport_descriptors_length_hi :4; -#else - u_char transport_descriptors_length_hi :4; - u_char :4; -#endif - u_char transport_descriptors_length_lo /*:8*/; - /* descriptors */ -} nit_ts_t; -#define NIT_TS_LEN sizeof (nit_ts_t) - -/* - * - * In addition to the PSI, data is needed to provide identification of - * services and events for the user. In contrast with the PAT, CAT, and - * PMT of the PSI, which give information only for the multiplex in which - * they are contained (the actual multiplex), the additional information - * defined within the present document can also provide information on - * services and events carried by different multiplexes, and even on other - * networks. This data is structured as nine tables: - * - * 1) Bouquet Association Table (BAT): - * - * - the BAT provides information regarding bouquets. As well as giving - * the name of the bouquet, it provides a list of services for each - * bouquet. - * - */ -/* SEE NIT (It has the same structure but has different allowed descriptors) */ -/* - * - * 2) Service Description Table (SDT): - * - * - the SDT contains data describing the services in the system e.g. - * names of services, the service provider, etc. - * - */ -typedef struct sdt { - u_char table_id /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char section_syntax_indicator :1; - u_char :3; - u_char section_length_hi :4; -#else - u_char section_length_hi :4; - u_char :3; - u_char section_syntax_indicator :1; -#endif - u_char section_length_lo /*:8*/; - u_char transport_stream_id_hi /*:8*/; - u_char transport_stream_id_lo /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :2; - u_char version_number :5; - u_char current_next_indicator :1; -#else - u_char current_next_indicator :1; - u_char version_number :5; - u_char :2; -#endif - u_char section_number /*:8*/; - u_char last_section_number /*:8*/; - u_char original_network_id_hi /*:8*/; - u_char original_network_id_lo /*:8*/; - u_char :8; -} sdt_t; -#define SDT_LEN sizeof (sdt_t) -#define GetSDTTransportStreamId(x) HILO(((sdt_t *)x)->transport_stream_id) -#define GetSDTOriginalNetworkId(x) HILO(((sdt_t *)x)->original_network_id) - -typedef struct sdt_descr { - u_char service_id_hi /*:8*/; - u_char service_id_lo /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :6; - u_char eit_schedule_flag :1; - u_char eit_present_following_flag :1; - u_char running_status :3; - u_char free_ca_mode :1; - u_char descriptors_loop_length_hi :4; -#else - u_char eit_present_following_flag :1; - u_char eit_schedule_flag :1; - u_char :6; - u_char descriptors_loop_length_hi :4; - u_char free_ca_mode :1; - u_char running_status :3; -#endif - u_char descriptors_loop_length_lo /*:8*/; - u_char data[]; -} sdt_descr_t; -#define SDT_DESCR_LEN sizeof (sdt_descr_t) -#define GetSDTDescriptorsLoopLength(x) HILO(((sdt_descr_t *)x)->descriptors_loop_length) - -/* - * - * 3) Event Information Table (EIT): - * - * - the EIT contains data concerning events or programmes such as event - * name, start time, duration, etc.; - the use of different descriptors - * allows the transmission of different kinds of event information e.g. - * for different service types. - * - */ -typedef struct eit { - u_char table_id /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char section_syntax_indicator :1; - u_char :3; - u_char section_length_hi :4; -#else - u_char section_length_hi :4; - u_char :3; - u_char section_syntax_indicator :1; -#endif - u_char section_length_lo /*:8*/; - u_char service_id_hi /*:8*/; - u_char service_id_lo /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :2; - u_char version_number :5; - u_char current_next_indicator :1; -#else - u_char current_next_indicator :1; - u_char version_number :5; - u_char :2; -#endif - u_char section_number /*:8*/; - u_char last_section_number /*:8*/; - u_char transport_stream_id_hi /*:8*/; - u_char transport_stream_id_lo /*:8*/; - u_char original_network_id_hi /*:8*/; - u_char original_network_id_lo /*:8*/; - u_char segment_last_section_number /*:8*/; - u_char segment_last_table_id /*:8*/; - u_char data[]; /* struct eit_event */ -} eit_t; -#define EIT_LEN sizeof (eit_t) - -typedef struct eit_event { - u_char event_id_hi /*:8*/; - u_char event_id_lo /*:8*/; - u_char mjd_hi /*:8*/; - u_char mjd_lo /*:8*/; - u_char start_time_h /*:8*/; - u_char start_time_m /*:8*/; - u_char start_time_s /*:8*/; - u_char duration_h /*:8*/; - u_char duration_m /*:8*/; - u_char duration_s /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char running_status :3; - u_char free_ca_mode :1; - u_char descriptors_loop_length_hi :4; -#else - u_char descriptors_loop_length_hi :4; - u_char free_ca_mode :1; - u_char running_status :3; -#endif - u_char descriptors_loop_length_lo /*:8*/; - u_char data[]; /* struct descr_gen */ -} eit_event_t; -#define EIT_EVENT_LEN sizeof (eit_event_t) -#define GetEITDescriptorsLoopLength(x) HILO(((eit_event_t *)x)->descriptors_loop_length) - -/* - * - * 4) Running Status Table (RST): - * - * - the RST gives the status of an event (running/not running). The RST - * updates this information and allows timely automatic switching to - * events. - * - */ - /* TO BE DONE */ -/* - * - * 5) Time and Date Table (TDT): - * - * - the TDT gives information relating to the present time and date. - * This information is given in a separate table due to the frequent - * updating of this information. - * - */ - -typedef struct tdt { - u_char table_id /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char section_syntax_indicator :1; - u_char :3; - u_char section_length_hi :4; -#else - u_char section_length_hi :4; - u_char :3; - u_char section_syntax_indicator :1; -#endif - u_char section_length_lo /*:8*/; - u_char utc_mjd_hi /*:8*/; - u_char utc_mjd_lo /*:8*/; - u_char utc_time_h /*:8*/; - u_char utc_time_m /*:8*/; - u_char utc_time_s /*:8*/; -} tdt_t; -#define TDT_LEN sizeof (tdt_t) - -/* - * - * 6) Time Offset Table (TOT): - * - * - the TOT gives information relating to the present time and date and - * local time offset. This information is given in a separate table due - * to the frequent updating of the time information. - * - */ -typedef struct tot { - u_char table_id /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char section_syntax_indicator :1; - u_char :3; - u_char section_length_hi :4; -#else - u_char section_length_hi :4; - u_char :3; - u_char section_syntax_indicator :1; -#endif - u_char section_length_lo /*:8*/; - u_char utc_mjd_hi /*:8*/; - u_char utc_mjd_lo /*:8*/; - u_char utc_time_h /*:8*/; - u_char utc_time_m /*:8*/; - u_char utc_time_s /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :4; - u_char descriptors_loop_length_hi :4; -#else - u_char descriptors_loop_length_hi :4; - u_char :4; -#endif - u_char descriptors_loop_length_lo /*:8*/; -} tot_t; -#define TOT_LEN sizeof (tot_t) - -/* - * - * 7) Stuffing Table (ST): - * - * - the ST is used to invalidate existing sections, for example at - * delivery system boundaries. - * - */ - /* TO BE DONE */ -/* - * - * 8) Selection Information Table (SIT): - * - * - the SIT is used only in "partial" (i.e. recorded) bitstreams. It - * carries a summary of the SI information required to describe the - * streams in the partial bitstream. - * - */ -struct sit { - uint8_t tableid; -#if BYTE_ORDER == BIG_ENDIAN - uint8_t section_length_hi : 4; - bool reserved1 : 2; - bool reserved_fu : 1; - bool section_syntax : 1; -#else - bool section_syntax : 1; - bool reserved_fu : 1; - bool reserved1 : 2; - uint8_t section_length_hi : 4; -#endif - uint8_t section_length_lo; - uint16_t transport_stream_id ; - bool reserved2 : 2; - uint8_t version : 5; - bool current_next_ind : 1; - uint8_t section_number; - uint8_t last_section_number; - uint16_t original_network_id; - uint8_t reserved3; - u_char serviceData[]; -} __attribute__((packed)); -struct si { - uint16_t serviceid; - uint8_t reserved_fu : 6; - bool eit_sched : 1; - bool eit_now_and_next : 1; -#if BYTE_ORDER == BIG_ENDIAN - uint8_t running_status : 3; - bool free_ca_mode : 1; - uint8_t desc_loop_len_hi : 4; -#else - uint8_t desc_loop_len_hi : 4; - bool free_ca_mode : 1; - uint8_t running_status : 3; -#endif - uint8_t desc_loop_len_lo; - u_char descData[]; -} __attribute__((packed)); -/* - * - * 9) Discontinuity Information Table (DIT): - * - * - the DIT is used only in "partial" (i.e. recorded) bitstreams. - * It is inserted where the SI information in the partial bitstream may - * be discontinuous. Where applicable the use of descriptors allows a - * flexible approach to the organization of the tables and allows for - * future compatible extensions. - * - */ - /* TO BE DONE */ -/* - * - * The following describes the different descriptors that can be used within - * the SI. - * - * The following semantics apply to all the descriptors defined in this - * subclause: - * - * descriptor_tag: The descriptor tag is an 8-bit field which identifies - * each descriptor. Those values with MPEG-2 normative - * meaning are described in ISO/IEC 13818-1. The values of - * descriptor_tag are defined in 'libsi.h' - * descriptor_length: The descriptor length is an 8-bit field specifying the - * total number of bytes of the data portion of the - * descriptor following the byte defining the value of - * this field. - * - */ - -typedef struct descr_gen { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; -} descr_gen_t; -#define DESCR_GEN_LEN sizeof (descr_gen_t) -#define CastGenericDescriptor(x) ((descr_gen_t *)(x)) - -#define GetDescriptorTag(x) (((descr_gen_t *)x)->descriptor_tag) -#define GetDescriptorLength(x) (((descr_gen_t *)x)->descriptor_length) - -/* 0x09 ca_descriptor */ -typedef struct descr_ca { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char CA_type_hi /*:8*/; - u_char CA_type_lo /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :3; - u_char CA_PID_hi :5; -#else - u_char CA_PID_hi :5; - u_char :3; -#endif - u_char CA_PID_lo /*:8*/; -} descr_ca_t; -#define DESCR_CA_LEN sizeof (descr_ca_t) -#define CastCaDescriptor(x) ((descr_ca_t *)(x)) - -/* 0x0A iso_639_language_descriptor */ -typedef struct descr_iso_639_language { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char lang_code1 /*:8*/; - u_char lang_code2 /*:8*/; - u_char lang_code3 /*:8*/; -} descr_iso_639_language_t; -#define DESCR_ISO_639_LANGUAGE_LEN sizeof (descr_iso_639_language_t) -#define CastIso639LanguageDescriptor(x) ((descr_iso_639_language_t *)(x)) - -/* 0x40 network_name_descriptor */ -typedef struct descr_network_name { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; -} descr_network_name_t; -#define DESCR_NETWORK_NAME_LEN sizeof (descr_network_name_t) -#define CastNetworkNameDescriptor(x) ((descr_network_name_t *)(x)) - -/* 0x41 service_list_descriptor */ -typedef struct descr_service_list { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; -} descr_service_list_t; -#define DESCR_SERVICE_LIST_LEN sizeof (descr_service_list_t) -#define CastServiceListDescriptor(x) ((descr_service_list_t *)(x)) - -typedef struct descr_service_list_loop { - u_char service_id_hi /*:8*/; - u_char service_id_lo /*:8*/; - u_char service_type /*:8*/; -} descr_service_list_loop_t; -#define DESCR_SERVICE_LIST_LOOP_LEN sizeof (descr_service_list_loop_t) -#define CastServiceListDescriptorLoop(x) ((descr_service_list_loop_t *)(x)) - -/* 0x42 stuffing_descriptor */ -typedef struct descr_stuffing { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char data[]; -} descr_stuffing_t; -#define DESCR_STUFFING_LEN sizeof (descr_stuffing_t) -#define CastStuffingDescriptor(x) ((descr_stuffing_t *)(x)) - -/* 0x43 satellite_delivery_system_descriptor */ -typedef struct descr_satellite_delivery_system { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char frequency1 /*:8*/; - u_char frequency2 /*:8*/; - u_char frequency3 /*:8*/; - u_char frequency4 /*:8*/; - u_char orbital_position1 /*:8*/; - u_char orbital_position2 /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char west_east_flag :1; - u_char polarization :2; - u_char modulation :5; -#else - u_char modulation :5; - u_char polarization :2; - u_char west_east_flag :1; -#endif - u_char symbol_rate1 /*:8*/; - u_char symbol_rate2 /*:8*/; - u_char symbol_rate3 /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char symbol_rate4 :4; - u_char fec_inner :4; -#else - u_char fec_inner :4; - u_char symbol_rate4 :4; -#endif -} descr_satellite_delivery_system_t; -#define DESCR_SATELLITE_DELIVERY_SYSTEM_LEN sizeof (descr_satellite_delivery_system_t) -#define CastSatelliteDeliverySystemDescriptor(x) ((descr_satellite_delivery_system_t *)(x)) -#define GetSatelliteDeliverySystemFrequency(x) HILO4(((descr_satellite_delivert_system_t *)x)->frequency) -#define GetSatelliteDeliverySystemSymbolRate(x) HILO4(((descr_satellite_delivert_system_t *)x)->symbol_rate) - - -/* 0x44 cable_delivery_system_descriptor */ -typedef struct descr_cable_delivery_system { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char frequency1 /*:8*/; - u_char frequency2 /*:8*/; - u_char frequency3 /*:8*/; - u_char frequency4 /*:8*/; - u_char :8; -#if BYTE_ORDER == BIG_ENDIAN - u_char :4; - u_char fec_outer :4; -#else - u_char fec_outer :4; - u_char :4; -#endif - u_char modulation /*:8*/; - u_char symbol_rate1 /*:8*/; - u_char symbol_rate2 /*:8*/; - u_char symbol_rate3 /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char symbol_rate4 :4; - u_char fec_inner :4; -#else - u_char fec_inner :4; - u_char symbol_rate4 :4; -#endif -} descr_cable_delivery_system_t; -#define DESCR_CABLE_DELIVERY_SYSTEM_LEN sizeof (descr_cable_delivery_system_t) -#define CastCableDeliverySystemDescriptor(x) ((descr_cable_delivery_system_t *)(x)) -#define GetCableDeliverySystemFrequency(x) HILO4(((descr_cable_delivert_system_t *)x)->frequency) -#define GetCableDeliverySystemSymbolRate(x) HILO4(((descr_cable_delivert_system_t *)x)->symbol_rate) - -/* 0x45 vbi_data_descriptor */ -typedef struct descr_vbi_data { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - /* TBD */ -} descr_vbi_data_t; -#define DESCR_VBI_DATA_LEN sizeof (descr_vbi_data_t) -#define CastVbiDataDescriptor(x) ((descr_vbi_data_t *)(x)) - -/* 0x46 vbi_teletext_descriptor */ -typedef struct descr_vbi_teletext { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - /* TBD */ -} descr_vbi_teletext_t; -#define DESCR_VBI_TELETEXT_LEN sizeof (descr_vbi_teletext_t) -#define CastVbiDescriptor(x) ((descr_vbi_teletext_t *)(x)) - -/* 0x47 bouquet_name_descriptor */ -typedef struct descr_bouquet_name { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; -} descr_bouquet_name_t; -#define DESCR_BOUQUET_NAME_LEN sizeof (descr_bouquet_name_t) - -#define CastBouquetNameDescriptor(x) ((descr_bouquet_name_t *)(x)) - -/* 0x48 service_descriptor */ -typedef struct descr_service { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char service_type /*:8*/; - u_char provider_name_length /*:8*/; -} descr_service_t; -#define DESCR_SERVICE_LEN sizeof (descr_service_t) -#define CastServiceDescriptor(x) ((descr_service_t *)(x)) - -/* 0x49 country_availability_descriptor */ -typedef struct descr_country_availability { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char country_availability_flag :1; - u_char :7; -#else - u_char :7; - u_char country_availability_flag :1; -#endif -} descr_country_availability_t; -#define DESCR_COUNTRY_AVAILABILITY_LEN sizeof (descr_country_availability_t) -#define CastCountryAvailabilityDescriptor(x) ((descr_country_availability_t *)(x)) - -/* 0x4A linkage_descriptor */ -typedef struct descr_linkage { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char transport_stream_id_hi /*:8*/; - u_char transport_stream_id_lo /*:8*/; - u_char original_network_id_hi /*:8*/; - u_char original_network_id_lo /*:8*/; - u_char service_id_hi /*:8*/; - u_char service_id_lo /*:8*/; - u_char linkage_type /*:8*/; -} descr_linkage_t; -#define DESCR_LINKAGE_LEN sizeof (descr_linkage_t) -#define CastLinkageDescriptor(x) ((descr_linkage_t *)(x)) - -/* 0x4B nvod_reference_descriptor */ -typedef struct descr_nvod_reference { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char data[]; /* struct item_nvod_reference */ -} descr_nvod_reference_t; -#define DESCR_NVOD_REFERENCE_LEN sizeof (descr_nvod_reference_t) -#define CastNvodReferenceDescriptor(x) ((descr_nvod_reference_t *)(x)) - -typedef struct item_nvod_reference { - u_char transport_stream_id_hi /*:8*/; - u_char transport_stream_id_lo /*:8*/; - u_char original_network_id_hi /*:8*/; - u_char original_network_id_lo /*:8*/; - u_char service_id_hi /*:8*/; - u_char service_id_lo /*:8*/; -} item_nvod_reference_t; -#define ITEM_NVOD_REFERENCE_LEN sizeof (item_nvod_reference_t) -#define CastNvodReferenceItem(x) ((item_nvod_reference_t *)(x)) - -/* 0x4C time_shifted_service_descriptor */ -typedef struct descr_time_shifted_service { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char reference_service_id_hi /*:8*/; - u_char reference_service_id_lo /*:8*/; -} descr_time_shifted_service_t; -#define DESCR_TIME_SHIFTED_SERVICE_LEN sizeof (descr_time_shifted_service_t) -#define CastTimeShiftedServiceDescriptor(x) ((descr_time_shifted_service_t *)(x)) - -/* 0x4D short_event_descriptor */ -typedef struct descr_short_event { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char lang_code1 /*:8*/; - u_char lang_code2 /*:8*/; - u_char lang_code3 /*:8*/; - u_char event_name_length /*:8*/; - u_char data[]; -} descr_short_event_t; -#define DESCR_SHORT_EVENT_LEN sizeof (descr_short_event_t) -#define CastShortEventDescriptor(x) ((descr_short_event_t *)(x)) - -/* 0x4E extended_event_descriptor */ -typedef struct descr_extended_event { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char descriptor_number :4; - u_char last_descriptor_number :4; -#else - u_char last_descriptor_number :4; - u_char descriptor_number :4; -#endif - u_char lang_code1 /*:8*/; - u_char lang_code2 /*:8*/; - u_char lang_code3 /*:8*/; - u_char length_of_items /*:8*/; - u_char data[]; /* struct item_extended_event */ -} descr_extended_event_t; -#define DESCR_EXTENDED_EVENT_LEN sizeof (descr_extended_event_t) -#define CastExtendedEventDescriptor(x) ((descr_extended_event_t *)(x)) - -typedef struct item_extended_event { - u_char item_description_length /*:8*/; - u_char data[]; -} item_extended_event_t; -#define ITEM_EXTENDED_EVENT_LEN sizeof (item_extended_event_t) -#define CastExtendedEventItem(x) ((item_extended_event_t *)(x)) - -/* 0x4F time_shifted_event_descriptor */ -typedef struct descr_time_shifted_event { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char reference_service_id_hi /*:8*/; - u_char reference_service_id_lo /*:8*/; - u_char reference_event_id_hi /*:8*/; - u_char reference_event_id_lo /*:8*/; -} descr_time_shifted_event_t; -#define DESCR_TIME_SHIFTED_EVENT_LEN sizeof (descr_time_shifted_event_t) -#define CastTimeShiftedEventDescriptor(x) ((descr_time_shifted_event_t *)(x)) - -/* 0x50 component_descriptor */ -typedef struct descr_component { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :4; - u_char stream_content :4; -#else - u_char stream_content :4; - u_char :4; -#endif - u_char component_type /*:8*/; - u_char component_tag /*:8*/; - u_char lang_code1 /*:8*/; - u_char lang_code2 /*:8*/; - u_char lang_code3 /*:8*/; - u_char data[]; -} descr_component_t; -#define DESCR_COMPONENT_LEN sizeof (descr_component_t) -#define CastComponentDescriptor(x) ((descr_component_t *)(x)) - -/* 0x51 mosaic_descriptor */ -typedef struct descr_mosaic { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char mosaic_entry_point :1; - u_char number_of_horizontal_elementary_cells :3; - u_char :1; - u_char number_of_vertical_elementary_cells :3; -#else - u_char number_of_vertical_elementary_cells :3; - u_char :1; - u_char number_of_horizontal_elementary_cells :3; - u_char mosaic_entry_point :1; -#endif - u_char data[]; /* struct item_mosaic */ -} descr_mosaic_t; -#define DESCR_MOSAIC_LEN sizeof (descr_mosaic_t) -#define CastMosaicDescriptor(x) ((descr_mosaic_t *)(x)) - -typedef struct item_mosaic { -#if BYTE_ORDER == BIG_ENDIAN - u_char logical_cell_id :6; - u_char :7; - u_char logical_cell_presentation_info :3; -#else - u_char :2; - u_char logical_cell_id :6; - u_char logical_cell_presentation_info :3; /*0=undefined, 1=video, 2=still picture, 3=graphical text, 4--7=reserved*/ - u_char :5; -#endif - u_char elementary_cell_field_length /*:8*/; - u_char data[]; /* struct item_mosaic_cell; struct item_mosaic_end */ -} item_mosaic_t; -typedef struct item_mosaic_end { - u_char cell_linkage_info /*:8*/; /*0=undefined, 1=bouquet, 2=service, 3=other mosaic, 4=event, 5--255=reserved*/ - u_char data[]; /* union item_cell_linkage */ -} item_mosaic_end_t; - -typedef struct item_mosaic_cell { -#if BYTE_ORDER == BIG_ENDIAN - u_char :2; - u_char elementary_cell_id :6; -#else - u_char elementary_cell_id :6; - u_char :2; -#endif -} item_mosaic_cell_t; -typedef union item_mosaic_cell_linkage { - struct item_mosaic_cell_bouquet { - u_char bouquet_id_hi /*:8*/; - u_char bouquet_id_lo /*:8*/; - } bouquet; - struct item_mosaic_cell_service { - u_char original_network_id_hi /*:8*/; - u_char original_network_id_lo /*:8*/; - u_char transport_stream_id_hi /*:8*/; - u_char transport_stream_id_lo /*:8*/; - u_char service_id_hi /*:8*/; - u_char service_id_lo /*:8*/; - } service; - struct item_mosaic_cell_other { - u_char original_network_id_hi /*:8*/; - u_char original_network_id_lo /*:8*/; - u_char transport_stream_id_hi /*:8*/; - u_char transport_stream_id_lo /*:8*/; - u_char service_id_hi /*:8*/; - u_char service_id_lo /*:8*/; - } other; - struct item_mosaic_cell_event { - u_char original_network_id_hi /*:8*/; - u_char original_network_id_lo /*:8*/; - u_char transport_stream_id_hi /*:8*/; - u_char transport_stream_id_lo /*:8*/; - u_char service_id_hi /*:8*/; - u_char service_id_lo /*:8*/; - u_char event_id_hi /*:8*/; - u_char event_id_lo /*:8*/; - } event; -} item_mosaic_cell_linkage_t; - -/* 0x52 stream_identifier_descriptor */ -typedef struct descr_stream_identifier { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char component_tag /*:8*/; -} descr_stream_identifier_t; -#define DESCR_STREAM_IDENTIFIER_LEN sizeof (descr_stream_identifier_t) -#define CastStreamIdentifierDescriptor(x) ((descr_stream_identifier_t *)(x)) - -/* 0x53 ca_identifier_descriptor */ -typedef struct descr_ca_identifier { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; -} descr_ca_identifier_t; -#define DESCR_CA_IDENTIFIER_LEN sizeof (descr_ca_identifier_t) -#define CastCaIdentifierDescriptor(x) ((descr_ca_identifier_t *)(x)) - -/* 0x54 content_descriptor */ -typedef struct descr_content { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char data[]; /* struct nibble_content */ -} descr_content_t; -#define DESCR_CONTENT_LEN sizeof (descr_content_t) -#define CastContentDescriptor(x) ((descr_content_t *)(x)) - -typedef struct nibble_content { -#if BYTE_ORDER == BIG_ENDIAN - u_char content_nibble_level_1 :4; - u_char content_nibble_level_2 :4; - u_char user_nibble_1 :4; - u_char user_nibble_2 :4; -#else - u_char user_nibble_2 :4; - u_char user_nibble_1 :4; - u_char content_nibble_level_2 :4; - u_char content_nibble_level_1 :4; -#endif -} nibble_content_t; -#define NIBBLE_CONTENT_LEN sizeof (nibble_content_t) -#define CastContentNibble(x) ((nibble_content_t *)(x)) - -/* 0x55 parental_rating_descriptor */ -typedef struct descr_parental_rating { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char data[]; /* struct parental_rating_item */ -} descr_parental_rating_t; -#define DESCR_PARENTAL_RATING_LEN sizeof (descr_parental_rating_t) -#define CastParentalRatingDescriptor(x) ((descr_parental_rating_t *)(x)) - -typedef struct parental_rating_item { - u_char lang_code1 /*:8*/; - u_char lang_code2 /*:8*/; - u_char lang_code3 /*:8*/; - u_char rating /*:8*/; -} parental_rating_item_t; -#define PARENTAL_RATING_ITEM_LEN sizeof (parental_rating_item_t) -#define CastParentalRatingItem(x) ((parental_rating_item_t *)(x)) - -/* 0x56 teletext_descriptor */ -typedef struct descr_teletext { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char data[]; /* struct item_teletext */ -} descr_teletext_t; -#define DESCR_TELETEXT_LEN sizeof (descr_teletext_t) -#define CastTeletextDescriptor(x) ((descr_teletext_t *)(x)) - -typedef struct item_teletext { - u_char lang_code1 /*:8*/; - u_char lang_code2 /*:8*/; - u_char lang_code3 /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char type :5; - u_char magazine_number :3; -#else - u_char magazine_number :3; - u_char type :5; -#endif - u_char page_number /*:8*/; -} item_teletext_t; -#define ITEM_TELETEXT_LEN sizeof (item_teletext_t) -#define CastTeletextItem(x) ((item_teletext_t *)(x)) - -/* 0x57 telephone_descriptor */ -typedef struct descr_telephone { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :2; - u_char foreign_availability :1; - u_char connection_type :5; -#else - u_char connection_type :5; - u_char foreign_availability :1; - u_char :2; -#endif -#if BYTE_ORDER == BIG_ENDIAN - u_char :1; - u_char country_prefix_length :2; - u_char international_area_code_length :3; - u_char operator_code_length :2; -#else - u_char operator_code_length :2; - u_char international_area_code_length :3; - u_char country_prefix_length :2; - u_char :1; -#endif -#if BYTE_ORDER == BIG_ENDIAN - u_char :1; - u_char national_area_code_length :3; - u_char core_number_length :4; -#else - u_char core_number_length :4; - u_char national_area_code_length :3; - u_char :1; -#endif - u_char data[]; /* coutry area operator national core */ -} descr_telephone_t; -#define DESCR_TELEPHONE_LEN sizeof (descr_telephone_t) -#define CastTelephoneDescriptor(x) ((descr_telephone_t *)(x)) - -/* 0x58 local_time_offset_descriptor */ -typedef struct descr_local_time_offset { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; -} descr_local_time_offset_t; -#define DESCR_LOCAL_TIME_OFFSET_LEN sizeof (descr_local_time_offset_t) -#define CastLocalTimeOffsetDescriptor(x) ((descr_local_time_offset_t *)(x)) - -typedef struct local_time_offset_entry { - u_char country_code1 /*:8*/; - u_char country_code2 /*:8*/; - u_char country_code3 /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char country_region_id :6; - u_char :1; - u_char local_time_offset_polarity :1; -#else - u_char local_time_offset_polarity :1; - u_char :1; - u_char country_region_id :6; -#endif - u_char local_time_offset_h /*:8*/; - u_char local_time_offset_m /*:8*/; - u_char time_of_change_mjd_hi /*:8*/; - u_char time_of_change_mjd_lo /*:8*/; - u_char time_of_change_time_h /*:8*/; - u_char time_of_change_time_m /*:8*/; - u_char time_of_change_time_s /*:8*/; - u_char next_time_offset_h /*:8*/; - u_char next_time_offset_m /*:8*/; -} local_time_offset_entry_t ; -#define LOCAL_TIME_OFFSET_ENTRY_LEN sizeof (local_time_offset_entry_t) -#define CastLocalTimeOffsetEntry(x) ((local_time_offset_entry_t *)(x)) - -/* 0x59 subtitling_descriptor */ -typedef struct descr_subtitling { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char data[]; /* item_subtitling */ -} descr_subtitling_t; -#define DESCR_SUBTITLING_LEN sizeof (descr_subtitling_t) -#define CastSubtitlingDescriptor(x) ((descr_subtitling_t *)(x)) - -typedef struct item_subtitling { - u_char lang_code1 /*:8*/; - u_char lang_code2 /*:8*/; - u_char lang_code3 /*:8*/; - u_char subtitling_type /*:8*/; - u_char composition_page_id_hi /*:8*/; - u_char composition_page_id_lo /*:8*/; - u_char ancillary_page_id_hi /*:8*/; - u_char ancillary_page_id_lo /*:8*/; -} item_subtitling_t; -#define ITEM_SUBTITLING_LEN sizeof (item_subtitling_t) -#define CastSubtitlingItem(x) ((item_subtitling_t *)(x)) - -/* 0x5A terrestrial_delivery_system_descriptor */ -typedef struct descr_terrestrial_delivery { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char frequency1 /*:8*/; - u_char frequency2 /*:8*/; - u_char frequency3 /*:8*/; - u_char frequency4 /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char bandwidth :3; - u_char :5; -#else - u_char :5; - u_char bandwidth :3; -#endif -#if BYTE_ORDER == BIG_ENDIAN - u_char constellation :2; - u_char hierarchy :3; - u_char code_rate_HP :3; -#else - u_char code_rate_HP :3; - u_char hierarchy :3; - u_char constellation :2; -#endif -#if BYTE_ORDER == BIG_ENDIAN - u_char code_rate_LP :3; - u_char guard_interval :2; - u_char transmission_mode :2; - u_char other_frequency_flag :1; -#else - u_char other_frequency_flag :1; - u_char transmission_mode :2; - u_char guard_interval :2; - u_char code_rate_LP :3; -#endif - u_char reserver2 /*:8*/; - u_char reserver3 /*:8*/; - u_char reserver4 /*:8*/; - u_char reserver5 /*:8*/; -} descr_terrestrial_delivery_system_t; -#define DESCR_TERRESTRIAL_DELIVERY_SYSTEM_LEN sizeof (descr_terrestrial_delivery_system_t) -#define CastTerrestrialDeliverySystemDescriptor(x) ((descr_terrestrial_delivery_system_t *)(x)) -#define GetTerrestrialDeliverySystemFrequency(x) HILO4(((descr_terrestrial_delivert_system_t *)x)->frequency) - -/* 0x5B multilingual_network_name_descriptor */ -typedef struct descr_multilingual_network_name { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char data[]; /* struct item_multilingual_network_name */ -} descr_multilingual_network_name_t; -#define DESCR_MULTILINGUAL_NETWORK_NAME_LEN sizeof (descr_multilingual_network_name_t) -#define CastMultilingualNetworkNameDescriptor(x) ((descr_multilingual_network_name_t *)(x)) - -typedef struct item_multilingual_network_name { - u_char lang_code1 /*:8*/; - u_char lang_code2 /*:8*/; - u_char lang_code3 /*:8*/; - u_char network_name_length /*:8*/; - u_char network_name[]; -} item_multilingual_network_name_t; - -/* 0x5C multilingual_bouquet_name_descriptor */ -typedef struct descr_multilingual_bouquet_name { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char names[]; /* struct item_multilingual_bouquet_name */ -} descr_multilingual_bouquet_name_t; -#define DESCR_MULTILINGUAL_BOUQUET_NAME_LEN sizeof (descr_multilingual_bouquet_name_t) -#define CastMultilingualBouquetNameDescriptor(x) ((descr_multilingual_bouquet_name_t *)(x)) - -typedef struct item_multilingual_bouquet_name { - u_char lang_code1 /*:8*/; - u_char lang_code2 /*:8*/; - u_char lang_code3 /*:8*/; - u_char bouquet_name_length /*:8*/; - u_char bouquet_name[]; -} item_multilingual_bouquet_name_t; - -/* 0x5D multilingual_service_name_descriptor */ -typedef struct descr_multilingual_service_name { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char data[]; /* struct multilingual_service_name_item */ -} descr_multilingual_service_name_t; -#define DESCR_MULTILINGUAL_SERVICE_NAME_LEN sizeof (descr_multilingual_service_name_t) -#define CastMultilingualServiceNameDescriptor(x) ((descr_multilingual_service_name_t *)(x)) - -typedef struct multilingual_service_name_item { - u_char lang_code1 /*:8*/; - u_char lang_code2 /*:8*/; - u_char lang_code3 /*:8*/; - u_char data[]; /* struct multilingual_service_name_item_(mid|end) */ -} multilingual_service_name_item_t; -typedef struct multilingual_service_name_item_mid { - u_char service_provider_name_length /*:8*/; - u_char service_provider_name[]; -} multilingual_service_name_item_mid_t; -typedef struct multilingual_service_name_item_end { - u_char service_name_length /*:8*/; - u_char service_name[]; -} multilingual_service_name_item_end_t; - -/* 0x5E multilingual_component_descriptor */ -typedef struct descr_multilingual_component { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char component_tag /*:8*/; - u_char data[]; /* struct multilingual_component_item */ -} descr_multilingual_component_t; -#define DESCR_MULTILINGUAL_COMPONENT_LEN sizeof (descr_multilingual_component_t) -#define CastMultilingualComponentDescriptor(x) ((descr_multilingual_component_t *)(x)) - -typedef struct item_multilingual_component { - u_char lang_code1 /*:8*/; - u_char lang_code2 /*:8*/; - u_char lang_code3 /*:8*/; - u_char text_description_length /*:8*/; - u_char text_description[]; -} item_multilingual_component_t; - -/* 0x5F private_data_specifier_descriptor */ -typedef struct descr_private_data_specifier { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char private_data_specifier1 /*:8*/; - u_char private_data_specifier2 /*:8*/; - u_char private_data_specifier3 /*:8*/; - u_char private_data_specifier4 /*:8*/; -} descr_private_data_specifier_t; -#define DESCR_PRIVATE_DATA_SPECIFIER_LEN sizeof (descr_private_data_specifier_t) -#define CastPrivateDataSpecifierDescriptor(x) ((descr_private_data_specifier_t *)(x)) -#define GetPrivateDataSpecifier(x) HILO4(((descr_private_data_specifier_t *)x)->private_data_specifier) - -/* 0x60 service_move_descriptor */ -typedef struct descr_service_move { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char new_original_network_id_hi /*:8*/; - u_char new_original_network_id_lo /*:8*/; - u_char new_transport_stream_id_hi /*:8*/; - u_char new_transport_stream_id_lo /*:8*/; - u_char new_service_id_hi /*:8*/; - u_char new_service_id_lo /*:8*/; -} descr_service_move_t; -#define DESCR_SERVICE_MOVE_LEN sizeof (descr_service_move_t) -#define CastServiceMoveDescriptor(x) ((descr_service_move_t *)(x)) - -/* 0x61 short_smoothing_buffer_descriptor */ -typedef struct descr_short_smoothing_buffer { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char sb_size :2; - u_char sb_leak_rate :6; -#else - u_char sb_leak_rate :6; - u_char sb_size :2; -#endif - u_char data[]; -} descr_short_smoothing_buffer_t; -#define DESCR_SHORT_SMOOTHING_BUFFER_LEN sizeof (descr_short_smoothing_buffer_t) -#define CastShortSmoothingBufferDescriptor(x) ((descr_short_smoothing_buffer_t *)(x)) - -/* 0x62 frequency_list_descriptor */ -typedef struct descr_frequency_list { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :6; - u_char coding_type :2; /* 00=not def 01=satelite 10=cable 11=terrestrial */ -#else - u_char coding_type :2; /* 00=not def 01=satelite 10=cable 11=terrestrial */ - u_char :6; -#endif - u_char centre_frequency1 /*:8*/; - u_char centre_frequency2 /*:8*/; - u_char centre_frequency3 /*:8*/; - u_char centre_frequency4 /*:8*/; -} descr_frequency_list_t; -#define DESCR_FREQUENCY_LIST_LEN sizeof (descr_frequency_list_t) -#define CastFrequencyListDescriptor(x) ((descr_frequency_list_t *)(x)) - -/* 0x63 partial_transport_stream_descriptor */ -typedef struct descr_partial_transport_stream { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :2; - u_char peak_rate1 :6; -#else - u_char peak_rate1 :6; - u_char :2; -#endif - u_char peak_rate2 /*:8*/; - u_char peak_rate3 /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :2; - u_char minimum_overall_smoothing_rate1 :6; -#else - u_char minimum_overall_smoothing_rate1 :6; - u_char :2; -#endif - u_char minimum_overall_smoothing_rate2 /*:8*/; - u_char minimum_overall_smoothing_rate3 /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :2; - u_char maximum_overall_smoothing_rate1 :6; -#else - u_char maximum_overall_smoothing_rate1 :6; - u_char :2; -#endif - u_char maximum_overall_smoothing_rate2 /*:8*/; -} descr_partial_transport_stream_t; -#define DESCR_PARTIAL_TRANSPORT_STREAM_LEN sizeof (descr_partial_transport_stream_t) -#define CastPartialDescriptor(x) ((descr_partial_transport_stream_t *)(x)) -#define GetPartialTransportStreamCentreFrequency(x) HILO4(((descr_partial_transport_stream_t *)x)->centre_frequency) -#define GetPTSPeakRate(x) HILO2(((descr_partial_transport_stream *)x)->peak_rate) -#define GetPTSMinOSRate(x) HILO3(((descr_partial_transport_stream *)x)->minimum_overall_smoothing_rate) -#define GetPTSMaxOSRate(x) HILO2(((descr_partial_transport_stream *)x)->minimum_overall_smoothing_rate) - -/* 0x64 data_broadcast_descriptor */ -typedef struct descr_data_broadcast { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char data_broadcast_id_hi /*:8*/; - u_char data_broadcast_id_lo /*:8*/; - u_char component_tag /*:8*/; - u_char selector_length /*:8*/; - u_char data[]; /* char[]; struct descr_data_broadcast_end */ -} descr_data_broadcast_t; -typedef struct descr_data_broadcast_end { - u_char lang_code1 /*:8*/; - u_char lang_code2 /*:8*/; - u_char lang_code3 /*:8*/; - u_char text_length /*:8*/; - u_char text[]; -} descr_data_broadcast_end_t; - -/* 0x65 ca_system_descriptor */ -typedef struct descr_ca_system { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char data[]; /* struct item_ca_system */ -} descr_ca_system_t; -#define DESCR_CA_SYSTEM_LEN sizeof (descr_ca_system_t) -#define CastCaSystemDescriptor(x) ((descr_ca_system_t *)(x)) - -typedef struct item_ca_system { - u_char CA_system_id_hi /*:8*/; - u_char CA_system_id_lo /*:8*/; -} item_ca_system_t; - -/* 0x66 data_broadcast_id_descriptor */ -typedef struct descr_data_broadcast_id { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char data_broadcast_id_hi /*:8*/; - u_char data_broadcast_id_lo /*:8*/; -} descr_data_broadcast_id_t; -#define DESCR_DATA_BROADCAST_ID_LEN sizeof (descr_data_broadcast_id_t) -#define CastDataBroadcastIdDescriptor(x) ((descr_data_broadcast_id_t *)(x)) - -/* 0x67 transport_stream_descriptor */ -typedef struct descr_transport_stream { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - /* TBD */ -} descr_transport_stream_t; -#define DESCR_TRANSPORT_STREAM_LEN sizeof (descr_transport_stream_t) -#define CastTransportStreamDescriptor(x) ((descr_transport_stream_t *)(x)) - -/* 0x68 dsng_descriptor */ -typedef struct descr_dsng { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - /* TBD */ -} descr_dsng_t; -#define DESCR_DSNG_LEN sizeof (descr_dsng_t) -#define CastDsngDescriptor(x) ((descr_dsng_t *)(x)) - -/* 0x69 programme_identificaion_label_descriptor */ -typedef struct descr_pdc { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char :4; - u_char day :5; - u_char month :4; - u_char hour :5; - u_char minute :6; -#else - u_char minute :6; - u_char hour :5; - u_char month :4; - u_char day :5; - u_char :4; -#endif -} descr_pdc_t; -#define DESCR_PDC_LEN sizeof (descr_pdc_t) -#define CastPdcDescriptor(x) ((descr_pdc_t *)(x)) - -/* 0x6A ac3_descriptor */ -typedef struct descr_ac3 { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; -#if BYTE_ORDER == BIG_ENDIAN - u_char ac3_type_flag :1; - u_char bsid_flag :1; - u_char mainid_flag :1; - u_char asvc_flag :1; - u_char :4; -#else - u_char :4; - u_char asvc_flag :1; - u_char mainid_flag :1; - u_char bsid_flag :1; - u_char ac3_type_flag :1; -#endif - u_char ac3_type /*:8*/; - u_char bsid /*:8*/; - u_char mainid /*:8*/; - u_char asvc /*:8*/; -} descr_ac3_t; -#define DESCR_AC3_LEN sizeof (descr_ac3_t) -#define CastAc3Descriptor(x) ((descr_ac3_t *)(x)) - -/* 0x6B ancillary_data_descriptor */ -typedef struct descr_ancillary_data { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char ancillary_data_identifier /*:8*/; -} descr_ancillary_data_t; -#define DESCR_ANCILLARY_DATA_LEN sizeof (descr_ancillary_data_t) -#define CastAncillaryDataDescriptor(x) ((descr_ancillary_data_t *)(x)) - -/* 0x6C cell_list_descriptor */ -typedef struct descr_cell_list { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - /* TBD */ -} descr_cell_list_t; -#define DESCR_CELL_LIST_LEN sizeof (descr_cell_list_t) -#define CastCellListDescriptor(x) ((descr_cell_list_t *)(x)) - -/* 0x6D cell_frequency_link_descriptor */ -typedef struct descr_cell_frequency_link { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - /* TBD */ -} descr_cell_frequency_link_t; -#define DESCR_CELL_FREQUENCY_LINK_LEN sizeof (descr_cell_frequency_link_t) -#define CastCellFrequencyLinkDescriptor(x) ((descr_cell_frequency_link_t *)(x)) - -/* 0x6E announcement_support_descriptor */ -typedef struct descr_announcement_support { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - /* TBD */ -} descr_announcement_support_t; -#define DESCR_ANNOUNCEMENT_SUPPORT_LEN sizeof (descr_announcement_support_t) -#define CastAnnouncementSupportDescriptor(x) ((descr_announcement_support_t *)(x)) - -/* 0x76 content_identifier_descriptor */ -typedef struct descr_content_identifier { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char data[]; -} descr_content_identifier_t; - -typedef struct descr_content_identifier_crid { -#if BYTE_ORDER == BIG_ENDIAN - u_char crid_type :6; - u_char crid_location :2; -#else - u_char crid_location :2; - u_char crid_type :6; -#endif - u_char crid_ref_data[]; -} descr_content_identifier_crid_t; - -typedef struct descr_content_identifier_crid_local { - u_char crid_length /*:8*/; - u_char crid_byte[]; -} descr_content_identifier_crid_local_t; - - -/* 0x80 custom_category_descriptor TODO */ -typedef struct descr_custom_category { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char dummy /*:8*/; // 7F - u_char data_length /*:8*/; - u_char data[]; /* struct custom_category_item(1|2) */ -} descr_custom_category_t; -struct custom_category_item1 { - u_char dummy /*:8*/; // 10 40 -}; -struct custom_category_item2 { - u_char length /*:8*/; - u_char data[]; /* struct custom_category_item3 */ -}; -struct custom_category_item3 { - u_char dummy0 /*:8*/; // FF -#if BYTE_ORDER == BIG_ENDIAN - u_char content_nibble_level_1 :4; - u_char content_nibble_level_2 :4; - u_char user_nibble_1 :4; - u_char user_nibble_2 :4; -#else - u_char user_nibble_2 :4; - u_char user_nibble_1 :4; - u_char content_nibble_level_2 :4; - u_char content_nibble_level_1 :4; -#endif - u_char dummy1[2] /*:8*/; // CF E2 | D4 48 - u_char text_length /*:8*/; - u_char text[]; -}; - -/* 0x81 xxx_descriptor TODO */ -typedef struct descr_xxx { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char dummy /*:8 FF*/; -} descr_xxx_t; -#define DESCR_XXX_LEN sizeof (descr_xxx_t) -#define CastXxxDescriptor(x) ((descr_xxx_t *)(x)) - -/* 0x82 vps_descriptor TODO */ -typedef struct descr_vps { - u_char descriptor_tag /*:8*/; - u_char descriptor_length /*:8*/; - u_char hour[2] /*:8*/; - u_char delimiter_time /*:8 ':'*/; - u_char minute[2] /*:8*/; - u_char day[2] /*:8*/; - u_char delimiter_date /*:8 '.'*/; - u_char month[2] /*:8*/; - u_char delimiter /*:8 '#'*/; - u_char number[2] /*:8*/; -} descr_vps_t; -#define DESCR_VPS_LEN sizeof (descr_vps_t) -#define CastVpsDescriptor(x) ((descr_vps_t *)(x)) |