810 lines · c
1/* SPDX-License-Identifier: GPL-2.0 */2/*3 * This file contains the logic to work with MPEG Program-Specific Information.4 * These are defined both in ISO/IEC 13818-1 (systems) and ETSI EN 300 468.5 * PSI is carried in the form of table structures, and although each table might6 * technically be broken into one or more sections, we do not do this here,7 * hence 'table' and 'section' are interchangeable for vidtv.8 *9 * Copyright (C) 2020 Daniel W. S. Almeida10 */11 12#ifndef VIDTV_PSI_H13#define VIDTV_PSI_H14 15#include <linux/types.h>16 17/*18 * all section lengths start immediately after the 'section_length' field19 * see ISO/IEC 13818-1 : 2000 and ETSI EN 300 468 V 1.10.1 for20 * reference21 */22#define PAT_LEN_UNTIL_LAST_SECTION_NUMBER 523#define PMT_LEN_UNTIL_PROGRAM_INFO_LENGTH 924#define SDT_LEN_UNTIL_RESERVED_FOR_FUTURE_USE 825#define NIT_LEN_UNTIL_NETWORK_DESCRIPTOR_LEN 726#define EIT_LEN_UNTIL_LAST_TABLE_ID 1127#define MAX_SECTION_LEN 102128#define EIT_MAX_SECTION_LEN 4093 /* see ETSI 300 468 v.1.10.1 p. 26 */29#define VIDTV_PAT_PID 0 /* mandated by the specs */30#define VIDTV_SDT_PID 0x0011 /* mandated by the specs */31#define VIDTV_NIT_PID 0x0010 /* mandated by the specs */32#define VIDTV_EIT_PID 0x0012 /*mandated by the specs */33 34enum vidtv_psi_descriptors {35 REGISTRATION_DESCRIPTOR = 0x05, /* See ISO/IEC 13818-1 section 2.6.8 */36 NETWORK_NAME_DESCRIPTOR = 0x40, /* See ETSI EN 300 468 section 6.2.27 */37 SERVICE_LIST_DESCRIPTOR = 0x41, /* See ETSI EN 300 468 section 6.2.35 */38 SERVICE_DESCRIPTOR = 0x48, /* See ETSI EN 300 468 section 6.2.33 */39 SHORT_EVENT_DESCRIPTOR = 0x4d, /* See ETSI EN 300 468 section 6.2.37 */40};41 42enum vidtv_psi_stream_types {43 STREAM_PRIVATE_DATA = 0x06, /* see ISO/IEC 13818-1 2000 p. 48 */44};45 46/*47 * struct vidtv_psi_desc - A generic PSI descriptor type.48 * The descriptor length is an 8-bit field specifying the total number of bytes of the data portion49 * of the descriptor following the byte defining the value of this field.50 */51struct vidtv_psi_desc {52 struct vidtv_psi_desc *next;53 u8 type;54 u8 length;55 u8 data[];56} __packed;57 58/*59 * struct vidtv_psi_desc_service - Service descriptor.60 * See ETSI EN 300 468 section 6.2.33.61 */62struct vidtv_psi_desc_service {63 struct vidtv_psi_desc *next;64 u8 type;65 u8 length;66 67 u8 service_type;68 u8 provider_name_len;69 char *provider_name;70 u8 service_name_len;71 char *service_name;72} __packed;73 74/*75 * struct vidtv_psi_desc_registration - A registration descriptor.76 * See ISO/IEC 13818-1 section 2.6.877 */78struct vidtv_psi_desc_registration {79 struct vidtv_psi_desc *next;80 u8 type;81 u8 length;82 83 /*84 * The format_identifier is a 32-bit value obtained from a Registration85 * Authority as designated by ISO/IEC JTC 1/SC 29.86 */87 __be32 format_id;88 /*89 * The meaning of additional_identification_info bytes, if any, are90 * defined by the assignee of that format_identifier, and once defined91 * they shall not change.92 */93 u8 additional_identification_info[];94} __packed;95 96/*97 * struct vidtv_psi_desc_network_name - A network name descriptor98 * see ETSI EN 300 468 v1.15.1 section 6.2.2799 */100struct vidtv_psi_desc_network_name {101 struct vidtv_psi_desc *next;102 u8 type;103 u8 length;104 char *network_name;105} __packed;106 107struct vidtv_psi_desc_service_list_entry {108 __be16 service_id;109 u8 service_type;110 struct vidtv_psi_desc_service_list_entry *next;111} __packed;112 113/*114 * struct vidtv_psi_desc_service_list - A service list descriptor115 * see ETSI EN 300 468 v1.15.1 section 6.2.35116 */117struct vidtv_psi_desc_service_list {118 struct vidtv_psi_desc *next;119 u8 type;120 u8 length;121 struct vidtv_psi_desc_service_list_entry *service_list;122} __packed;123 124/*125 * struct vidtv_psi_desc_short_event - A short event descriptor126 * see ETSI EN 300 468 v1.15.1 section 6.2.37127 */128struct vidtv_psi_desc_short_event {129 struct vidtv_psi_desc *next;130 u8 type;131 u8 length;132 char *iso_language_code;133 u8 event_name_len;134 char *event_name;135 u8 text_len;136 char *text;137} __packed;138 139struct vidtv_psi_desc_short_event140*vidtv_psi_short_event_desc_init(struct vidtv_psi_desc *head,141 char *iso_language_code,142 char *event_name,143 char *text);144 145/*146 * struct vidtv_psi_table_header - A header that is present for all PSI tables.147 */148struct vidtv_psi_table_header {149 u8 table_id;150 151 __be16 bitfield; /* syntax: 1, zero: 1, one: 2, section_length: 13 */152 153 __be16 id; /* TS ID */154 u8 current_next:1;155 u8 version:5;156 u8 one2:2;157 u8 section_id; /* section_number */158 u8 last_section; /* last_section_number */159} __packed;160 161/*162 * struct vidtv_psi_table_pat_program - A single program in the PAT163 * See ISO/IEC 13818-1 : 2000 p.43164 */165struct vidtv_psi_table_pat_program {166 __be16 service_id;167 __be16 bitfield; /* reserved: 3, program_map_pid/network_pid: 13 */168 struct vidtv_psi_table_pat_program *next;169} __packed;170 171/*172 * struct vidtv_psi_table_pat - The Program Allocation Table (PAT)173 * See ISO/IEC 13818-1 : 2000 p.43174 */175struct vidtv_psi_table_pat {176 struct vidtv_psi_table_header header;177 u16 num_pat;178 u16 num_pmt;179 struct vidtv_psi_table_pat_program *program;180} __packed;181 182/*183 * struct vidtv_psi_table_sdt_service - Represents a service in the SDT.184 * see ETSI EN 300 468 v1.15.1 section 5.2.3.185 */186struct vidtv_psi_table_sdt_service {187 __be16 service_id;188 u8 EIT_present_following:1;189 u8 EIT_schedule:1;190 u8 reserved:6;191 __be16 bitfield; /* running_status: 3, free_ca:1, desc_loop_len:12 */192 struct vidtv_psi_desc *descriptor;193 struct vidtv_psi_table_sdt_service *next;194} __packed;195 196/*197 * struct vidtv_psi_table_sdt - Represents the Service Description Table198 * see ETSI EN 300 468 v1.15.1 section 5.2.3.199 */200 201struct vidtv_psi_table_sdt {202 struct vidtv_psi_table_header header;203 __be16 network_id; /* original_network_id */204 u8 reserved;205 struct vidtv_psi_table_sdt_service *service;206} __packed;207 208/*209 * enum service_running_status - Status of a SDT service.210 * see ETSI EN 300 468 v1.15.1 section 5.2.3 table 6.211 */212enum service_running_status {213 RUNNING = 0x4,214};215 216/*217 * enum service_type - The type of a SDT service.218 * see ETSI EN 300 468 v1.15.1 section 6.2.33, table 81.219 */220enum service_type {221 /* see ETSI EN 300 468 v1.15.1 p. 77 */222 DIGITAL_TELEVISION_SERVICE = 0x1,223 DIGITAL_RADIO_SOUND_SERVICE = 0X2,224};225 226/*227 * struct vidtv_psi_table_pmt_stream - A single stream in the PMT.228 * See ISO/IEC 13818-1 : 2000 p.46.229 */230struct vidtv_psi_table_pmt_stream {231 u8 type;232 __be16 bitfield; /* reserved: 3, elementary_pid: 13 */233 __be16 bitfield2; /*reserved: 4, zero: 2, desc_length: 10 */234 struct vidtv_psi_desc *descriptor;235 struct vidtv_psi_table_pmt_stream *next;236} __packed;237 238/*239 * struct vidtv_psi_table_pmt - The Program Map Table (PMT).240 * See ISO/IEC 13818-1 : 2000 p.46.241 */242struct vidtv_psi_table_pmt {243 struct vidtv_psi_table_header header;244 __be16 bitfield; /* reserved:3, pcr_pid: 13 */245 __be16 bitfield2; /* reserved: 4, zero: 2, desc_len: 10 */246 struct vidtv_psi_desc *descriptor;247 struct vidtv_psi_table_pmt_stream *stream;248} __packed;249 250/**251 * struct psi_write_args - Arguments for the PSI packetizer.252 * @dest_buf: The buffer to write into.253 * @from: PSI data to be copied.254 * @len: How much to write.255 * @dest_offset: where to start writing in the dest_buffer.256 * @pid: TS packet ID.257 * @new_psi_section: Set when starting a table section.258 * @continuity_counter: Incremented on every new packet.259 * @is_crc: Set when writing the CRC at the end.260 * @dest_buf_sz: The size of the dest_buffer261 * @crc: a pointer to store the crc for this chunk262 */263struct psi_write_args {264 void *dest_buf;265 void *from;266 size_t len;267 u32 dest_offset;268 u16 pid;269 bool new_psi_section;270 u8 *continuity_counter;271 bool is_crc;272 u32 dest_buf_sz;273 u32 *crc;274};275 276/**277 * struct desc_write_args - Arguments in order to write a descriptor.278 * @dest_buf: The buffer to write into.279 * @dest_offset: where to start writing in the dest_buffer.280 * @desc: A pointer to the descriptor281 * @pid: TS packet ID.282 * @continuity_counter: Incremented on every new packet.283 * @dest_buf_sz: The size of the dest_buffer284 * @crc: a pointer to store the crc for this chunk285 */286struct desc_write_args {287 void *dest_buf;288 u32 dest_offset;289 struct vidtv_psi_desc *desc;290 u16 pid;291 u8 *continuity_counter;292 u32 dest_buf_sz;293 u32 *crc;294};295 296/**297 * struct crc32_write_args - Arguments in order to write the CRC at the end of298 * the PSI tables.299 * @dest_buf: The buffer to write into.300 * @dest_offset: where to start writing in the dest_buffer.301 * @crc: the CRC value to write302 * @pid: TS packet ID.303 * @continuity_counter: Incremented on every new packet.304 * @dest_buf_sz: The size of the dest_buffer305 */306struct crc32_write_args {307 void *dest_buf;308 u32 dest_offset;309 __be32 crc;310 u16 pid;311 u8 *continuity_counter;312 u32 dest_buf_sz;313};314 315/**316 * struct header_write_args - Arguments in order to write the common table317 * header318 * @dest_buf: The buffer to write into.319 * @dest_offset: where to start writing in the dest_buffer.320 * @h: a pointer to the header.321 * @pid: TS packet ID.322 * @continuity_counter: Incremented on every new packet.323 * @dest_buf_sz: The size of the dest_buffer324 * @crc: a pointer to store the crc for this chunk325 */326struct header_write_args {327 void *dest_buf;328 u32 dest_offset;329 struct vidtv_psi_table_header *h;330 u16 pid;331 u8 *continuity_counter;332 u32 dest_buf_sz;333 u32 *crc;334};335 336struct vidtv_psi_desc_service *vidtv_psi_service_desc_init(struct vidtv_psi_desc *head,337 enum service_type service_type,338 char *service_name,339 char *provider_name);340 341struct vidtv_psi_desc_registration342*vidtv_psi_registration_desc_init(struct vidtv_psi_desc *head,343 __be32 format_id,344 u8 *additional_ident_info,345 u32 additional_info_len);346 347struct vidtv_psi_desc_network_name348*vidtv_psi_network_name_desc_init(struct vidtv_psi_desc *head, char *network_name);349 350struct vidtv_psi_desc_service_list351*vidtv_psi_service_list_desc_init(struct vidtv_psi_desc *head,352 struct vidtv_psi_desc_service_list_entry *entry);353 354struct vidtv_psi_table_pat_program355*vidtv_psi_pat_program_init(struct vidtv_psi_table_pat_program *head,356 u16 service_id,357 u16 program_map_pid);358 359struct vidtv_psi_table_pmt_stream*360vidtv_psi_pmt_stream_init(struct vidtv_psi_table_pmt_stream *head,361 enum vidtv_psi_stream_types stream_type,362 u16 es_pid);363 364struct vidtv_psi_table_pat *vidtv_psi_pat_table_init(u16 transport_stream_id);365 366struct vidtv_psi_table_pmt *vidtv_psi_pmt_table_init(u16 program_number,367 u16 pcr_pid);368 369struct vidtv_psi_table_sdt *vidtv_psi_sdt_table_init(u16 network_id,370 u16 transport_stream_id);371 372struct vidtv_psi_table_sdt_service*373vidtv_psi_sdt_service_init(struct vidtv_psi_table_sdt_service *head,374 u16 service_id,375 bool eit_schedule,376 bool eit_present_following);377 378void379vidtv_psi_desc_destroy(struct vidtv_psi_desc *desc);380 381void382vidtv_psi_pat_program_destroy(struct vidtv_psi_table_pat_program *p);383 384void385vidtv_psi_pat_table_destroy(struct vidtv_psi_table_pat *p);386 387void388vidtv_psi_pmt_stream_destroy(struct vidtv_psi_table_pmt_stream *s);389 390void391vidtv_psi_pmt_table_destroy(struct vidtv_psi_table_pmt *pmt);392 393void394vidtv_psi_sdt_table_destroy(struct vidtv_psi_table_sdt *sdt);395 396void397vidtv_psi_sdt_service_destroy(struct vidtv_psi_table_sdt_service *service);398 399/**400 * vidtv_psi_sdt_service_assign - Assigns the service loop to the SDT.401 * @sdt: The SDT to assign to.402 * @service: The service loop (one or more services)403 *404 * This will free the previous service loop in the table.405 * This will assign ownership of the service loop to the table, i.e. the table406 * will free this service loop when a call to its destroy function is made.407 */408void409vidtv_psi_sdt_service_assign(struct vidtv_psi_table_sdt *sdt,410 struct vidtv_psi_table_sdt_service *service);411 412/**413 * vidtv_psi_desc_assign - Assigns a descriptor loop at some point414 * @to: Where to assign this descriptor loop to415 * @desc: The descriptor loop that will be assigned.416 *417 * This will free the loop in 'to', if any.418 */419void vidtv_psi_desc_assign(struct vidtv_psi_desc **to,420 struct vidtv_psi_desc *desc);421 422/**423 * vidtv_pmt_desc_assign - Assigns a descriptor loop at some point in a PMT section.424 * @pmt: The PMT section that will contain the descriptor loop425 * @to: Where in the PMT to assign this descriptor loop to426 * @desc: The descriptor loop that will be assigned.427 *428 * This will free the loop in 'to', if any.429 * This will assign ownership of the loop to the table, i.e. the table430 * will free this loop when a call to its destroy function is made.431 */432void vidtv_pmt_desc_assign(struct vidtv_psi_table_pmt *pmt,433 struct vidtv_psi_desc **to,434 struct vidtv_psi_desc *desc);435 436/**437 * vidtv_sdt_desc_assign - Assigns a descriptor loop at some point in a SDT.438 * @sdt: The SDT that will contain the descriptor loop439 * @to: Where in the PMT to assign this descriptor loop to440 * @desc: The descriptor loop that will be assigned.441 *442 * This will free the loop in 'to', if any.443 * This will assign ownership of the loop to the table, i.e. the table444 * will free this loop when a call to its destroy function is made.445 */446void vidtv_sdt_desc_assign(struct vidtv_psi_table_sdt *sdt,447 struct vidtv_psi_desc **to,448 struct vidtv_psi_desc *desc);449 450/**451 * vidtv_psi_pat_program_assign - Assigns the program loop to the PAT.452 * @pat: The PAT to assign to.453 * @p: The program loop (one or more programs)454 *455 * This will free the previous program loop in the table.456 * This will assign ownership of the program loop to the table, i.e. the table457 * will free this program loop when a call to its destroy function is made.458 */459void vidtv_psi_pat_program_assign(struct vidtv_psi_table_pat *pat,460 struct vidtv_psi_table_pat_program *p);461 462/**463 * vidtv_psi_pmt_stream_assign - Assigns the stream loop to the PAT.464 * @pmt: The PMT to assign to.465 * @s: The stream loop (one or more streams)466 *467 * This will free the previous stream loop in the table.468 * This will assign ownership of the stream loop to the table, i.e. the table469 * will free this stream loop when a call to its destroy function is made.470 */471void vidtv_psi_pmt_stream_assign(struct vidtv_psi_table_pmt *pmt,472 struct vidtv_psi_table_pmt_stream *s);473 474struct vidtv_psi_desc *vidtv_psi_desc_clone(struct vidtv_psi_desc *desc);475 476/**477 * vidtv_psi_pmt_create_sec_for_each_pat_entry - Create a PMT section for each478 * program found in the PAT479 * @pat: The PAT to look for programs.480 * @pcr_pid: packet ID for the PCR to be used for the program described in this481 * PMT section482 */483struct vidtv_psi_table_pmt**484vidtv_psi_pmt_create_sec_for_each_pat_entry(struct vidtv_psi_table_pat *pat, u16 pcr_pid);485 486/**487 * vidtv_psi_pmt_get_pid - Get the TS PID for a PMT section.488 * @section: The PMT section whose PID we want to retrieve.489 * @pat: The PAT table to look into.490 *491 * Returns: the TS PID for 'section'492 */493u16 vidtv_psi_pmt_get_pid(struct vidtv_psi_table_pmt *section,494 struct vidtv_psi_table_pat *pat);495 496/**497 * vidtv_psi_pat_table_update_sec_len - Recompute and update the PAT section length.498 * @pat: The PAT whose length is to be updated.499 *500 * This will traverse the table and accumulate the length of its components,501 * which is then used to replace the 'section_length' field.502 *503 * If section_length > MAX_SECTION_LEN, the operation fails.504 */505void vidtv_psi_pat_table_update_sec_len(struct vidtv_psi_table_pat *pat);506 507/**508 * vidtv_psi_pmt_table_update_sec_len - Recompute and update the PMT section length.509 * @pmt: The PMT whose length is to be updated.510 *511 * This will traverse the table and accumulate the length of its components,512 * which is then used to replace the 'section_length' field.513 *514 * If section_length > MAX_SECTION_LEN, the operation fails.515 */516void vidtv_psi_pmt_table_update_sec_len(struct vidtv_psi_table_pmt *pmt);517 518/**519 * vidtv_psi_sdt_table_update_sec_len - Recompute and update the SDT section length.520 * @sdt: The SDT whose length is to be updated.521 *522 * This will traverse the table and accumulate the length of its components,523 * which is then used to replace the 'section_length' field.524 *525 * If section_length > MAX_SECTION_LEN, the operation fails.526 */527void vidtv_psi_sdt_table_update_sec_len(struct vidtv_psi_table_sdt *sdt);528 529/**530 * struct vidtv_psi_pat_write_args - Arguments for writing a PAT table531 * @buf: The destination buffer.532 * @offset: The offset into the destination buffer.533 * @pat: A pointer to the PAT.534 * @buf_sz: The size of the destination buffer.535 * @continuity_counter: A pointer to the CC. Incremented on every new packet.536 *537 */538struct vidtv_psi_pat_write_args {539 char *buf;540 u32 offset;541 struct vidtv_psi_table_pat *pat;542 u32 buf_sz;543 u8 *continuity_counter;544};545 546/**547 * vidtv_psi_pat_write_into - Write PAT as MPEG-TS packets into a buffer.548 * @args: An instance of struct vidtv_psi_pat_write_args549 *550 * This function writes the MPEG TS packets for a PAT table into a buffer.551 * Calling code will usually generate the PAT via a call to its init function552 * and thus is responsible for freeing it.553 *554 * Return: The number of bytes written into the buffer. This is NOT555 * equal to the size of the PAT, since more space is needed for TS headers during TS556 * encapsulation.557 */558u32 vidtv_psi_pat_write_into(struct vidtv_psi_pat_write_args *args);559 560/**561 * struct vidtv_psi_sdt_write_args - Arguments for writing a SDT table562 * @buf: The destination buffer.563 * @offset: The offset into the destination buffer.564 * @sdt: A pointer to the SDT.565 * @buf_sz: The size of the destination buffer.566 * @continuity_counter: A pointer to the CC. Incremented on every new packet.567 *568 */569 570struct vidtv_psi_sdt_write_args {571 char *buf;572 u32 offset;573 struct vidtv_psi_table_sdt *sdt;574 u32 buf_sz;575 u8 *continuity_counter;576};577 578/**579 * vidtv_psi_sdt_write_into - Write SDT as MPEG-TS packets into a buffer.580 * @args: an instance of struct vidtv_psi_sdt_write_args581 *582 * This function writes the MPEG TS packets for a SDT table into a buffer.583 * Calling code will usually generate the SDT via a call to its init function584 * and thus is responsible for freeing it.585 *586 * Return: The number of bytes written into the buffer. This is NOT587 * equal to the size of the SDT, since more space is needed for TS headers during TS588 * encapsulation.589 */590u32 vidtv_psi_sdt_write_into(struct vidtv_psi_sdt_write_args *args);591 592/**593 * struct vidtv_psi_pmt_write_args - Arguments for writing a PMT section594 * @buf: The destination buffer.595 * @offset: The offset into the destination buffer.596 * @pmt: A pointer to the PMT.597 * @pid: Program ID598 * @buf_sz: The size of the destination buffer.599 * @continuity_counter: A pointer to the CC. Incremented on every new packet.600 * @pcr_pid: The TS PID used for the PSI packets. All channels will share the601 * same PCR.602 */603struct vidtv_psi_pmt_write_args {604 char *buf;605 u32 offset;606 struct vidtv_psi_table_pmt *pmt;607 u16 pid;608 u32 buf_sz;609 u8 *continuity_counter;610 u16 pcr_pid;611};612 613/**614 * vidtv_psi_pmt_write_into - Write PMT as MPEG-TS packets into a buffer.615 * @args: an instance of struct vidtv_psi_pmt_write_args616 *617 * This function writes the MPEG TS packets for a PMT section into a buffer.618 * Calling code will usually generate the PMT section via a call to its init function619 * and thus is responsible for freeing it.620 *621 * Return: The number of bytes written into the buffer. This is NOT622 * equal to the size of the PMT section, since more space is needed for TS headers623 * during TS encapsulation.624 */625u32 vidtv_psi_pmt_write_into(struct vidtv_psi_pmt_write_args *args);626 627/**628 * vidtv_psi_find_pmt_sec - Finds the PMT section for 'program_num'629 * @pmt_sections: The sections to look into.630 * @nsections: The number of sections.631 * @program_num: The 'program_num' from PAT pointing to a PMT section.632 *633 * Return: A pointer to the PMT, if found, or NULL.634 */635struct vidtv_psi_table_pmt *vidtv_psi_find_pmt_sec(struct vidtv_psi_table_pmt **pmt_sections,636 u16 nsections,637 u16 program_num);638 639u16 vidtv_psi_get_pat_program_pid(struct vidtv_psi_table_pat_program *p);640u16 vidtv_psi_pmt_stream_get_elem_pid(struct vidtv_psi_table_pmt_stream *s);641 642/**643 * struct vidtv_psi_table_transport - A entry in the TS loop for the NIT and/or other tables.644 * See ETSI 300 468 section 5.2.1645 * @transport_id: The TS ID being described646 * @network_id: The network_id that contains the TS ID647 * @bitfield: Contains the descriptor loop length648 * @descriptor: A descriptor loop649 * @next: Pointer to the next entry650 *651 */652struct vidtv_psi_table_transport {653 __be16 transport_id;654 __be16 network_id;655 __be16 bitfield; /* desc_len: 12, reserved: 4 */656 struct vidtv_psi_desc *descriptor;657 struct vidtv_psi_table_transport *next;658} __packed;659 660/**661 * struct vidtv_psi_table_nit - A Network Information Table (NIT). See ETSI 300662 * 468 section 5.2.1663 * @header: A PSI table header664 * @bitfield: Contains the network descriptor length665 * @descriptor: A descriptor loop describing the network666 * @bitfield2: Contains the transport stream loop length667 * @transport: The transport stream loop668 *669 */670struct vidtv_psi_table_nit {671 struct vidtv_psi_table_header header;672 __be16 bitfield; /* network_desc_len: 12, reserved:4 */673 struct vidtv_psi_desc *descriptor;674 __be16 bitfield2; /* ts_loop_len: 12, reserved: 4 */675 struct vidtv_psi_table_transport *transport;676} __packed;677 678struct vidtv_psi_table_nit679*vidtv_psi_nit_table_init(u16 network_id,680 u16 transport_stream_id,681 char *network_name,682 struct vidtv_psi_desc_service_list_entry *service_list);683 684/**685 * struct vidtv_psi_nit_write_args - Arguments for writing a NIT section686 * @buf: The destination buffer.687 * @offset: The offset into the destination buffer.688 * @nit: A pointer to the NIT689 * @buf_sz: The size of the destination buffer.690 * @continuity_counter: A pointer to the CC. Incremented on every new packet.691 *692 */693struct vidtv_psi_nit_write_args {694 char *buf;695 u32 offset;696 struct vidtv_psi_table_nit *nit;697 u32 buf_sz;698 u8 *continuity_counter;699};700 701/**702 * vidtv_psi_nit_write_into - Write NIT as MPEG-TS packets into a buffer.703 * @args: an instance of struct vidtv_psi_nit_write_args704 *705 * This function writes the MPEG TS packets for a NIT table into a buffer.706 * Calling code will usually generate the NIT via a call to its init function707 * and thus is responsible for freeing it.708 *709 * Return: The number of bytes written into the buffer. This is NOT710 * equal to the size of the NIT, since more space is needed for TS headers during TS711 * encapsulation.712 */713u32 vidtv_psi_nit_write_into(struct vidtv_psi_nit_write_args *args);714 715void vidtv_psi_nit_table_destroy(struct vidtv_psi_table_nit *nit);716 717/*718 * struct vidtv_psi_desc_short_event - A short event descriptor719 * see ETSI EN 300 468 v1.15.1 section 6.2.37720 */721struct vidtv_psi_table_eit_event {722 __be16 event_id;723 u8 start_time[5];724 u8 duration[3];725 __be16 bitfield; /* desc_length: 12, free_CA_mode: 1, running_status: 1 */726 struct vidtv_psi_desc *descriptor;727 struct vidtv_psi_table_eit_event *next;728} __packed;729 730/*731 * struct vidtv_psi_table_eit - A Event Information Table (EIT)732 * See ETSI 300 468 section 5.2.4733 */734struct vidtv_psi_table_eit {735 struct vidtv_psi_table_header header;736 __be16 transport_id;737 __be16 network_id;738 u8 last_segment;739 u8 last_table_id;740 struct vidtv_psi_table_eit_event *event;741} __packed;742 743struct vidtv_psi_table_eit744*vidtv_psi_eit_table_init(u16 network_id,745 u16 transport_stream_id,746 __be16 service_id);747 748/**749 * struct vidtv_psi_eit_write_args - Arguments for writing an EIT section750 * @buf: The destination buffer.751 * @offset: The offset into the destination buffer.752 * @eit: A pointer to the EIT753 * @buf_sz: The size of the destination buffer.754 * @continuity_counter: A pointer to the CC. Incremented on every new packet.755 *756 */757struct vidtv_psi_eit_write_args {758 char *buf;759 u32 offset;760 struct vidtv_psi_table_eit *eit;761 u32 buf_sz;762 u8 *continuity_counter;763};764 765/**766 * vidtv_psi_eit_write_into - Write EIT as MPEG-TS packets into a buffer.767 * @args: an instance of struct vidtv_psi_nit_write_args768 *769 * This function writes the MPEG TS packets for a EIT table into a buffer.770 * Calling code will usually generate the EIT via a call to its init function771 * and thus is responsible for freeing it.772 *773 * Return: The number of bytes written into the buffer. This is NOT774 * equal to the size of the EIT, since more space is needed for TS headers during TS775 * encapsulation.776 */777u32 vidtv_psi_eit_write_into(struct vidtv_psi_eit_write_args *args);778 779void vidtv_psi_eit_table_destroy(struct vidtv_psi_table_eit *eit);780 781/**782 * vidtv_psi_eit_table_update_sec_len - Recompute and update the EIT section length.783 * @eit: The EIT whose length is to be updated.784 *785 * This will traverse the table and accumulate the length of its components,786 * which is then used to replace the 'section_length' field.787 *788 * If section_length > EIT_MAX_SECTION_LEN, the operation fails.789 */790void vidtv_psi_eit_table_update_sec_len(struct vidtv_psi_table_eit *eit);791 792/**793 * vidtv_psi_eit_event_assign - Assigns the event loop to the EIT.794 * @eit: The EIT to assign to.795 * @e: The event loop796 *797 * This will free the previous event loop in the table.798 * This will assign ownership of the stream loop to the table, i.e. the table799 * will free this stream loop when a call to its destroy function is made.800 */801void vidtv_psi_eit_event_assign(struct vidtv_psi_table_eit *eit,802 struct vidtv_psi_table_eit_event *e);803 804struct vidtv_psi_table_eit_event805*vidtv_psi_eit_event_init(struct vidtv_psi_table_eit_event *head, u16 event_id);806 807void vidtv_psi_eit_event_destroy(struct vidtv_psi_table_eit_event *e);808 809#endif // VIDTV_PSI_H810