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 might 6 * 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. Almeida 10 */ 11 12 #ifndef VIDTV_PSI_H 13 #define VIDTV_PSI_H 14 15 #include <linux/types.h> 16 17 /* 18 * all section lengths start immediately after the 'section_length' field 19 * see ISO/IEC 13818-1 : 2000 and ETSI EN 300 468 V 1.10.1 for 20 * reference 21 */ 22 #define PAT_LEN_UNTIL_LAST_SECTION_NUMBER 5 23 #define PMT_LEN_UNTIL_PROGRAM_INFO_LENGTH 9 24 #define SDT_LEN_UNTIL_RESERVED_FOR_FUTURE_USE 8 25 #define NIT_LEN_UNTIL_NETWORK_DESCRIPTOR_LEN 7 26 #define EIT_LEN_UNTIL_LAST_TABLE_ID 11 27 #define MAX_SECTION_LEN 1021 28 #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 34 enum 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 42 enum 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 portion 49 * of the descriptor following the byte defining the value of this field. 50 */ 51 struct 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 */ 62 struct 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.8 77 */ 78 struct 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 Registration 85 * 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, are 90 * defined by the assignee of that format_identifier, and once defined 91 * they shall not change. 92 */ 93 u8 additional_identification_info[]; 94 } __packed; 95 96 /* 97 * struct vidtv_psi_desc_network_name - A network name descriptor 98 * see ETSI EN 300 468 v1.15.1 section 6.2.27 99 */ 100 struct vidtv_psi_desc_network_name { 101 struct vidtv_psi_desc *next; 102 u8 type; 103 u8 length; 104 char *network_name; 105 } __packed; 106 107 struct 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 descriptor 115 * see ETSI EN 300 468 v1.15.1 section 6.2.35 116 */ 117 struct 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 descriptor 126 * see ETSI EN 300 468 v1.15.1 section 6.2.37 127 */ 128 struct 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 139 struct vidtv_psi_desc_short_event 140 *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 */ 148 struct 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 PAT 163 * See ISO/IEC 13818-1 : 2000 p.43 164 */ 165 struct 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.43 174 */ 175 struct 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 */ 186 struct 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 Table 198 * see ETSI EN 300 468 v1.15.1 section 5.2.3. 199 */ 200 201 struct 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 */ 212 enum 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 */ 220 enum 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 */ 230 struct 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 */ 242 struct 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_buffer 261 * @crc: a pointer to store the crc for this chunk 262 */ 263 struct 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 descriptor 281 * @pid: TS packet ID. 282 * @continuity_counter: Incremented on every new packet. 283 * @dest_buf_sz: The size of the dest_buffer 284 * @crc: a pointer to store the crc for this chunk 285 */ 286 struct 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 of 298 * 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 write 302 * @pid: TS packet ID. 303 * @continuity_counter: Incremented on every new packet. 304 * @dest_buf_sz: The size of the dest_buffer 305 */ 306 struct 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 table 317 * header 318 * @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_buffer 324 * @crc: a pointer to store the crc for this chunk 325 */ 326 struct 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 336 struct 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 341 struct vidtv_psi_desc_registration 342 *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 347 struct vidtv_psi_desc_network_name 348 *vidtv_psi_network_name_desc_init(struct vidtv_psi_desc *head, char *network_name); 349 350 struct vidtv_psi_desc_service_list 351 *vidtv_psi_service_list_desc_init(struct vidtv_psi_desc *head, 352 struct vidtv_psi_desc_service_list_entry *entry); 353 354 struct vidtv_psi_table_pat_program 355 *vidtv_psi_pat_program_init(struct vidtv_psi_table_pat_program *head, 356 u16 service_id, 357 u16 program_map_pid); 358 359 struct vidtv_psi_table_pmt_stream* 360 vidtv_psi_pmt_stream_init(struct vidtv_psi_table_pmt_stream *head, 361 enum vidtv_psi_stream_types stream_type, 362 u16 es_pid); 363 364 struct vidtv_psi_table_pat *vidtv_psi_pat_table_init(u16 transport_stream_id); 365 366 struct vidtv_psi_table_pmt *vidtv_psi_pmt_table_init(u16 program_number, 367 u16 pcr_pid); 368 369 struct vidtv_psi_table_sdt *vidtv_psi_sdt_table_init(u16 network_id, 370 u16 transport_stream_id); 371 372 struct vidtv_psi_table_sdt_service* 373 vidtv_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 378 void 379 vidtv_psi_desc_destroy(struct vidtv_psi_desc *desc); 380 381 void 382 vidtv_psi_pat_program_destroy(struct vidtv_psi_table_pat_program *p); 383 384 void 385 vidtv_psi_pat_table_destroy(struct vidtv_psi_table_pat *p); 386 387 void 388 vidtv_psi_pmt_stream_destroy(struct vidtv_psi_table_pmt_stream *s); 389 390 void 391 vidtv_psi_pmt_table_destroy(struct vidtv_psi_table_pmt *pmt); 392 393 void 394 vidtv_psi_sdt_table_destroy(struct vidtv_psi_table_sdt *sdt); 395 396 void 397 vidtv_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 table 406 * will free this service loop when a call to its destroy function is made. 407 */ 408 void 409 vidtv_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 point 414 * @to: Where to assign this descriptor loop to 415 * @desc: The descriptor loop that will be assigned. 416 * 417 * This will free the loop in 'to', if any. 418 */ 419 void 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 loop 425 * @to: Where in the PMT to assign this descriptor loop to 426 * @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 table 430 * will free this loop when a call to its destroy function is made. 431 */ 432 void 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 loop 439 * @to: Where in the PMT to assign this descriptor loop to 440 * @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 table 444 * will free this loop when a call to its destroy function is made. 445 */ 446 void 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 table 457 * will free this program loop when a call to its destroy function is made. 458 */ 459 void 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 table 469 * will free this stream loop when a call to its destroy function is made. 470 */ 471 void vidtv_psi_pmt_stream_assign(struct vidtv_psi_table_pmt *pmt, 472 struct vidtv_psi_table_pmt_stream *s); 473 474 struct 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 each 478 * program found in the PAT 479 * @pat: The PAT to look for programs. 480 * @pcr_pid: packet ID for the PCR to be used for the program described in this 481 * PMT section 482 */ 483 struct vidtv_psi_table_pmt** 484 vidtv_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 */ 493 u16 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 */ 505 void 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 */ 516 void 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 */ 527 void 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 table 531 * @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 */ 538 struct 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_args 549 * 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 function 552 * and thus is responsible for freeing it. 553 * 554 * Return: The number of bytes written into the buffer. This is NOT 555 * equal to the size of the PAT, since more space is needed for TS headers during TS 556 * encapsulation. 557 */ 558 u32 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 table 562 * @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 570 struct 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_args 581 * 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 function 584 * and thus is responsible for freeing it. 585 * 586 * Return: The number of bytes written into the buffer. This is NOT 587 * equal to the size of the SDT, since more space is needed for TS headers during TS 588 * encapsulation. 589 */ 590 u32 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 section 594 * @buf: The destination buffer. 595 * @offset: The offset into the destination buffer. 596 * @pmt: A pointer to the PMT. 597 * @pid: Program ID 598 * @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 the 601 * same PCR. 602 */ 603 struct 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_args 616 * 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 function 619 * and thus is responsible for freeing it. 620 * 621 * Return: The number of bytes written into the buffer. This is NOT 622 * equal to the size of the PMT section, since more space is needed for TS headers 623 * during TS encapsulation. 624 */ 625 u32 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 */ 635 struct vidtv_psi_table_pmt *vidtv_psi_find_pmt_sec(struct vidtv_psi_table_pmt **pmt_sections, 636 u16 nsections, 637 u16 program_num); 638 639 u16 vidtv_psi_get_pat_program_pid(struct vidtv_psi_table_pat_program *p); 640 u16 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.1 645 * @transport_id: The TS ID being described 646 * @network_id: The network_id that contains the TS ID 647 * @bitfield: Contains the descriptor loop length 648 * @descriptor: A descriptor loop 649 * @next: Pointer to the next entry 650 * 651 */ 652 struct 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 300 662 * 468 section 5.2.1 663 * @header: A PSI table header 664 * @bitfield: Contains the network descriptor length 665 * @descriptor: A descriptor loop describing the network 666 * @bitfield2: Contains the transport stream loop length 667 * @transport: The transport stream loop 668 * 669 */ 670 struct 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 678 struct vidtv_psi_table_nit 679 *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 section 686 * @buf: The destination buffer. 687 * @offset: The offset into the destination buffer. 688 * @nit: A pointer to the NIT 689 * @buf_sz: The size of the destination buffer. 690 * @continuity_counter: A pointer to the CC. Incremented on every new packet. 691 * 692 */ 693 struct 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_args 704 * 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 function 707 * and thus is responsible for freeing it. 708 * 709 * Return: The number of bytes written into the buffer. This is NOT 710 * equal to the size of the NIT, since more space is needed for TS headers during TS 711 * encapsulation. 712 */ 713 u32 vidtv_psi_nit_write_into(struct vidtv_psi_nit_write_args *args); 714 715 void vidtv_psi_nit_table_destroy(struct vidtv_psi_table_nit *nit); 716 717 /* 718 * struct vidtv_psi_desc_short_event - A short event descriptor 719 * see ETSI EN 300 468 v1.15.1 section 6.2.37 720 */ 721 struct 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.4 733 */ 734 struct 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 743 struct vidtv_psi_table_eit 744 *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 section 750 * @buf: The destination buffer. 751 * @offset: The offset into the destination buffer. 752 * @eit: A pointer to the EIT 753 * @buf_sz: The size of the destination buffer. 754 * @continuity_counter: A pointer to the CC. Incremented on every new packet. 755 * 756 */ 757 struct 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_args 768 * 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 function 771 * and thus is responsible for freeing it. 772 * 773 * Return: The number of bytes written into the buffer. This is NOT 774 * equal to the size of the EIT, since more space is needed for TS headers during TS 775 * encapsulation. 776 */ 777 u32 vidtv_psi_eit_write_into(struct vidtv_psi_eit_write_args *args); 778 779 void 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 */ 790 void 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 loop 796 * 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 table 799 * will free this stream loop when a call to its destroy function is made. 800 */ 801 void vidtv_psi_eit_event_assign(struct vidtv_psi_table_eit *eit, 802 struct vidtv_psi_table_eit_event *e); 803 804 struct vidtv_psi_table_eit_event 805 *vidtv_psi_eit_event_init(struct vidtv_psi_table_eit_event *head, u16 event_id); 806 807 void vidtv_psi_eit_event_destroy(struct vidtv_psi_table_eit_event *e); 808 809 #endif // VIDTV_PSI_H 810