1 /*****************************************************************************
2 * dvb_gen_si.c: Generate SI tables and descriptors
3 *****************************************************************************
4 * Copyright (c) 2011 Unix Solutions Ltd.
5 * Copyright (c) 2015 VideoLAN
6 *
7 * Authors:
8 * Georgi Chorbadzhiyski <gf@unixsol.org>
9 * Christophe Massiot <massiot@via.ecp.fr>
10 *
11 * Permission is hereby granted, free of charge, to any person obtaining
12 * a copy of this software and associated documentation files (the
13 * "Software"), to deal in the Software without restriction, including
14 * without limitation the rights to use, copy, modify, merge, publish,
15 * distribute, sublicense, and/or sell copies of the Software, and to
16 * permit persons to whom the Software is furnished to do so, subject
17 * to the following conditions:
18 *
19 * The above copyright notice and this permission notice shall be
20 * included in all copies or substantial portions of the Software.
21 *
22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
25 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
26 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
27 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
28 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 *****************************************************************************/
30
31 #include <stdlib.h>
32 #include <stdint.h>
33 #include <stdbool.h>
34 #include <inttypes.h>
35 #include <string.h>
36 #include <stdio.h>
37 #include <unistd.h>
38 #include <errno.h>
39
40 #include <bitstream/mpeg/ts.h>
41 #include <bitstream/mpeg/psi.h>
42 #include <bitstream/dvb/si.h>
43 #include <bitstream/dvb/si_print.h>
44 #include <bitstream/scte/35.h>
45 #include <bitstream/scte/35_print.h>
46
47 uint16_t tsid = 10000;
48 uint16_t sid = 20000;
49 uint16_t event_id = 30000;
50 uint16_t onid = 40000;
51
52 uint16_t pmt_pid = 100;
53 uint16_t scte35_pid = 200;
54
55 time_t ts_0 = 1234567890;
56 time_t ts_1 = 1;
57 time_t ts_2 = 999999999;
58 time_t ts_3 = 0x7fffffff;
59
60 uint8_t cc = 0;
61
62 /* =========================================================================
63 * MPEG defined descriptors
64 * ========================================================================= */
65
66 /* MPEG Descriptor 0x02: Video stream descriptor */
build_desc02_1(uint8_t * desc)67 static void build_desc02_1(uint8_t *desc) {
68 desc02_init(desc);
69 desc02_set_multiple_frame_rate (desc, true);
70 desc02_set_frame_rate_code (desc, 3); // 25.00
71 desc02_set_mpeg1_only_flag (desc, true);
72 desc02_set_constraint_parameter(desc, true);
73 desc02_set_still_picture (desc, true);
74 }
75
build_desc02_2(uint8_t * desc)76 static void build_desc02_2(uint8_t *desc) {
77 desc02_init(desc);
78 desc02_set_multiple_frame_rate (desc, true);
79 desc02_set_frame_rate_code (desc, 4); // 29.97
80 desc02_set_mpeg1_only_flag (desc, false); // Allow more flags
81 desc02_set_constraint_parameter(desc, true);
82 desc02_set_still_picture (desc, true);
83 desc02_set_profile (desc, 4); // Main
84 desc02_set_level (desc, 8); // Main
85 desc02_set_chroma_format (desc, 2); // 4:2:2
86 desc02_set_frame_rate_extension(desc, false);
87 }
88
89 /* MPEG Descriptor 0x03: Audio stream descriptor */
build_desc03(uint8_t * desc)90 static void build_desc03(uint8_t *desc) {
91 desc03_init(desc);
92 desc03_set_free_format_flag(desc, true);
93 desc03_set_ID(desc, true);
94 desc03_set_layer(desc, 2); // Layer II
95 desc03_set_vbr_flag(desc, true);
96 }
97
98 /* MPEG Descriptor 0x04: Hierarchy descriptor */
build_desc04(uint8_t * desc)99 static void build_desc04(uint8_t *desc) {
100 desc04_init(desc);
101 desc04_set_type(desc, 1);
102 desc04_set_layer_index(desc, 6);
103 desc04_set_embedded_layer_index(desc, 7);
104 desc04_set_channel(desc, 8);
105 }
106
107 /* MPEG Descriptor 0x05: Registration descriptor */
build_desc05(uint8_t * desc)108 static void build_desc05(uint8_t *desc) {
109 desc05_init(desc);
110 desc05_set_identifier(desc, (uint8_t *)"TEST");
111 }
112
113 /* MPEG Descriptor 0x06: Data stream alignment descriptor */
build_desc06(uint8_t * desc)114 static void build_desc06(uint8_t *desc) {
115 desc06_init(desc);
116 desc06_set_alignment(desc, 2); // Video access unit
117 }
118
119 /* MPEG Descriptor 0x07: Target Background Grid descriptor */
build_desc07(uint8_t * desc)120 static void build_desc07(uint8_t *desc) {
121 desc07_init(desc);
122 desc07_set_horizontal_size(desc, 720);
123 desc07_set_vertical_size(desc, 576);
124 desc07_set_aspect_ratio_info(desc, 7);
125 }
126
127 /* MPEG Descriptor 0x08: Video Window descriptor */
build_desc08(uint8_t * desc)128 static void build_desc08(uint8_t *desc) {
129 desc08_init(desc);
130 desc08_set_horizontal_offset(desc, 1024);
131 desc08_set_vertical_offset(desc, 768);
132 desc08_set_window_priority(desc, 15);
133 }
134
135 /* MPEG Descriptor 0x09: Conditional access descriptor */
build_desc09(uint8_t * desc)136 static void build_desc09(uint8_t *desc) {
137 desc09_init(desc);
138 desc09_set_sysid(desc, 0xb000);
139 desc09_set_pid(desc, 1234);
140 }
141
142 /* MPEG Descriptor 0x0A: ISO-639 language descriptor */
build_desc0a(uint8_t * desc)143 static void build_desc0a(uint8_t *desc) {
144 uint8_t k = 0;
145 uint8_t *lang_n;
146
147 desc0a_init(desc);
148 desc_set_length(desc, 255);
149
150 lang_n = desc0a_get_language(desc, k++);
151 desc0an_set_code(lang_n, (uint8_t *)"eng");
152 desc0an_set_audiotype(lang_n, 0);
153
154 lang_n = desc0a_get_language(desc, k++);
155 desc0an_set_code(lang_n, (uint8_t *)"eng");
156 desc0an_set_audiotype(lang_n, 1);
157
158 lang_n = desc0a_get_language(desc, k++);
159 desc0an_set_code(lang_n, (uint8_t *)"eng");
160 desc0an_set_audiotype(lang_n, 2);
161
162 lang_n = desc0a_get_language(desc, k++);
163 desc0an_set_code(lang_n, (uint8_t *)"eng");
164 desc0an_set_audiotype(lang_n, 3);
165
166 lang_n = desc0a_get_language(desc, k++);
167 desc0an_set_code(lang_n, (uint8_t *)"bul");
168 desc0an_set_audiotype(lang_n, 4);
169
170 lang_n = desc0a_get_language(desc, k++);
171 desc0an_set_code(lang_n, (uint8_t *)"bul");
172 desc0an_set_audiotype(lang_n, 0);
173
174 lang_n = desc0a_get_language(desc, k);
175 desc_set_length(desc, lang_n - desc - DESC_HEADER_SIZE);
176 }
177
178 /* MPEG Descriptor 0x0B: System clock descriptor */
build_desc0b(uint8_t * desc)179 static void build_desc0b(uint8_t *desc) {
180 desc0b_init(desc);
181 desc0b_set_external_clock_reference_indicator(desc, true);
182 desc0b_set_clock_accuracy_integer(desc, 60);
183 desc0b_set_clock_accuracy_exponent(desc, 4);
184 }
185
186 /* MPEG Descriptor 0x0C: Multiplex buffer utilization descriptor */
build_desc0c(uint8_t * desc)187 static void build_desc0c(uint8_t *desc) {
188 desc0c_init(desc);
189 desc0c_set_bound_valid(desc, true);
190 desc0c_set_LTW_offset_lower_bound(desc, 1234);
191 desc0c_set_LTW_offset_upper_bound(desc, 5678);
192 }
193
194 /* MPEG Descriptor 0x0D: Copyright descriptor */
build_desc0d(uint8_t * desc)195 static void build_desc0d(uint8_t *desc) {
196 desc0d_init(desc);
197 desc0d_set_copyright_identifier(desc, 0x12345678);
198 desc0d_set_additional_copyright_info(desc, (uint8_t *)"ABCD", 4);
199 }
200
201 /* MPEG Descriptor 0x0E: Maximum bitrate descriptor */
build_desc0e(uint8_t * desc)202 static void build_desc0e(uint8_t *desc) {
203 desc0e_init(desc);
204 desc0e_set_max_bitrate(desc, 123456);
205 }
206
207 /* MPEG Descriptor 0x0F: Private data indicator descriptor */
build_desc0f(uint8_t * desc)208 static void build_desc0f(uint8_t *desc) {
209 desc0f_init(desc);
210 desc0f_set_private_indicator(desc, 0xaabbccdd);
211 }
212
213 /* MPEG Descriptor 0x10: Smoothing buffer descriptor */
build_desc10(uint8_t * desc)214 static void build_desc10(uint8_t *desc) {
215 desc10_init(desc);
216 desc10_set_sb_leak_rate(desc, 112233);
217 desc10_set_sb_size(desc, 4112233);
218 }
219
220 /* MPEG Descriptor 0x11: STD descriptor */
build_desc11(uint8_t * desc)221 static void build_desc11(uint8_t *desc) {
222 desc11_init(desc);
223 desc11_set_leak_valid_flag(desc, true);
224 }
225
226 /* MPEG Descriptor 0x12: IBP descriptor */
build_desc12(uint8_t * desc)227 static void build_desc12(uint8_t *desc) {
228 desc12_init(desc);
229 desc12_set_closed_gop_flag(desc, true);
230 desc12_set_identical_gop_flag(desc, false);
231 desc12_set_max_gop_length(desc, 5000);
232 }
233
234 /* MPEG Descriptor 0x1b: MPEG4 Video descriptor */
build_desc1b(uint8_t * desc)235 static void build_desc1b(uint8_t *desc) {
236 desc1b_init(desc);
237 desc1b_set_mpeg4_visual_profile_and_level(desc, 0x12);
238 }
239
240 /* MPEG Descriptor 0x1c: MPEG4 Audio descriptor */
build_desc1c(uint8_t * desc)241 static void build_desc1c(uint8_t *desc) {
242 desc1c_init(desc);
243 desc1c_set_mpeg4_audio_profile_and_level(desc, 0x13);
244 }
245
246 /* MPEG Descriptor 0x1d: IOD descriptor */
build_desc1d(uint8_t * desc)247 static void build_desc1d(uint8_t *desc) {
248 desc1d_init(desc);
249 desc1d_set_scope(desc, 0x01);
250 desc1d_set_iod_label(desc, 0x23);
251 desc1d_set_iod(desc, 0x45);
252 }
253
254 /* MPEG Descriptor 0x1e: SL descriptor */
build_desc1e(uint8_t * desc)255 static void build_desc1e(uint8_t *desc) {
256 desc1e_init(desc);
257 desc1e_set_es_id(desc, 0x1234);
258 }
259
260 /* MPEG Descriptor 0x1f: FMC descriptor */
build_desc1f(uint8_t * desc)261 static void build_desc1f(uint8_t *desc) {
262 uint8_t k = 0;
263 uint8_t *entry_n;
264
265 desc1f_init(desc);
266 desc_set_length(desc, 255);
267
268 entry_n = desc1f_get_entry(desc, k++);
269 desc1fn_set_es_id(entry_n, 0x1122);
270 desc1fn_set_flexmux_channel(entry_n, 0x33);
271
272 entry_n = desc1f_get_entry(desc, k++);
273 desc1fn_set_es_id(entry_n, 0x4455);
274 desc1fn_set_flexmux_channel(entry_n, 0x66);
275
276 entry_n = desc1f_get_entry(desc, k++);
277 desc1fn_set_es_id(entry_n, 0x7788);
278 desc1fn_set_flexmux_channel(entry_n, 0x99);
279
280 entry_n = desc1f_get_entry(desc, k);
281 desc_set_length(desc, entry_n - desc - DESC_HEADER_SIZE);
282 }
283
284 /* MPEG Descriptor 0x20: External ES_ID descriptor */
build_desc20(uint8_t * desc)285 static void build_desc20(uint8_t *desc) {
286 desc20_init(desc);
287 desc20_set_external_es_id(desc, 0x1234);
288 }
289
290 /* MPEG Descriptor 0x21: MuxCode descriptor */
build_desc21(uint8_t * desc)291 static void build_desc21(uint8_t *desc) {
292 uint8_t n = 0, k = 0, r;
293 uint8_t *entry_n, *entry_k;
294
295 desc21_init(desc);
296 desc_set_length(desc, 255);
297
298 entry_n = desc21_get_entry(desc, n++);
299 desc21n_set_muxcode(entry_n, 1);
300 desc21n_set_version(entry_n, 1);
301 desc21n_set_length(entry_n, DESC21_ENTRY_HEADER_SIZE - 1);
302 desc21n_set_substruct_count(entry_n, 0);
303
304 entry_n = desc21_get_entry(desc, n++);
305 desc21n_set_muxcode(entry_n, 2);
306 desc21n_set_version(entry_n, 2);
307 desc21n_set_length(entry_n, 255);
308 desc21n_set_substruct_count(entry_n, 255);
309 {
310 k = 0;
311 entry_k = desc21n_get_substruct(entry_n, k++);
312 desc21k_set_repetition_count(entry_k, 1);
313 desc21k_set_slot_count(entry_k, 0);
314
315 entry_k = desc21n_get_substruct(entry_n, k++);
316 desc21k_set_repetition_count(entry_k, 5);
317 desc21k_set_slot_count(entry_k, 5);
318 for (r=0; r<desc21k_get_slot_count(entry_k); r++) {
319 desc21k_set_flex_mux_channel(entry_k, r, r + 10);
320 desc21k_set_number_of_bytes(entry_k, r, r + 20);
321 }
322
323 entry_k = desc21n_get_substruct(entry_n, k++);
324 desc21k_set_repetition_count(entry_k, 3);
325 desc21k_set_slot_count(entry_k, 1);
326 for (r=0; r<desc21k_get_slot_count(entry_k); r++) {
327 desc21k_set_flex_mux_channel(entry_k, r, r + 30);
328 desc21k_set_number_of_bytes(entry_k, r, r + 40);
329 }
330
331 entry_k = desc21n_get_substruct(entry_n, k);
332 desc21n_set_length(entry_n, entry_k - entry_n - 1);
333 desc21n_set_substruct_count(entry_n, k);
334 }
335
336 entry_n = desc21_get_entry(desc, n++);
337 desc21n_set_muxcode(entry_n, 3);
338 desc21n_set_version(entry_n, 3);
339 desc21n_set_length(entry_n, DESC21_ENTRY_HEADER_SIZE - 1);
340 desc21n_set_substruct_count(entry_n, 0);
341
342 entry_n = desc21_get_entry(desc, n++);
343 desc21n_set_muxcode(entry_n, 4);
344 desc21n_set_version(entry_n, 4);
345 desc21n_set_length(entry_n, 255);
346 desc21n_set_substruct_count(entry_n, 255);
347 {
348 k = 0;
349 entry_k = desc21n_get_substruct(entry_n, k++);
350 desc21k_set_repetition_count(entry_k, 3);
351 desc21k_set_slot_count(entry_k, 2);
352 for (r=0; r<desc21k_get_slot_count(entry_k); r++) {
353 desc21k_set_flex_mux_channel(entry_k, r, r + 50);
354 desc21k_set_number_of_bytes(entry_k, r, r + 60);
355 }
356
357 entry_k = desc21n_get_substruct(entry_n, k++);
358 desc21k_set_repetition_count(entry_k, 4);
359 desc21k_set_slot_count(entry_k, 4);
360 for (r=0; r<desc21k_get_slot_count(entry_k); r++) {
361 desc21k_set_flex_mux_channel(entry_k, r, r + 70);
362 desc21k_set_number_of_bytes(entry_k, r, r + 80);
363 }
364
365 entry_k = desc21n_get_substruct(entry_n, k);
366 desc21n_set_length(entry_n, entry_k - entry_n - 1);
367 desc21n_set_substruct_count(entry_n, k);
368 }
369
370 entry_n = desc21_get_entry(desc, n);
371 desc_set_length(desc, entry_n - desc - DESC_HEADER_SIZE);
372 }
373
374 /* MPEG Descriptor 0x22: FmxBufferSize descriptor */
build_desc22(uint8_t * desc)375 static void build_desc22(uint8_t *desc) {
376 uint8_t k = 0;
377 uint8_t *entry_n;
378
379 desc22_init(desc);
380 desc22_set_default_buffer_size(desc, 0x112233);
381
382 desc_set_length(desc, 255);
383 entry_n = desc22_get_entry(desc, k++);
384 desc22n_set_flexmux_channel(entry_n, 0x11);
385 desc22n_set_flexmux_buffer_size(entry_n, 0x223344);
386
387 entry_n = desc22_get_entry(desc, k++);
388 desc22n_set_flexmux_channel(entry_n, 0x55);
389 desc22n_set_flexmux_buffer_size(entry_n, 0x667788);
390
391 entry_n = desc22_get_entry(desc, k++);
392 desc22n_set_flexmux_channel(entry_n, 0x99);
393 desc22n_set_flexmux_buffer_size(entry_n, 0xaabbcc);
394
395 entry_n = desc22_get_entry(desc, k);
396 desc_set_length(desc, entry_n - desc - DESC_HEADER_SIZE);
397 }
398
399 /* MPEG Descriptor 0x23: MultiplexBuffer descriptor */
build_desc23(uint8_t * desc)400 static void build_desc23(uint8_t *desc) {
401 desc23_init(desc);
402 desc23_set_mb_buffer_size(desc, 112233);
403 desc23_set_tb_leak_rate(desc, 445566);
404 }
405
406 /* MPEG Descriptor 0x24: Content labeling descriptor */
build_desc24_1(uint8_t * desc)407 static void build_desc24_1(uint8_t *desc) {
408 desc24_init(desc);
409
410 desc24_set_metadata_application_format(desc, 0xabcd);
411 desc24_set_content_reference_id_record_flag(desc, false);
412 desc24_set_content_time_base_indicator(desc, 0);
413
414 desc24_set_length(desc);
415 }
416
build_desc24_2(uint8_t * desc)417 static void build_desc24_2(uint8_t *desc) {
418 desc24_init(desc);
419
420 desc24_set_metadata_application_format(desc, 0xfff0);
421
422 desc24_set_content_reference_id_record_flag(desc, false);
423
424 desc24_set_content_time_base_indicator(desc, 3);
425 desc24_set_time_base_association(desc, 3, (uint8_t *)"ABC");
426
427 desc24_set_length(desc);
428 }
429
build_desc24_3(uint8_t * desc)430 static void build_desc24_3(uint8_t *desc) {
431 desc24_init(desc);
432
433 desc24_set_metadata_application_format(desc, 0xffff);
434 // Needs desc24_set_metadata_application_format(desc, 0xffff);
435 desc24_set_metadata_application_format_identifier(desc, 0xaabbccdd);
436
437 desc24_set_content_reference_id_record_flag(desc, true);
438 // Needs desc24_set_content_reference_id_record_flag(desc, true);
439 desc24_set_content_reference_id_record(desc, 3, (uint8_t *)"abc");
440
441 desc24_set_content_time_base_indicator(desc, 2);
442 // Needs desc24_set_content_time_base_indicator(desc, 1..2);
443 desc24_set_content_time_base_value (desc, 0x1F0F0F0F0); // 8337289456
444 desc24_set_metadata_time_base_value(desc, 0x1F1F1F1F1); // 8354132465
445
446 // Needs desc24_set_content_time_base_indicator(desc, 2);
447 desc24_set_content_id(desc, 100);
448
449 // Needs desc24_set_content_time_base_indicator(desc, 3..7);
450 desc24_set_time_base_association(desc, 3, (uint8_t *)"ABC");
451
452 desc24_set_length(desc);
453 }
454
455 /* MPEG Descriptor 0x25: Metadata pointer descriptor */
build_desc25(uint8_t * desc)456 static void build_desc25(uint8_t *desc) {
457 desc25_init(desc);
458
459 desc25_set_metadata_application_format(desc, 0xffff);
460 // Needs desc25_set_metadata_application_format(desc, 0xffff);
461 desc25_set_metadata_application_format_identifier(desc, 0x00112233);
462
463 desc25_set_metadata_format(desc, 0xff);
464 // Needs desc25_set_metadata_format(desc, 0xff);
465 desc25_set_metadata_format_identifier(desc, 0xdeadbeaf);
466
467 desc25_set_metadata_service_id(desc, 0x88);
468
469 desc25_set_metadata_locator_record_flag(desc, true);
470 // Needs desc25_set_metadata_locator_record_flag(desc, true);
471 desc25_set_metadata_locator_record(desc, 3, (uint8_t *)"abc");
472
473 desc25_set_mpeg_carriage_flags(desc, 1);
474 // Needs desc25_set_mpeg_carriage_flags(desc, 0..2);
475 desc25_set_program_number(desc, 1000);
476 // Needs desc25_set_mpeg_carriage_flags(desc, 1);
477 desc25_set_ts_location(desc, 2000);
478 desc25_set_ts_id(desc, 3000);
479
480 desc25_set_length(desc);
481 }
482
483 /* MPEG Descriptor 0x26: Metadata descriptor */
build_desc26_1(uint8_t * desc)484 static void build_desc26_1(uint8_t *desc) {
485 desc26_init(desc);
486
487 desc26_set_metadata_application_format(desc, 0xfff0);
488 desc26_set_metadata_format(desc, 0xf0);
489 desc26_set_metadata_service_id(desc, 0x88);
490 desc26_set_dsm_cc_flag(desc, false);
491 desc26_set_decoder_config_flags(desc, 0);
492
493 desc26_set_length(desc);
494 }
495
build_desc26_2(uint8_t * desc)496 static void build_desc26_2(uint8_t *desc) {
497 desc26_init(desc);
498
499 desc26_set_metadata_application_format(desc, 0xffff);
500 // Needs desc26_set_metadata_application_format(desc, 0xffff);
501 desc26_set_metadata_application_format_identifier(desc, 0x00112233);
502
503 desc26_set_metadata_format(desc, 0xff);
504 // Needs desc26_set_metadata_format(desc, 0xff);
505 desc26_set_metadata_format_identifier(desc, 0xdeadbeaf);
506
507 desc26_set_metadata_service_id(desc, 0x88);
508
509 desc26_set_dsm_cc_flag(desc, true);
510 // Needs desc26_set_dsm_cc_flag(desc, true);
511 desc26_set_service_identification_record(desc, 3, (uint8_t *)"abc");
512
513 desc26_set_decoder_config_flags(desc, 3);
514 // Needs desc26_set_decoder_config_flags(desc, 1);
515 desc26_set_decoder_config(desc, 3, (uint8_t *)"123");
516
517 // Needs desc26_set_decoder_config_flags(desc, 3);
518 desc26_set_dec_config_identification_record(desc, 3, (uint8_t *)"ABC");
519
520 // Needs desc26_set_mpeg_carriage_flags(desc, 4);
521 desc26_set_decoder_config_metadata_service_id(desc, 100);
522
523 desc26_set_length(desc);
524 }
525
526 /* MPEG Descriptor 0x27: Metadata STD descriptor */
build_desc27(uint8_t * desc)527 static void build_desc27(uint8_t *desc) {
528 desc27_init(desc);
529 desc27_set_input_leak_rate(desc, 12345);
530 desc27_set_buffer_size(desc, 23456);
531 desc27_set_output_leak_rate(desc, 34567);
532 }
533
534 /* MPEG Descriptor 0x28: AVC video descriptor */
build_desc28(uint8_t * desc)535 static void build_desc28(uint8_t *desc) {
536 desc28_init(desc);
537 desc28_set_profile_idc(desc, 0x12);
538 desc28_set_constraint_set0_flag(desc, true);
539 desc28_set_constraint_set1_flag(desc, true);
540 desc28_set_constraint_set2_flag(desc, false);
541 desc28_set_avc_compatible_flags(desc, 0x0a);
542 desc28_set_level_idc(desc, 0x34);
543 desc28_set_avc_still_present(desc, false);
544 desc28_set_avc_24_hour_picture_flag(desc, false);
545 }
546
547 /* MPEG Descriptor 0x2a: AVC timing and HRD descriptor */
build_desc2a(uint8_t * desc)548 static void build_desc2a(uint8_t *desc) {
549 desc2a_init(desc);
550 desc2a_set_hrd_management_valid_flag(desc, false);
551 desc2a_set_picture_and_timing_info_present(desc, true);
552 desc2a_set_90khz_flag(desc, false); // depends on picture_and_timing_info
553 desc2a_set_N(desc, 12345678); // depends on 90khz == false
554 desc2a_set_K(desc, 34567890); // depends on 90khz == false
555 desc2a_set_num_units_in_tick(desc, 456789); // depends on picture_and_timing_info
556 desc2a_set_fixed_frame_rate_flag(desc, true);
557 desc2a_set_temporal_poc_flag(desc, false);
558 desc2a_set_picture_to_display_conversion_flag(desc, true);
559 }
560
561 /* MPEG Descriptor 0x2b: MPEG-2 AAC audio descriptor */
build_desc2b(uint8_t * desc)562 static void build_desc2b(uint8_t *desc) {
563 desc2b_init(desc);
564 desc2b_set_aac_profile(desc, 0x12);
565 desc2b_set_aac_channel_config(desc, 0x05);
566 desc2b_set_aac_additional_info(desc, 0x00);
567 }
568
569 /* MPEG Descriptor 0x2c: FlexMuxTiming descriptor */
build_desc2c(uint8_t * desc)570 static void build_desc2c(uint8_t *desc) {
571 desc2c_init(desc);
572 desc2c_set_fcr_es_id(desc, 0x1234);
573 desc2c_set_fcr_resolution(desc, 123456789);
574 desc2c_set_fcr_length(desc, 55);
575 desc2c_set_fmx_rate_length(desc, 32);
576 }
577
578 /* =========================================================================
579 * DVB defined descriptors
580 * ========================================================================= */
581
582 /* DVB Descriptor 0x40: Network name descriptor */
build_desc40(uint8_t * desc)583 static void build_desc40(uint8_t *desc) {
584 char *network_name = "Test Network Name";
585 desc40_init(desc);
586 desc40_set_networkname(desc, (uint8_t *)network_name, strlen(network_name));
587 }
588
589 /* DVB Descriptor 0x41: Service list descriptor */
build_desc41(uint8_t * desc)590 static void build_desc41(uint8_t *desc) {
591 uint8_t k = 0;
592 uint8_t *service_n;
593
594 desc41_init(desc);
595 desc_set_length(desc, 255);
596
597 service_n = desc41_get_service(desc, k++);
598 desc41n_set_sid(service_n, sid);
599 desc41n_set_type(service_n, 1);
600
601 service_n = desc41_get_service(desc, k++);
602 desc41n_set_sid(service_n, sid + 100);
603 desc41n_set_type(service_n, 2);
604
605 service_n = desc41_get_service(desc, k++);
606 desc41n_set_sid(service_n, sid + 200);
607 desc41n_set_type(service_n, 1);
608
609 service_n = desc41_get_service(desc, k++);
610 desc41n_set_sid(service_n, sid + 300);
611 desc41n_set_type(service_n, 2);
612
613 service_n = desc41_get_service(desc, k);
614 desc_set_length(desc, service_n - desc - DESC_HEADER_SIZE);
615 }
616
617 /* DVB Descriptor 0x43: Satellite delivery system descriptor */
build_desc43(uint8_t * desc)618 static void build_desc43(uint8_t *desc) {
619 desc43_init(desc);
620 desc43_set_frequency_bcd (desc, 0x1175725); // 11,75725 GHz
621 desc43_set_position_bcd (desc, 0x0192); // 19.2
622 desc43_set_east (desc, true);
623 desc43_set_polarization (desc, 1); // 0-H, 1-V, 2-L, 3-R
624 desc43_set_rolloff (desc, 0); // Must be 0 if dvbs2 is false
625 desc43_set_dvbs2 (desc, false);
626 desc43_set_modulation (desc, 1); // QPSK
627 // desc43_set_rolloff (desc, 1); // 0,25
628 // desc43_set_dvbs2 (desc, true);
629 // desc43_set_modulation (desc, 2); // 8PSK
630 desc43_set_symbolrate_bcd (desc, 0x274500); // 27,450
631 desc43_set_fecinner (desc, 5); // 7/8
632 }
633
634 /* DVB Descriptor 0x44: Cable delivery system descriptor */
build_desc44(uint8_t * desc)635 static void build_desc44(uint8_t *desc) {
636 desc44_init(desc);
637 desc44_set_frequency_bcd (desc, 0x3120000); // 312,0000 Mhz
638 desc44_set_fecouter (desc, 0); // 0 - not defined
639 desc44_set_modulation (desc, 3); // 64-QAM
640 desc44_set_symbolrate_bcd (desc, 0x274500); // 27,450
641 desc44_set_fecinner (desc, 6); // 8/9
642 }
643
644 /* DVB Descriptor 0x45: VBI data descriptor */
build_desc45(uint8_t * desc)645 static void build_desc45(uint8_t *desc) {
646 uint8_t k = 0;
647 uint8_t *data_n;
648
649 desc45_init(desc);
650 desc_set_length(desc, 255);
651
652 data_n = desc45_get_data(desc, k++);
653 desc45n_set_service_id (data_n, 0x01); // EBU teletext
654 desc45n_set_data_length(data_n, 8); // How much bytes are after this
655 {
656 uint8_t j, max_j = desc45n_get_data_length(data_n);
657 for (j = 0; j < max_j; j++) {
658 desc45n_set_field_parity(data_n, j, (j % 2) == 0);
659 desc45n_set_line_offset (data_n, j, j);
660 }
661 }
662
663 data_n = desc45_get_data(desc, k++);
664 desc45n_set_service_id (data_n, 0x03); // Reserved
665 desc45n_set_data_length(data_n, 4); // How much bytes are after this
666 desc45n_set_byte(data_n, 0, 0x12);
667 desc45n_set_byte(data_n, 1, 0x34);
668 desc45n_set_byte(data_n, 2, 0x56);
669 desc45n_set_byte(data_n, 3, 0x78);
670
671 data_n = desc45_get_data(desc, k++);
672 desc45n_set_service_id (data_n, 0x04); // VPS
673 desc45n_set_data_length(data_n, 1); // How much bytes are after this
674 {
675 uint8_t j, max_j = desc45n_get_data_length(data_n);
676 for (j = 0; j < max_j; j++) {
677 desc45n_set_field_parity(data_n, j, (j % 2) == 2);
678 desc45n_set_line_offset (data_n, j, j + 10);
679 }
680 }
681
682 data_n = desc45_get_data(desc, k++);
683 desc45n_set_service_id (data_n, 0x05); // WSS
684 desc45n_set_data_length(data_n, 4); // How much bytes are after this
685 {
686 uint8_t j, max_j = desc45n_get_data_length(data_n);
687 for (j = 0; j < max_j; j++) {
688 desc45n_set_field_parity(data_n, j, (j % 2) == 1);
689 desc45n_set_line_offset (data_n, j, j + 20);
690 }
691 }
692
693 data_n = desc45_get_data(desc, k++);
694 desc45n_set_service_id (data_n, 0x06); // Closed Captioning
695 desc45n_set_data_length(data_n, 0); // How much bytes are after this
696
697 data_n = desc45_get_data(desc, k);
698 desc_set_length(desc, data_n - desc - DESC_HEADER_SIZE);
699 }
700
701 /* DVB Descriptor 0x46: VBI teletext descriptor */
build_desc46(uint8_t * desc)702 static void build_desc46(uint8_t *desc) {
703 uint8_t k = 0;
704 uint8_t *lang_n;
705
706 desc46_init(desc);
707 desc_set_length(desc, 255);
708
709 lang_n = desc46_get_language(desc, k++);
710 desc46n_set_code(lang_n, (uint8_t *)"eng");
711 desc46n_set_teletexttype(lang_n, 1);
712 desc46n_set_teletextmagazine(lang_n, 3);
713 desc46n_set_teletextpage(lang_n, 255);
714
715 lang_n = desc46_get_language(desc, k++);
716 desc46n_set_code(lang_n, (uint8_t *)"bul");
717 desc46n_set_teletexttype(lang_n, 2);
718 desc46n_set_teletextmagazine(lang_n, 2);
719 desc46n_set_teletextpage(lang_n, 127);
720
721 lang_n = desc46_get_language(desc, k++);
722 desc46n_set_code(lang_n, (uint8_t *)"fre");
723 desc46n_set_teletexttype(lang_n, 3);
724 desc46n_set_teletextmagazine(lang_n, 1);
725 desc46n_set_teletextpage(lang_n, 64);
726
727 lang_n = desc46_get_language(desc, k);
728 desc_set_length(desc, lang_n - desc - DESC_HEADER_SIZE);
729 }
730
731 /* DVB Descriptor 0x47: Bouquet name descriptor */
build_desc47(uint8_t * desc)732 static void build_desc47(uint8_t *desc) {
733 char *bouquet_name = "Test Bouquet Name";
734 desc47_init(desc);
735 desc47_set_bouquetname(desc, (uint8_t *)bouquet_name, strlen(bouquet_name));
736 }
737
738 /* DVB Descriptor 0x48: Service descriptor */
build_desc48(uint8_t * desc)739 static void build_desc48(uint8_t *desc) {
740 uint8_t service_type = 0x01; // digital tv
741 char *provider_name = "Test Provider Name";
742 char *service_name = "Test Service Name";
743 desc48_init(desc);
744 desc48_set_type(desc, service_type);
745 desc48_set_provider(desc, (uint8_t *)provider_name, strlen(provider_name));
746 desc48_set_service(desc, (uint8_t *)service_name, strlen(service_name));
747 desc48_set_length(desc);
748 }
749
750 /* DVB Descriptor 0x49: Country availability descriptor */
build_desc49(uint8_t * desc,bool b_available)751 static void build_desc49(uint8_t *desc, bool b_available) {
752 uint8_t k = 0;
753 uint8_t *code_n;
754
755 desc49_init(desc);
756 desc49_set_country_availability_flag(desc, b_available);
757
758 desc_set_length(desc, 255);
759
760 code_n = desc49_get_code(desc, k++);
761 desc49n_set_code(code_n, (uint8_t *)"GBR");
762
763 code_n = desc49_get_code(desc, k++);
764 desc49n_set_code(code_n, (uint8_t *)"FRA");
765
766 code_n = desc49_get_code(desc, k++);
767 desc49n_set_code(code_n, (uint8_t *)"BUL");
768
769 code_n = desc49_get_code(desc, k);
770 desc_set_length(desc, code_n - desc - DESC_HEADER_SIZE);
771 }
772
773 /* DVB Descriptor 0x4a: Linkage descriptor */
build_desc4a_std(uint8_t * desc)774 static void build_desc4a_std(uint8_t *desc) {
775 desc4a_init(desc);
776 desc4a_set_tsid(desc, tsid + 500);
777 desc4a_set_onid(desc, onid + 500);
778 desc4a_set_sid (desc, 0x0000);
779 desc4a_set_linkage(desc, 0x04); // new ts
780 }
781
build_desc4a_mobile(uint8_t * desc)782 static void build_desc4a_mobile(uint8_t *desc) {
783 desc4a_init(desc);
784 desc4a_set_tsid(desc, tsid + 600);
785 desc4a_set_onid(desc, onid + 600);
786 desc4a_set_sid (desc, sid + 600);
787 // mobile handover
788 desc4a_set_linkage(desc, DESC4A_LINKAGE_MOBILE);
789 desc4a_set_mobile_handover_type(desc, 1);
790 desc4a_set_mobile_origin_type(desc, false);
791 desc4a_set_mobile_nid(desc, onid + 1000);
792 desc4a_set_mobile_initial_sid(desc, sid + 1000);
793 desc4a_set_length(desc);
794 }
795
build_desc4a_event(uint8_t * desc)796 static void build_desc4a_event(uint8_t *desc) {
797 desc4a_init(desc);
798 desc4a_set_tsid(desc, tsid + 700);
799 desc4a_set_onid(desc, onid + 700);
800 desc4a_set_sid (desc, sid + 700);
801 // event linkage
802 desc4a_set_linkage(desc, DESC4A_LINKAGE_EVENT);
803 desc4a_set_event_target_event_id(desc, event_id + 1000);
804 desc4a_set_event_target_listed(desc, true);
805 desc4a_set_event_simulcast(desc, true);
806 desc4a_set_length(desc);
807 }
808
build_desc4a_extended_event(uint8_t * desc)809 static void build_desc4a_extended_event(uint8_t *desc) {
810 uint8_t k = 0;
811 uint8_t *ext_n;
812
813 desc4a_init(desc);
814 desc4a_set_tsid(desc, tsid + 800);
815 desc4a_set_onid(desc, onid + 800);
816 desc4a_set_sid (desc, sid + 800);
817 // extended event linkage
818 desc4a_set_linkage(desc, DESC4A_LINKAGE_EXT_EVENT);
819
820 desc_set_length(desc, 255);
821
822 ext_n = desc4a_get_ext_event(desc, k++);
823 desc4an_set_ext_event_target_event_id(ext_n, event_id + 1000);
824 desc4an_set_ext_event_target_listed (ext_n, false);
825 desc4an_set_ext_event_simulcast (ext_n, true);
826 desc4an_set_ext_event_link_type (ext_n, 1); // HD
827 desc4an_set_ext_event_target_id_type (ext_n, 3); // user defined id
828 desc4an_set_ext_event_onid_id_flag (ext_n, true);
829 desc4an_set_ext_event_service_id_flag(ext_n, true);
830 desc4an_set_ext_event_user_defined_id(ext_n, 7878);
831 desc4an_set_ext_event_target_tsid (ext_n, tsid + 1000); // !!!
832 desc4an_set_ext_event_target_onid (ext_n, onid + 1000); // !!!
833 desc4an_set_ext_event_service_id (ext_n, sid + 1000); // !!!
834
835 ext_n = desc4a_get_ext_event(desc, k++);
836 desc4an_set_ext_event_target_event_id(ext_n, event_id + 2000);
837 desc4an_set_ext_event_target_listed (ext_n, true);
838 desc4an_set_ext_event_simulcast (ext_n, true);
839 desc4an_set_ext_event_link_type (ext_n, 0); // SD
840 desc4an_set_ext_event_target_id_type (ext_n, 0); // onid_id_flag, target_service_id_flag
841 desc4an_set_ext_event_onid_id_flag (ext_n, true);
842 desc4an_set_ext_event_service_id_flag(ext_n, true);
843 desc4an_set_ext_event_user_defined_id(ext_n, 8787); // !!!
844 desc4an_set_ext_event_target_tsid (ext_n, tsid + 2000); // !!!
845 desc4an_set_ext_event_target_onid (ext_n, onid + 2000);
846 desc4an_set_ext_event_service_id (ext_n, sid + 2000);
847
848 ext_n = desc4a_get_ext_event(desc, k++);
849 desc4an_set_ext_event_target_event_id(ext_n, event_id + 3000);
850 desc4an_set_ext_event_target_listed (ext_n, true);
851 desc4an_set_ext_event_simulcast (ext_n, true);
852 desc4an_set_ext_event_link_type (ext_n, 2); // 3D
853 desc4an_set_ext_event_target_id_type (ext_n, 1); // target_tsid, onid_id_flag, target_service_id_flag
854 desc4an_set_ext_event_onid_id_flag (ext_n, true);
855 desc4an_set_ext_event_service_id_flag(ext_n, true);
856 desc4an_set_ext_event_user_defined_id(ext_n, 8787); // !!!
857 desc4an_set_ext_event_target_tsid (ext_n, tsid + 3000);
858 desc4an_set_ext_event_target_onid (ext_n, onid + 3000);
859 desc4an_set_ext_event_service_id (ext_n, sid + 3000);
860
861 ext_n = desc4a_get_ext_event(desc, k++);
862 desc4an_set_ext_event_target_event_id(ext_n, event_id + 4000);
863 desc4an_set_ext_event_target_listed (ext_n, false);
864 desc4an_set_ext_event_simulcast (ext_n, false);
865 desc4an_set_ext_event_link_type (ext_n, 0); // SD
866 desc4an_set_ext_event_target_id_type (ext_n, 0); // onid_id_flag, target_service_id_flag
867 desc4an_set_ext_event_onid_id_flag (ext_n, false);
868 desc4an_set_ext_event_service_id_flag(ext_n, false);
869 desc4an_set_ext_event_user_defined_id(ext_n, 8787); // !!!
870 desc4an_set_ext_event_target_tsid (ext_n, tsid + 4000); // !!!
871 desc4an_set_ext_event_target_onid (ext_n, onid + 4000); // !!!
872 desc4an_set_ext_event_service_id (ext_n, sid + 4000); // !!!
873
874 ext_n = desc4a_get_ext_event(desc, k);
875 desc_set_length(desc, ext_n - desc - DESC_HEADER_SIZE);
876 }
877
878 /* DVB Descriptor 0x4b: NVOD_reference_descriptor */
build_desc4b(uint8_t * desc,bool b_available)879 static void build_desc4b(uint8_t *desc, bool b_available) {
880 uint8_t k = 0;
881 uint8_t *ref_n;
882
883 desc4b_init(desc);
884 desc_set_length(desc, 255);
885
886 ref_n = desc4b_get_reference(desc, k++);
887 desc4bn_set_tsid(ref_n, tsid);
888 desc4bn_set_onid(ref_n, onid);
889 desc4bn_set_sid (ref_n, sid);
890
891 ref_n = desc4b_get_reference(desc, k++);
892 desc4bn_set_tsid(ref_n, tsid + 100);
893 desc4bn_set_onid(ref_n, onid + 100);
894 desc4bn_set_sid (ref_n, sid + 100);
895
896 ref_n = desc4b_get_reference(desc, k++);
897 desc4bn_set_tsid(ref_n, tsid + 200);
898 desc4bn_set_onid(ref_n, onid + 200);
899 desc4bn_set_sid (ref_n, sid + 200);
900
901 ref_n = desc4b_get_reference(desc, k);
902 desc_set_length(desc, ref_n - desc - DESC_HEADER_SIZE);
903 }
904
905 /* DVB Descriptor 0x4c: time_shifted_service_descriptor */
build_desc4c(uint8_t * desc)906 static void build_desc4c(uint8_t *desc) {
907 desc4c_init(desc);
908 desc4c_set_reference_sid(desc, sid + 1000);
909 }
910
911 /* DVB Descriptor 0x4d: Short event descriptor */
build_desc4d(uint8_t * desc)912 static void build_desc4d(uint8_t *desc) {
913 char *event_name = "Major TV event";
914 char *text = "The event of the century!";
915 desc4d_init(desc);
916 desc4d_set_lang(desc, (uint8_t *)"eng");
917 desc4d_set_event_name(desc, (uint8_t *)event_name, strlen(event_name));
918 desc4d_set_text(desc, (uint8_t *)text, strlen(text));
919 desc4d_set_length(desc);
920 }
921
922 /* DVB Descriptor 0x4e: Extended event descriptor */
build_desc4e(uint8_t * desc)923 static void build_desc4e(uint8_t *desc) {
924 uint8_t k = 0;
925 uint8_t *item_n;
926 char *item1_desc = "Director";
927 char *item1_text = "Famous director";
928 char *item2_desc = "Year";
929 char *item2_text = "2011";
930 char *item3_desc = "Rating";
931 char *item3_text = "***++";
932 char *text = "Wow, what an event!";
933
934 desc4e_init(desc);
935 desc_set_length(desc, 255);
936
937 desc4e_set_desc_number(desc, 0);
938 desc4e_set_last_desc_number(desc, 0);
939 desc4e_set_lang(desc, (uint8_t *)"eng");
940 desc4e_set_items_length(desc, 0);
941
942 {
943 desc4e_set_items_length(desc, 255);
944 uint8_t *first_item = desc4e_get_item(desc, 0);
945
946 item_n = desc4e_get_item(desc, k++);
947 desc4en_set_item_description(item_n, (uint8_t *)item1_desc, strlen(item1_desc));
948 desc4en_set_item_text(item_n, (uint8_t *)item1_text, strlen(item1_text));
949
950 item_n = desc4e_get_item(desc, k++);
951 desc4en_set_item_description(item_n, (uint8_t *)item2_desc, strlen(item2_desc));
952 desc4en_set_item_text(item_n, (uint8_t *)item2_text, strlen(item2_text));
953
954 item_n = desc4e_get_item(desc, k++);
955 desc4en_set_item_description(item_n, (uint8_t *)item3_desc, strlen(item3_desc));
956 desc4en_set_item_text(item_n, (uint8_t *)item3_text, strlen(item3_text));
957
958 item_n = desc4e_get_item(desc, k);
959 desc4e_set_items_length(desc, item_n - first_item);
960 }
961
962 desc4e_set_text(desc, (uint8_t *)text, strlen(text));
963 desc4e_set_length(desc);
964 }
965
966 /* DVB Descriptor 0x4f: time_shifted_event_descriptor */
build_desc4f(uint8_t * desc)967 static void build_desc4f(uint8_t *desc) {
968 desc4f_init(desc);
969 desc4f_set_reference_sid(desc, sid + 2000);
970 desc4f_set_reference_event_id(desc, event_id + 2000);
971 }
972
973 /* DVB Descriptor 0x50: Component descriptor */
build_desc50(uint8_t * desc)974 static void build_desc50(uint8_t *desc) {
975 char *text = "Stereo";
976 desc50_init(desc);
977 desc50_set_stream_content(desc, 0x02);
978 desc50_set_component_type(desc, 0x03);
979 desc50_set_component_tag(desc, 46);
980 desc50_set_language(desc, (uint8_t *)"eng");
981 desc50_set_text(desc, (uint8_t *)text, strlen(text)); // Not required
982 }
983
984 /* DVB Descriptor 0x51: Mosaic descriptor */
build_desc51(uint8_t * desc)985 static void build_desc51(uint8_t *desc) {
986 uint8_t k = 0;
987 uint8_t *cell_n;
988
989 desc51_init(desc);
990 desc51_set_mosaic_entry_point(desc, 1);
991 desc51_set_horizontal_cells(desc, 2); // +1 == 3
992 desc51_set_vertical_cells(desc, 2); // +1 == 3 (3x3 == 9 cells)
993
994 desc_set_length(desc, 255);
995 cell_n = desc51_get_logical_cell(desc, k++);
996 {
997 desc51n_set_logical_cell_id(cell_n, 0);
998 desc51n_set_logical_cell_presentation_info(cell_n, 1);
999 desc51n_set_elementary_cell_field_length(cell_n, 3);
1000 {
1001 desc51n_set_elementary_cell_id(cell_n, 0, 0);
1002 desc51n_set_elementary_cell_id(cell_n, 1, 1);
1003 desc51n_set_elementary_cell_id(cell_n, 2, 2);
1004 }
1005
1006 desc51n_set_cell_linkage_info(cell_n, 1); // bouquet_id
1007 desc51n_set_bouquet_id(cell_n, onid + 100);
1008 }
1009
1010 cell_n = desc51_get_logical_cell(desc, k++);
1011 {
1012 desc51n_set_logical_cell_id(cell_n, 1);
1013 desc51n_set_logical_cell_presentation_info(cell_n, 2);
1014 desc51n_set_elementary_cell_field_length(cell_n, 3);
1015 {
1016 desc51n_set_elementary_cell_id(cell_n, 0, 3);
1017 desc51n_set_elementary_cell_id(cell_n, 1, 4);
1018 desc51n_set_elementary_cell_id(cell_n, 2, 5);
1019 }
1020 desc51n_set_cell_linkage_info(cell_n, 2); // 2 or 3, onid, tsid, sid
1021 desc51n_set_onid(cell_n, onid + 500);
1022 desc51n_set_tsid(cell_n, tsid + 500);
1023 desc51n_set_sid(cell_n, sid + 500);
1024 }
1025
1026 cell_n = desc51_get_logical_cell(desc, k++);
1027 {
1028 desc51n_set_logical_cell_id(cell_n, 2);
1029 desc51n_set_logical_cell_presentation_info(cell_n, 3);
1030 desc51n_set_elementary_cell_field_length(cell_n, 3);
1031 {
1032 desc51n_set_elementary_cell_id(cell_n, 0, 6);
1033 desc51n_set_elementary_cell_id(cell_n, 1, 7);
1034 desc51n_set_elementary_cell_id(cell_n, 2, 8);
1035 }
1036 desc51n_set_cell_linkage_info(cell_n, 4); // onid, tsid, sid, event_id
1037 desc51n_set_onid(cell_n, onid + 1000);
1038 desc51n_set_tsid(cell_n, tsid + 1000);
1039 desc51n_set_sid(cell_n, sid + 1000);
1040 desc51n_set_event_id(cell_n, event_id + 1000);
1041 }
1042
1043 cell_n = desc51_get_logical_cell(desc, k);
1044 desc_set_length(desc, cell_n - desc - DESC_HEADER_SIZE);
1045 }
1046
1047 /* DVB Descriptor 0x52: Stream identifier descriptor */
build_desc52(uint8_t * desc)1048 static void build_desc52(uint8_t *desc) {
1049 desc52_init(desc);
1050 desc52_set_component_tag(desc, 46);
1051 }
1052
1053 /* DVB Descriptor 0x53: CA_identifier_descriptor */
build_desc53(uint8_t * desc)1054 static void build_desc53(uint8_t *desc) {
1055 uint8_t k = 0;
1056 uint8_t *cas_n;
1057
1058 desc53_init(desc);
1059 desc_set_length(desc, 255);
1060
1061 cas_n = desc53_get_ca(desc, k++);
1062 desc53n_set_ca_sysid(cas_n, 0xaabb);
1063
1064 cas_n = desc53_get_ca(desc, k++);
1065 desc53n_set_ca_sysid(cas_n, 0xccdd);
1066
1067 cas_n = desc53_get_ca(desc, k++);
1068 desc53n_set_ca_sysid(cas_n, 0xeeff);
1069
1070 cas_n = desc53_get_ca(desc, k);
1071 desc_set_length(desc, cas_n - desc - DESC_HEADER_SIZE);
1072 }
1073
1074 /* DVB Descriptor 0x54: Content descriptor */
build_desc54(uint8_t * desc)1075 static void build_desc54(uint8_t *desc) {
1076 uint8_t k = 0;
1077 uint8_t *content_n;
1078
1079 desc54_init(desc);
1080 desc_set_length(desc, 255);
1081
1082 content_n = desc54_get_content(desc, k++);
1083 desc54n_set_content_l1(content_n, 2);
1084 desc54n_set_content_l2(content_n, 4);
1085 desc54n_set_user(content_n, 78);
1086
1087 content_n = desc54_get_content(desc, k++);
1088 desc54n_set_content_l1(content_n, 6);
1089 desc54n_set_content_l2(content_n, 8);
1090 desc54n_set_user(content_n, 177);
1091
1092 content_n = desc54_get_content(desc, k);
1093 desc_set_length(desc, content_n - desc - DESC_HEADER_SIZE);
1094 }
1095
1096 /* DVB Descriptor 0x55: Parental rating descriptor */
build_desc55(uint8_t * desc)1097 static void build_desc55(uint8_t *desc) {
1098 uint8_t k = 0;
1099 uint8_t *rating_n;
1100
1101 desc55_init(desc);
1102 desc_set_length(desc, 255);
1103
1104 rating_n = desc55_get_rating(desc, k++);
1105 desc55n_set_country_code(rating_n, (uint8_t *)"USA");
1106 desc55n_set_rating(rating_n, 0);
1107
1108 rating_n = desc55_get_rating(desc, k++);
1109 desc55n_set_country_code(rating_n, (uint8_t *)"CHI");
1110 desc55n_set_rating(rating_n, 15);
1111
1112 rating_n = desc55_get_rating(desc, k++);
1113 desc55n_set_country_code(rating_n, (uint8_t *)"FRA");
1114 desc55n_set_rating(rating_n, 12);
1115
1116 rating_n = desc55_get_rating(desc, k++);
1117 desc55n_set_country_code(rating_n, (uint8_t *)"BUL");
1118 desc55n_set_rating(rating_n, 24);
1119
1120 rating_n = desc55_get_rating(desc, k);
1121 desc_set_length(desc, rating_n - desc - DESC_HEADER_SIZE);
1122 }
1123
1124 /* DVB Descriptor 0x56: Teletext descriptor */
build_desc56(uint8_t * desc)1125 static void build_desc56(uint8_t *desc) {
1126 // Desc 46 is the same as desc 56, only
1127 // the descriptor tag is different
1128 build_desc46(desc);
1129 desc56_init(desc);
1130 }
1131
1132 /* DVB Descriptor 0x57: telephone_descriptor */
build_desc57(uint8_t * desc)1133 static void build_desc57(uint8_t *desc) {
1134 char *country_prefix = "+";
1135 char *international_area_code = "359";
1136 char *operator_code = "2";
1137 char *national_area_code = "";
1138 char *core_number = "9868620";
1139
1140 desc57_init(desc);
1141
1142 desc57_set_foreign_availability(desc, true);
1143 desc57_set_connection_type(desc, 3);
1144
1145 desc57_set_country_prefix(desc, country_prefix, strlen(country_prefix));
1146 desc57_set_international_area_code(desc, international_area_code, strlen(international_area_code));
1147 desc57_set_operator_code(desc, operator_code, strlen(operator_code));
1148 desc57_set_national_area_code(desc, national_area_code, strlen(national_area_code));
1149 desc57_set_core_number(desc, core_number, strlen(core_number));
1150 desc57_set_length(desc);
1151 }
1152
1153 /* DVB Descriptor 0x58: Local time offset descriptor */
build_desc58(uint8_t * desc)1154 static void build_desc58(uint8_t *desc) {
1155 uint8_t k = 0;
1156 uint8_t *lto_n;
1157
1158 desc58_init(desc);
1159 desc_set_length(desc, 255);
1160
1161 lto_n = desc58_get_lto(desc, k++);
1162 desc58n_set_country_code(lto_n, (uint8_t *)"BUL");
1163 desc58n_set_country_region_id(lto_n, 2);
1164 desc58n_set_lto_polarity(lto_n, 1);
1165 desc58n_set_lt_offset(lto_n, 0x0200);
1166 desc58n_set_time_of_change(lto_n, dvb_time_encode_UTC(ts_0));
1167 desc58n_set_next_offset(lto_n, 0x0300);
1168
1169 lto_n = desc58_get_lto(desc, k++);
1170 desc58n_set_country_code(lto_n, (uint8_t *)"USA");
1171 desc58n_set_country_region_id(lto_n, 9);
1172 desc58n_set_lto_polarity(lto_n, 0);
1173 desc58n_set_lt_offset(lto_n, 0x1400);
1174 desc58n_set_time_of_change(lto_n, dvb_time_encode_UTC(ts_2));
1175 desc58n_set_next_offset(lto_n, 0x1830);
1176
1177 lto_n = desc58_get_lto(desc, k);
1178 desc_set_length(desc, lto_n - desc - DESC_HEADER_SIZE);
1179 }
1180
1181 /* DVB Descriptor 0x59: Subtitling descriptor */
build_desc59(uint8_t * desc)1182 static void build_desc59(uint8_t *desc) {
1183 uint8_t k = 0;
1184 uint8_t *lang_n;
1185
1186 desc59_init(desc);
1187 desc_set_length(desc, 255);
1188
1189 lang_n = desc59_get_language(desc, k++);
1190 desc59n_set_code(lang_n, (uint8_t *)"eng");
1191 desc59n_set_subtitlingtype(lang_n, 1);
1192 desc59n_set_compositionpage(lang_n, 2);
1193 desc59n_set_ancillarypage(lang_n, 3);
1194
1195 lang_n = desc59_get_language(desc, k++);
1196 desc59n_set_code(lang_n, (uint8_t *)"bul");
1197 desc59n_set_subtitlingtype(lang_n, 2);
1198 desc59n_set_compositionpage(lang_n, 3);
1199 desc59n_set_ancillarypage(lang_n, 4);
1200
1201 lang_n = desc59_get_language(desc, k++);
1202 desc59n_set_code(lang_n, (uint8_t *)"fre");
1203 desc59n_set_subtitlingtype(lang_n, 5);
1204 desc59n_set_compositionpage(lang_n, 6);
1205 desc59n_set_ancillarypage(lang_n, 7);
1206
1207 lang_n = desc59_get_language(desc, k);
1208 desc_set_length(desc, lang_n - desc - DESC_HEADER_SIZE);
1209 }
1210
1211 /* DVB Descriptor 0x5a: Terrestrial delivery system descriptor */
build_desc5a(uint8_t * desc)1212 static void build_desc5a(uint8_t *desc) {
1213 desc5a_init(desc);
1214 desc5a_set_frequency (desc, 1234567890); // Hz * 10
1215 desc5a_set_bandwidth (desc, 2); // 6 Mhz
1216 desc5a_set_priority (desc, false); // HP, hierarchy must 0
1217 desc5a_set_timeslicing (desc, true);
1218 desc5a_set_mpefec (desc, true);
1219 desc5a_set_constellation (desc, 2); // 64-QAM
1220 desc5a_set_hierarchy (desc, 0xe);
1221 desc5a_set_coderatehp (desc, 2); // 3/4
1222 desc5a_set_coderatelp (desc, 3); // 5/6
1223 desc5a_set_guard (desc, 1); // 1/16
1224 desc5a_set_transmission (desc, 2); // 4k mode
1225 desc5a_set_otherfrequency (desc, true);
1226 }
1227
1228 /* DVB Descriptor 0x5b: multilingual_network_name_descriptor */
build_desc5b(uint8_t * desc)1229 static void build_desc5b(uint8_t *desc) {
1230 char *network_name = "M Network";
1231 uint8_t k = 0;
1232 uint8_t *data_n;
1233
1234 desc5b_init(desc);
1235 desc_set_length(desc, 255);
1236
1237 data_n = desc5b_get_data(desc, k++);
1238 desc5bn_set_code(data_n, (uint8_t *)"eng");
1239 desc5bn_set_networkname(data_n, (uint8_t *)network_name, strlen(network_name));
1240
1241 data_n = desc5b_get_data(desc, k++);
1242 desc5bn_set_code(data_n, (uint8_t *)"fre");
1243 desc5bn_set_networkname(data_n, (uint8_t *)network_name, strlen(network_name));
1244
1245 data_n = desc5b_get_data(desc, k++);
1246 desc5bn_set_code(data_n, (uint8_t *)"bul");
1247 desc5bn_set_networkname(data_n, (uint8_t *)network_name, strlen(network_name));
1248
1249 data_n = desc5b_get_data(desc, k);
1250 desc_set_length(desc, data_n - desc - DESC_HEADER_SIZE);
1251 }
1252
1253 /* DVB Descriptor 0x5c: Multilingual bouquet name descriptor */
build_desc5c(uint8_t * desc)1254 static void build_desc5c(uint8_t *desc) {
1255 char *bouquet_name = "M Bouquet";
1256 uint8_t k = 0;
1257 uint8_t *data_n;
1258
1259 desc5c_init(desc);
1260 desc_set_length(desc, 255);
1261
1262 data_n = desc5c_get_data(desc, k++);
1263 desc5cn_set_code(data_n, (uint8_t *)"eng");
1264 desc5cn_set_bouquetname(data_n, (uint8_t *)bouquet_name, strlen(bouquet_name));
1265
1266 data_n = desc5c_get_data(desc, k++);
1267 desc5cn_set_code(data_n, (uint8_t *)"fre");
1268 desc5cn_set_bouquetname(data_n, (uint8_t *)bouquet_name, strlen(bouquet_name));
1269
1270 data_n = desc5c_get_data(desc, k++);
1271 desc5cn_set_code(data_n, (uint8_t *)"bul");
1272 desc5cn_set_bouquetname(data_n, (uint8_t *)bouquet_name, strlen(bouquet_name));
1273
1274 data_n = desc5c_get_data(desc, k);
1275 desc_set_length(desc, data_n - desc - DESC_HEADER_SIZE);
1276 }
1277
1278 /* DVB Descriptor 0x5d: Multilingual service name descriptor */
build_desc5d(uint8_t * desc)1279 static void build_desc5d(uint8_t *desc) {
1280 char *provider_name = "M Provider";
1281 char *service_name = "M Service";
1282 uint8_t k = 0;
1283 uint8_t *data_n;
1284
1285 desc5d_init(desc);
1286 desc_set_length(desc, 255);
1287
1288 data_n = desc5d_get_data(desc, k++);
1289 desc5dn_set_code(data_n, (uint8_t *)"eng");
1290 desc5dn_set_provider_name(data_n, (uint8_t *)provider_name, strlen(provider_name));
1291 desc5dn_set_service_name(data_n, (uint8_t *)service_name, strlen(service_name));
1292
1293 data_n = desc5d_get_data(desc, k++);
1294 desc5dn_set_code(data_n, (uint8_t *)"fre");
1295 desc5dn_set_provider_name(data_n, (uint8_t *)provider_name, strlen(provider_name));
1296 desc5dn_set_service_name(data_n, (uint8_t *)service_name, strlen(service_name));
1297
1298 data_n = desc5d_get_data(desc, k++);
1299 desc5dn_set_code(data_n, (uint8_t *)"bul");
1300 desc5dn_set_provider_name(data_n, (uint8_t *)provider_name, strlen(provider_name));
1301 desc5dn_set_service_name(data_n, (uint8_t *)service_name, strlen(service_name));
1302
1303
1304 data_n = desc5d_get_data(desc, k);
1305 desc_set_length(desc, data_n - desc - DESC_HEADER_SIZE);
1306 }
1307
1308 /* DVB Descriptor 0x5e: Multilingual component descriptor */
build_desc5e(uint8_t * desc)1309 static void build_desc5e(uint8_t *desc) {
1310 char *text = "Stereo";
1311 uint8_t k = 0;
1312 uint8_t *data_n;
1313
1314 desc5e_init(desc);
1315 desc5e_set_component_tag(desc, 46);
1316 desc_set_length(desc, 255);
1317
1318 data_n = desc5e_get_data(desc, k++);
1319 desc5en_set_code(data_n, (uint8_t *)"eng");
1320 desc5en_set_text(data_n, (uint8_t *)text, strlen(text));
1321
1322 data_n = desc5e_get_data(desc, k++);
1323 desc5en_set_code(data_n, (uint8_t *)"fre");
1324 desc5en_set_text(data_n, (uint8_t *)text, strlen(text));
1325
1326 data_n = desc5e_get_data(desc, k++);
1327 desc5en_set_code(data_n, (uint8_t *)"bul");
1328 desc5en_set_text(data_n, (uint8_t *)text, strlen(text));
1329
1330 data_n = desc5e_get_data(desc, k);
1331 desc_set_length(desc, data_n - desc - DESC_HEADER_SIZE);
1332 }
1333
1334
1335 /* DVB Descriptor 0x5f: Private data specifier descriptor */
build_desc5f(uint8_t * desc)1336 static void build_desc5f(uint8_t *desc) {
1337 desc5f_init(desc);
1338 desc5f_set_specifier(desc, 0xaabbccdd);
1339 }
1340
1341 /* DVB Descriptor 0x60: Service move descriptor */
build_desc60(uint8_t * desc)1342 static void build_desc60(uint8_t *desc) {
1343 desc60_init(desc);
1344 desc60_set_new_onid(desc, 10000);
1345 desc60_set_new_tsid(desc, 15000);
1346 desc60_set_new_service_id(desc, 20000);
1347 }
1348
1349 /* DVB Descriptor 0x61: Short smoothing buffer descriptor */
build_desc61(uint8_t * desc)1350 static void build_desc61(uint8_t *desc) {
1351 desc61_init(desc);
1352 desc61_set_sb_size(desc, 1); // 1536 bytes buffer size
1353 desc61_set_sb_leak_rate(desc, 10); // 0.5 Mbit/s
1354 }
1355
1356 /* DVB Descriptor 0x62: Frequency list descriptor */
build_desc62(uint8_t * desc)1357 static void build_desc62(uint8_t *desc) {
1358 uint8_t k = 0;
1359 uint8_t *freq_n;
1360
1361 desc62_init(desc);
1362 desc62_set_coding_type(desc, 2); // Cable
1363 desc_set_length(desc, 255);
1364
1365 freq_n = desc62_get_frequency(desc, k++);
1366 desc62n_set_freq(freq_n, 0x3120000); // 312,0000 Mhz
1367
1368 freq_n = desc62_get_frequency(desc, k++);
1369 desc62n_set_freq(freq_n, 0x3180000); // 318,0000 Mhz
1370
1371 freq_n = desc62_get_frequency(desc, k++);
1372 desc62n_set_freq(freq_n, 0x3240000); // 324,0000 Mhz
1373
1374 freq_n = desc62_get_frequency(desc, k++);
1375 desc62n_set_freq(freq_n, 0x3300000); // 330,0000 Mhz
1376
1377 freq_n = desc62_get_frequency(desc, k++);
1378 desc62n_set_freq(freq_n, 0x3360000); // 336,0000 Mhz
1379
1380 freq_n = desc62_get_frequency(desc, k);
1381 desc_set_length(desc, freq_n - desc - DESC_HEADER_SIZE);
1382 }
1383
1384 /* DVB Descriptor 0x63: Partial transport stream descriptor */
build_desc63(uint8_t * desc)1385 static void build_desc63(uint8_t *desc) {
1386 desc63_init(desc);
1387 desc63_set_peak_rate(desc, 5000);
1388 desc63_set_min_overall_smoothing_rate(desc, 7000);
1389 desc63_set_max_overall_smoothing_buffer(desc, 1000);
1390 }
1391
1392 /* DVB Descriptor 0x64: Data broadcast descriptor */
build_desc64(uint8_t * desc)1393 static void build_desc64(uint8_t *desc) {
1394 char *selector_byte = "BY\"TE";
1395 char *text = "Some text";
1396 desc64_init(desc);
1397 desc64_set_broadcast_id(desc, 0x1122);
1398 desc64_set_component_tag(desc, 78);
1399 desc64_set_selector_byte(desc, (uint8_t *)selector_byte, strlen(selector_byte));
1400 desc64_set_lang(desc, (uint8_t *)"eng");
1401 desc64_set_text(desc, (uint8_t *)text, strlen(text));
1402 desc64_set_length(desc);
1403 }
1404
1405 /* DVB Descriptor 0x65: Scrambling descriptor */
build_desc65(uint8_t * desc)1406 static void build_desc65(uint8_t *desc) {
1407 desc65_init(desc);
1408 desc65_set_scrambling_mode(desc, 0x01);
1409 }
1410
1411 /* DVB Descriptor 0x66: Data broadcast id descriptor */
build_desc66(uint8_t * desc)1412 static void build_desc66(uint8_t *desc) {
1413 char *selector_byte = "UNIX";
1414 desc66_init(desc);
1415 desc66_set_broadcast_id(desc, 0x1122);
1416 desc66_set_selector_byte(desc, (uint8_t *)selector_byte, strlen(selector_byte));
1417 }
1418
1419 /* DVB Descriptor 0x67: Transport stream descriptor */
build_desc67(uint8_t * desc,char * bytes)1420 static void build_desc67(uint8_t *desc, char *bytes) {
1421 desc67_init(desc);
1422 desc67_set_bytes(desc, (uint8_t *)bytes, strlen(bytes));
1423 }
1424
1425 /* DVB Descriptor 0x68: DSNG_descriptor */
build_desc68(uint8_t * desc)1426 static void build_desc68(uint8_t *desc) {
1427 char *dsng_bytes = "1234,SNG_Headquarter,SNG_Provider";
1428 desc68_init(desc);
1429 desc68_set_bytes(desc, (uint8_t *)dsng_bytes, strlen(dsng_bytes));
1430 }
1431
1432 /* DVB Descriptor 0x69: PDC_descriptor */
build_desc69(uint8_t * desc)1433 static void build_desc69(uint8_t *desc) {
1434 desc69_init(desc);
1435 // desc69_set_pil(desc, 0x5d805);
1436 desc69_set_day(desc, 11);
1437 desc69_set_month(desc, 11);
1438 desc69_set_hour(desc, 0);
1439 desc69_set_minute(desc, 5);
1440 }
1441
1442 /* DVB Descriptor 0x6a: AC-3 descriptor */
build_desc6a(uint8_t * desc)1443 static void build_desc6a(uint8_t *desc) {
1444 desc6a_init(desc);
1445
1446 desc6a_set_component_type_flag (desc, true);
1447 desc6a_set_component_type (desc, 10);
1448
1449 desc6a_set_bsid_flag (desc, true);
1450 desc6a_set_bsid (desc, 20);
1451
1452 desc6a_set_mainid_flag (desc, true);
1453 desc6a_set_mainid (desc, 30);
1454
1455 desc6a_set_asvc_flag (desc, true);
1456 desc6a_set_asvc (desc, 40);
1457
1458 desc6a_set_length(desc);
1459 }
1460
1461 /* DVB Descriptor 0x6b: Ancillary data descriptor */
build_desc6b(uint8_t * desc)1462 static void build_desc6b(uint8_t *desc) {
1463 desc6b_init(desc);
1464 desc6b_set_dvd_video_ancillary_data_flag (desc, true);
1465 desc6b_set_extended_ancillary_data_flag (desc, false);
1466 desc6b_set_announcement_switching_data_flag (desc, true);
1467 desc6b_set_dab_ancillary_data_flag (desc, false);
1468 desc6b_set_scale_factor_error_check_flag (desc, true);
1469 desc6b_set_mpeg4_ancillary_data_flag (desc, false);
1470 desc6b_set_rds_via_uecp_flag (desc, true);
1471 }
1472
1473 /* DVB Descriptor 0x6c: Cell list descriptor */
build_desc6c(uint8_t * desc)1474 static void build_desc6c(uint8_t *desc) {
1475 uint8_t n = 0, k;
1476 uint8_t *cell_n, *subcell_k;
1477
1478 desc6c_init(desc);
1479 desc_set_length(desc, 255);
1480
1481 cell_n = desc6c_get_cell(desc, n++);
1482 desc6cn_set_cell_id(cell_n, 1234);
1483 desc6cn_set_cell_latitude(cell_n, 4567);
1484 desc6cn_set_cell_longtitude(cell_n, 5678);
1485 desc6cn_set_cell_extend_of_latitude(cell_n, 123);
1486 desc6cn_set_cell_extend_of_longtitude(cell_n, 345);
1487 desc6cn_set_subcell_info_loop_length(cell_n, 0);
1488
1489 cell_n = desc6c_get_cell(desc, n++);
1490 desc6cn_set_cell_id(cell_n, 4456);
1491 desc6cn_set_cell_latitude(cell_n, 5567);
1492 desc6cn_set_cell_longtitude(cell_n, 6678);
1493 desc6cn_set_cell_extend_of_latitude(cell_n, 1234);
1494 desc6cn_set_cell_extend_of_longtitude(cell_n, 1234);
1495 desc6cn_set_subcell_info_loop_length(cell_n, 0);
1496 {
1497 k = 0;
1498 desc6cn_set_subcell_info_loop_length(cell_n, 255);
1499
1500 subcell_k = desc6cn_get_subcell(cell_n, k++);
1501 desc6ck_set_cell_id_extension(subcell_k, 0);
1502 desc6ck_set_subcell_latitude(subcell_k, 0x1122);
1503 desc6ck_set_subcell_longtitude(subcell_k, 0x3344);
1504 desc6ck_set_subcell_extend_of_latitude(subcell_k, 0xf567);
1505 desc6ck_set_subcell_extend_of_longtitude(subcell_k, 0xf89a);
1506
1507 subcell_k = desc6cn_get_subcell(cell_n, k++);
1508 desc6ck_set_cell_id_extension(subcell_k, 1);
1509 desc6ck_set_subcell_latitude(subcell_k, 0x2233);
1510 desc6ck_set_subcell_longtitude(subcell_k, 0x4455);
1511 desc6ck_set_subcell_extend_of_latitude(subcell_k, 0xf678);
1512 desc6ck_set_subcell_extend_of_longtitude(subcell_k, 0xf9ab);
1513
1514 subcell_k = desc6cn_get_subcell(cell_n, k++);
1515 desc6ck_set_cell_id_extension(subcell_k, 2);
1516 desc6ck_set_subcell_latitude(subcell_k, 0x2233);
1517 desc6ck_set_subcell_longtitude(subcell_k, 0x4455);
1518 desc6ck_set_subcell_extend_of_latitude(subcell_k, 0xf678);
1519 desc6ck_set_subcell_extend_of_longtitude(subcell_k, 0xf9ab);
1520
1521 subcell_k = desc6cn_get_subcell(cell_n, k);
1522 desc6cn_set_subcell_info_loop_length(cell_n, subcell_k - cell_n - DESC6C_DATA_SIZE);
1523 }
1524
1525 cell_n = desc6c_get_cell(desc, n++);
1526 desc6cn_set_cell_id(cell_n, 0xffff);
1527 desc6cn_set_cell_latitude(cell_n, 0xeeee);
1528 desc6cn_set_cell_longtitude(cell_n, 0xdddd);
1529 desc6cn_set_cell_extend_of_latitude(cell_n, 0xf789);
1530 desc6cn_set_cell_extend_of_longtitude(cell_n, 0xfabc);
1531 desc6cn_set_subcell_info_loop_length(cell_n, 0);
1532 {
1533 k = 0;
1534 desc6cn_set_subcell_info_loop_length(cell_n, 255);
1535
1536 subcell_k = desc6cn_get_subcell(cell_n, k++);
1537 desc6ck_set_cell_id_extension(subcell_k, 0x00);
1538 desc6ck_set_subcell_latitude(subcell_k, 0x1122);
1539 desc6ck_set_subcell_longtitude(subcell_k, 0x3344);
1540 desc6ck_set_subcell_extend_of_latitude(subcell_k, 0xf567);
1541 desc6ck_set_subcell_extend_of_longtitude(subcell_k, 0xf89a);
1542
1543 subcell_k = desc6cn_get_subcell(cell_n, k);
1544 desc6cn_set_subcell_info_loop_length(cell_n, subcell_k - cell_n - DESC6C_DATA_SIZE);
1545 }
1546
1547 cell_n = desc6c_get_cell(desc, n);
1548 desc_set_length(desc, cell_n - desc - DESC_HEADER_SIZE);
1549 }
1550
1551 /* DVB Descriptor 0x6d: Cell frequency link descriptor */
build_desc6d(uint8_t * desc)1552 static void build_desc6d(uint8_t *desc) {
1553 uint8_t n = 0, k;
1554 uint8_t *cell_n, *subcell_k;
1555
1556 desc6d_init(desc);
1557 desc_set_length(desc, 255);
1558
1559 cell_n = desc6d_get_cell(desc, n++);
1560 desc6dn_set_cell_id(cell_n, 1234);
1561 desc6dn_set_frequency(cell_n, 4567);
1562 desc6dn_set_subcell_info_loop_length(cell_n, 0);
1563
1564 cell_n = desc6d_get_cell(desc, n++);
1565 desc6dn_set_cell_id(cell_n, 4456);
1566 desc6dn_set_frequency(cell_n, 5567);
1567 desc6dn_set_subcell_info_loop_length(cell_n, 0);
1568 {
1569 k = 0;
1570 desc6dn_set_subcell_info_loop_length(cell_n, 255);
1571
1572 subcell_k = desc6dn_get_subcell(cell_n, k++);
1573 desc6dk_set_cell_id_extension(subcell_k, 0);
1574 desc6dk_set_transponder_frequency(subcell_k, 1122);
1575
1576 subcell_k = desc6dn_get_subcell(cell_n, k++);
1577 desc6dk_set_cell_id_extension(subcell_k, 1);
1578 desc6dk_set_transponder_frequency(subcell_k, 2233);
1579
1580 subcell_k = desc6dn_get_subcell(cell_n, k++);
1581 desc6dk_set_cell_id_extension(subcell_k, 2);
1582 desc6dk_set_transponder_frequency(subcell_k, 3344);
1583
1584 subcell_k = desc6dn_get_subcell(cell_n, k);
1585 desc6dn_set_subcell_info_loop_length(cell_n, subcell_k - cell_n - DESC6D_DATA_SIZE);
1586 }
1587
1588 cell_n = desc6d_get_cell(desc, n++);
1589 desc6dn_set_cell_id(cell_n, 7890);
1590 desc6dn_set_frequency(cell_n, 56789);
1591 desc6dn_set_subcell_info_loop_length(cell_n, 0);
1592 {
1593 k = 0;
1594 desc6dn_set_subcell_info_loop_length(cell_n, 255);
1595
1596 subcell_k = desc6dn_get_subcell(cell_n, k++);
1597 desc6dk_set_cell_id_extension(subcell_k, 0);
1598 desc6dk_set_transponder_frequency(subcell_k, 889911);
1599
1600 subcell_k = desc6dn_get_subcell(cell_n, k);
1601 desc6dn_set_subcell_info_loop_length(cell_n, subcell_k - cell_n - DESC6D_DATA_SIZE);
1602 }
1603
1604 cell_n = desc6d_get_cell(desc, n);
1605 desc_set_length(desc, cell_n - desc - DESC_HEADER_SIZE);
1606 }
1607
1608 /* DVB Descriptor 0x6e: Announcement support descriptor */
build_desc6e(uint8_t * desc)1609 static void build_desc6e(uint8_t *desc) {
1610 desc6e_init(desc);
1611
1612 desc6e_set_emergency_alarm_flag (desc, true);
1613 desc6e_set_road_traffic_flash_flag (desc, false);
1614 desc6e_set_public_transport_flash_flag (desc, true);
1615 desc6e_set_warning_message_flag (desc, true);
1616 desc6e_set_news_flash_flag (desc, true);
1617 desc6e_set_weather_flash_flag (desc, true);
1618 desc6e_set_event_announcement_flag (desc, false);
1619 desc6e_set_personal_call_flag (desc, false);
1620
1621 {
1622 uint8_t n = 0;
1623 uint8_t *ann_n;
1624 desc_set_length(desc, 255);
1625
1626 ann_n = desc6e_get_announcement(desc, n++);
1627 desc6en_set_announcement_type(ann_n, 0); // Emergency alarm
1628 desc6en_set_reference_type(ann_n, 0);
1629
1630 ann_n = desc6e_get_announcement(desc, n++);
1631 desc6en_set_announcement_type(ann_n, 3); // Warning alarm
1632 desc6en_set_reference_type(ann_n, 1);
1633
1634 // The following are valid only if
1635 // reference_type == 0x01
1636 // || reference_type == 0x02
1637 // || reference_type == 0x03
1638 //
1639 desc6en_set_onid(ann_n, 0x1122);
1640 desc6en_set_tsid(ann_n, 0x3344);
1641 desc6en_set_service_id(ann_n, 0x5566);
1642 desc6en_set_component_tag(ann_n, 0x77);
1643
1644 ann_n = desc6e_get_announcement(desc, n++);
1645 desc6en_set_announcement_type(ann_n, 5); // Weather flash
1646 desc6en_set_reference_type(ann_n, 0);
1647
1648 ann_n = desc6e_get_announcement(desc, n++);
1649 desc6en_set_announcement_type(ann_n, 2); // Public Transport flash
1650 desc6en_set_reference_type(ann_n, 3);
1651
1652 // The following are valid only if
1653 // reference_type == 0x01
1654 // || reference_type == 0x02
1655 // || reference_type == 0x03
1656 //
1657 desc6en_set_onid(ann_n, 0x6677);
1658 desc6en_set_tsid(ann_n, 0x8899);
1659 desc6en_set_service_id(ann_n, 0x4455);
1660 desc6en_set_component_tag(ann_n, 0x88);
1661
1662 ann_n = desc6e_get_announcement(desc, n++);
1663 desc6en_set_announcement_type(ann_n, 4); // News flash
1664 desc6en_set_reference_type(ann_n, 0);
1665
1666 ann_n = desc6e_get_announcement(desc, n);
1667 desc_set_length(desc, ann_n - desc - DESC_HEADER_SIZE);
1668 }
1669 }
1670
1671 /* --- Descriptor 0x6f: application_signalling_descriptor */
1672 /* --- Descriptor 0x70: adaptation_field_data_descriptor */
1673 /* --- Descriptor 0x71: service_identifier_descriptor */
1674 /* --- Descriptor 0x72: service_availability_descriptor */
1675 /* --- Descriptor 0x73: default_authority_descriptor */
1676 /* --- Descriptor 0x74: related_content_descriptor */
1677 /* --- Descriptor 0x75: TVA_id_descriptor */
1678 /* --- Descriptor 0x76: content_identifier_descriptor */
1679 /* --- Descriptor 0x77: time_slice_fec_identifier_descriptor */
1680 /* --- Descriptor 0x78: ECM_repetition_rate_descriptor */
1681 /* --- Descriptor 0x79: S2_satellite_delivery_system_descriptor */
1682
1683 /* DVB Descriptor 0x7a: Enhanced AC-3 descriptor */
build_desc7a(uint8_t * desc)1684 static void build_desc7a(uint8_t *desc) {
1685 desc7a_init(desc);
1686
1687 desc7a_set_component_type_flag (desc, true);
1688 desc7a_set_component_type (desc, 10);
1689
1690 desc7a_set_bsid_flag (desc, true);
1691 desc7a_set_bsid (desc, 20);
1692
1693 desc7a_set_mainid_flag (desc, true);
1694 desc7a_set_mainid (desc, 30);
1695
1696 desc7a_set_asvc_flag (desc, true);
1697 desc7a_set_asvc (desc, 40);
1698
1699 desc7a_set_mixinfoexists_flag (desc, true);
1700
1701 desc7a_set_substream1_flag (desc, true);
1702 desc7a_set_substream1 (desc, 50);
1703
1704 desc7a_set_substream2_flag (desc, true);
1705 desc7a_set_substream2 (desc, 60);
1706
1707 desc7a_set_substream3_flag (desc, true);
1708 desc7a_set_substream3 (desc, 70);
1709
1710 desc7a_set_length(desc);
1711 }
1712
1713 /* DVB Descriptor 0x7b: DTS descriptor */
build_desc7b(uint8_t * desc)1714 static void build_desc7b(uint8_t *desc) {
1715 desc7b_init(desc);
1716 desc7b_set_sample_rate_code(desc, 8);
1717 desc7b_set_bit_rate_code(desc, 11);
1718 desc7b_set_nblks(desc, 5);
1719 desc7b_set_fsize(desc, 95);
1720 desc7b_set_surround_mode(desc, 3);
1721 desc7b_set_lfe_flag(desc, true);
1722 desc7b_set_extended_surround_flag(desc, 2);
1723 }
1724
1725 /* DVB Descriptor 0x7c: AAC descriptor */
build_desc7c(uint8_t * desc)1726 static void build_desc7c(uint8_t *desc) {
1727 desc7c_init(desc);
1728 desc7c_set_profile_and_level(desc, 0x14);
1729 desc7c_set_aac_type_flag(desc, true);
1730 desc7c_set_aac_type(desc, 0x1f);
1731 }
1732
1733 /* --- Descriptor 0x7d: XAIT location descriptor */
1734 /* --- Descriptor 0x7e: FTA_content_management_descriptor */
1735 /* --- Descriptor 0x7f: extension descriptor */
1736
output_psi_section(uint8_t * section,uint16_t pid,uint8_t * cc)1737 static void output_psi_section(uint8_t *section, uint16_t pid, uint8_t *cc) {
1738 uint16_t section_length = psi_get_length(section) + PSI_HEADER_SIZE;
1739 uint16_t section_offset = 0;
1740 do {
1741 uint8_t ts[TS_SIZE];
1742 uint8_t ts_offset = 0;
1743 memset(ts, 0xff, TS_SIZE);
1744
1745 psi_split_section(ts, &ts_offset, section, §ion_offset);
1746
1747 ts_set_pid(ts, pid);
1748 ts_set_cc(ts, *cc);
1749 (*cc)++;
1750 *cc &= 0xf;
1751
1752 if (section_offset == section_length)
1753 psi_split_end(ts, &ts_offset);
1754
1755 if (write(fileno(stdout), ts, TS_SIZE) < 0)
1756 perror("write");
1757 } while (section_offset < section_length);
1758 }
1759
1760 /* =========================================================================
1761 * SI Tables
1762 * ========================================================================= */
1763
1764 /* MPEG Program Allocation Table (PAT) */
generate_pat(void)1765 static void generate_pat(void) {
1766 // Generate empty PAT
1767 uint8_t *pat = psi_allocate();
1768 uint8_t *pat_n;
1769 uint8_t j = 0;
1770
1771 // Generate empty PAT
1772 pat_init(pat);
1773 pat_set_length(pat, 0);
1774 pat_set_tsid(pat, tsid);
1775 psi_set_version(pat, 0);
1776 psi_set_current(pat);
1777 psi_set_section(pat, 0);
1778 psi_set_lastsection(pat, 0);
1779 psi_set_crc(pat);
1780 output_psi_section(pat, PAT_PID, &cc);
1781
1782 // Increase PAT version
1783 psi_set_version(pat, 1);
1784 psi_set_current(pat);
1785 psi_set_crc(pat);
1786 output_psi_section(pat, PAT_PID, &cc);
1787
1788 // Add couple of programs to PAT
1789 psi_set_version(pat, 2);
1790 psi_set_current(pat);
1791 psi_set_length(pat, PSI_MAX_SIZE);
1792
1793 pat_n = pat_get_program(pat, j++);
1794 patn_init(pat_n);
1795 patn_set_program(pat_n, 0);
1796 patn_set_pid(pat_n, NIT_PID);
1797
1798 pat_n = pat_get_program(pat, j++);
1799 patn_init(pat_n);
1800 patn_set_program(pat_n, sid);
1801 patn_set_pid(pat_n, pmt_pid);
1802
1803 pat_n = pat_get_program(pat, j++);
1804 patn_init(pat_n);
1805 patn_set_program(pat_n, sid + 100);
1806 patn_set_pid(pat_n, pmt_pid + 100);
1807
1808 pat_n = pat_get_program(pat, j++);
1809 patn_init(pat_n);
1810 patn_set_program(pat_n, sid + 200);
1811 patn_set_pid(pat_n, pmt_pid + 200);
1812
1813 pat_n = pat_get_program(pat, j++);
1814 patn_init(pat_n);
1815 patn_set_program(pat_n, sid + 300);
1816 patn_set_pid(pat_n, pmt_pid + 300);
1817
1818 // Set correct PAT length
1819 pat_n = pat_get_program(pat, j); // Get offset of the end of last program
1820 pat_set_length(pat, pat_n - pat - PAT_HEADER_SIZE);
1821 psi_set_crc(pat);
1822
1823 output_psi_section(pat, PAT_PID, &cc);
1824
1825 free(pat);
1826 }
1827
1828 /* MPEG Conditional Access Table (CAT) */
generate_cat(void)1829 static void generate_cat(void) {
1830 // Generate empty cat
1831 uint8_t *cat = psi_allocate();
1832 uint8_t *desc;
1833 uint8_t desc_loop[DESCS_HEADER_SIZE + DESCS_MAX_SIZE];
1834 uint8_t desc_counter;
1835
1836 cat_init(cat);
1837 cat_set_length(cat, 0);
1838 psi_set_version(cat, 0);
1839 psi_set_current(cat);
1840 psi_set_crc(cat);
1841 output_psi_section(cat, CAT_PID, &cc);
1842
1843 // Increase CAT version
1844 psi_set_version(cat, 1);
1845 psi_set_current(cat);
1846 psi_set_crc(cat);
1847 output_psi_section(cat, CAT_PID, &cc);
1848
1849 // Add couple of descriptors to CAT
1850 psi_set_version(cat, 2);
1851 psi_set_current(cat);
1852 psi_set_length(cat, PSI_MAX_SIZE);
1853
1854 descs_set_length(desc_loop, DESCS_MAX_SIZE);
1855 desc_counter = 0;
1856
1857 desc = descs_get_desc(desc_loop, desc_counter++);
1858 build_desc09(desc);
1859
1860 desc = descs_get_desc(desc_loop, desc_counter++);
1861 build_desc09(desc);
1862
1863 desc = descs_get_desc(desc_loop, desc_counter++);
1864 build_desc09(desc);
1865
1866 // Finish descriptor generation
1867 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
1868 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
1869 cat_set_desclength(cat, descs_get_length(desc_loop));
1870 // Put descriptor loop into CAT
1871 memcpy(cat_get_descl(cat), desc_loop + DESCS_HEADER_SIZE,
1872 descs_get_length(desc_loop));
1873
1874 psi_set_crc(cat);
1875 output_psi_section(cat, CAT_PID, &cc);
1876
1877 free(cat);
1878 }
1879
1880 /* MPEG Conditional Access Table (TSDT) */
generate_tsdt(void)1881 static void generate_tsdt(void) {
1882 // Generate empty tsdt
1883 uint8_t *tsdt = psi_allocate();
1884 uint8_t *desc;
1885 uint8_t desc_loop[DESCS_HEADER_SIZE + DESCS_MAX_SIZE];
1886 uint8_t desc_counter;
1887
1888 tsdt_init(tsdt);
1889 tsdt_set_length(tsdt, 0);
1890 psi_set_version(tsdt, 0);
1891 psi_set_current(tsdt);
1892 psi_set_crc(tsdt);
1893 output_psi_section(tsdt, TSDT_PID, &cc);
1894
1895 // Add couple of descriptors to TSDT
1896 psi_set_version(tsdt, 1);
1897 psi_set_current(tsdt);
1898 psi_set_length(tsdt, PSI_MAX_SIZE);
1899
1900 descs_set_length(desc_loop, DESCS_MAX_SIZE);
1901 desc_counter = 0;
1902
1903 desc = descs_get_desc(desc_loop, desc_counter++);
1904 build_desc67(desc, "DVB");
1905
1906 desc = descs_get_desc(desc_loop, desc_counter++);
1907 build_desc67(desc, "CONT");
1908
1909 desc = descs_get_desc(desc_loop, desc_counter++);
1910 build_desc68(desc);
1911
1912 // Finish descriptor generation
1913 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
1914 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
1915 tsdt_set_desclength(tsdt, descs_get_length(desc_loop));
1916 // Put descriptor loop into TSDT
1917 memcpy(tsdt_get_descl(tsdt), desc_loop + DESCS_HEADER_SIZE,
1918 descs_get_length(desc_loop));
1919
1920 psi_set_crc(tsdt);
1921 output_psi_section(tsdt, TSDT_PID, &cc);
1922
1923 free(tsdt);
1924 }
1925
1926 /* DVB Network Information Table (NIT) */
generate_nit(void)1927 static void generate_nit(void) {
1928 uint8_t *nit = psi_allocate();
1929 uint8_t *nit_tsloop;
1930 uint8_t *desc_loop, *desc;
1931 uint8_t desc_counter;
1932
1933 // Generate empty nit
1934 nit_init(nit, true);
1935 psi_set_version(nit, 0);
1936 psi_set_current(nit);
1937 nit_set_nid(nit, onid);
1938 nit_set_length(nit, 2);
1939
1940 nit_set_desclength(nit, 0);
1941
1942 nit_tsloop = nit_get_header2(nit);
1943 nith_init(nit_tsloop);
1944 nith_set_tslength(nit_tsloop, 0);
1945
1946 psi_set_crc(nit);
1947
1948 output_psi_section(nit, NIT_PID, &cc);
1949
1950 // Add descriptors and transport stream loop
1951 nit_init(nit, true);
1952 psi_set_version(nit, 1);
1953 psi_set_current(nit);
1954 nit_set_nid(nit, onid);
1955 nit_set_length(nit, PSI_MAX_SIZE);
1956 nit_set_desclength(nit, 0);
1957
1958 {
1959 // Add descriptors to network descriptors
1960 desc_counter = 0;
1961 desc_loop = nit_get_descs(nit);
1962
1963 nit_set_desclength(nit, DESCS_MAX_SIZE);
1964 desc = descs_get_desc(desc_loop, desc_counter++);
1965 build_desc40(desc);
1966
1967 desc = descs_get_desc(desc_loop, desc_counter++);
1968 build_desc43(desc);
1969
1970 desc = descs_get_desc(desc_loop, desc_counter++);
1971 build_desc44(desc);
1972
1973 desc = descs_get_desc(desc_loop, desc_counter++);
1974 build_desc5a(desc);
1975
1976 desc = descs_get_desc(desc_loop, desc_counter++);
1977 build_desc5b(desc);
1978
1979 desc = descs_get_desc(desc_loop, desc_counter++);
1980 build_desc62(desc);
1981
1982 desc = descs_get_desc(desc_loop, desc_counter++);
1983 build_desc6c(desc);
1984
1985 desc = descs_get_desc(desc_loop, desc_counter++);
1986 build_desc6d(desc);
1987
1988 // Finish descriptor generation
1989 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
1990 nit_set_desclength(nit, desc - desc_loop - DESCS_HEADER_SIZE);
1991 nit_set_length(nit, 2 + nit_get_desclength(nit));
1992 }
1993
1994 // Process transport stream loop
1995 nit_tsloop = nit_get_header2(nit);
1996 nith_init(nit_tsloop);
1997 nit_set_length(nit, PSI_MAX_SIZE); // This needed so nit_get_ts works
1998 {
1999 uint8_t *nit_n;
2000 uint8_t nit_n_counter = 0;
2001
2002 nit_n = nit_get_ts(nit, nit_n_counter++);
2003 nitn_init(nit_n);
2004 nitn_set_tsid(nit_n, tsid);
2005 nitn_set_onid(nit_n, onid);
2006 nitn_set_desclength(nit_n, 0);
2007 {
2008 // Add descriptors to transport_stream_n
2009 desc_counter = 0;
2010 desc_loop = nitn_get_descs(nit_n);
2011 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2012
2013 desc = descs_get_desc(desc_loop, desc_counter++);
2014 build_desc41(desc);
2015
2016 desc = descs_get_desc(desc_loop, desc_counter++);
2017 build_desc4a_std(desc);
2018
2019 // Finish descriptor generation
2020 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2021 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2022 }
2023
2024 nit_n = nit_get_ts(nit, nit_n_counter++);
2025 nitn_init(nit_n);
2026 nitn_set_tsid(nit_n, tsid + 100);
2027 nitn_set_onid(nit_n, onid + 100);
2028 nitn_set_desclength(nit_n, 0);
2029
2030 nit_n = nit_get_ts(nit, nit_n_counter++);
2031 nitn_init(nit_n);
2032 nitn_set_tsid(nit_n, tsid + 200);
2033 nitn_set_onid(nit_n, onid + 200);
2034 nitn_set_onid(nit_n, onid + 200);
2035 nitn_set_desclength(nit_n, 0);
2036 {
2037 // Add descriptors to transport_stream_n
2038 desc_counter = 0;
2039 desc_loop = nitn_get_descs(nit_n);
2040 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2041
2042 desc = descs_get_desc(desc_loop, desc_counter++);
2043 build_desc41(desc);
2044
2045 desc = descs_get_desc(desc_loop, desc_counter++);
2046 build_desc4a_mobile(desc);
2047
2048 // Finish descriptor generation
2049 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2050 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2051 }
2052
2053 nit_n = nit_get_ts(nit, nit_n_counter++);
2054 nitn_init(nit_n);
2055 nitn_set_tsid(nit_n, tsid + 300);
2056 nitn_set_onid(nit_n, onid + 300);
2057 nitn_set_desclength(nit_n, 0);
2058
2059 // Set transport_stream_loop length
2060 nit_n = nit_get_ts(nit, nit_n_counter); // Get last ts
2061 nith_set_tslength(nit_tsloop, nit_n - nit_tsloop - NIT_HEADER2_SIZE);
2062 }
2063 // Set NIT length
2064 nit_set_length(nit, 2 + nit_get_desclength(nit) + nith_get_tslength(nit_tsloop));
2065 psi_set_crc(nit);
2066
2067 output_psi_section(nit, NIT_PID, &cc);
2068
2069 free(nit);
2070 }
2071
2072 /* DVB Bouquet Association Table (BAT) */
generate_bat(void)2073 static void generate_bat(void) {
2074 uint8_t *bat = psi_allocate();
2075 uint8_t *bat_tsloop;
2076 uint8_t *desc_loop, *desc;
2077 uint8_t desc_counter;
2078
2079 // Generate empty BAT
2080 bat_init(bat);
2081 psi_set_version(bat, 0);
2082 psi_set_current(bat);
2083 bat_set_bouquet_id(bat, onid);
2084 bat_set_length(bat, 2);
2085
2086 bat_set_desclength(bat, 0);
2087
2088 bat_tsloop = bat_get_header2(bat);
2089 bath_init(bat_tsloop);
2090 bath_set_tslength(bat_tsloop, 0);
2091
2092 psi_set_crc(bat);
2093
2094 output_psi_section(bat, BAT_PID, &cc);
2095
2096 // Add descriptors and transport stream loop
2097 bat_init(bat);
2098 psi_set_version(bat, 1);
2099 psi_set_current(bat);
2100 bat_set_bouquet_id(bat, onid);
2101 bat_set_length(bat, PSI_MAX_SIZE);
2102 bat_set_desclength(bat, 0);
2103
2104 {
2105 // Add descriptors to bouquet descriptors
2106 bat_set_desclength(bat, DESCS_MAX_SIZE);
2107
2108 desc_counter = 0;
2109 desc_loop = bat_get_descs(bat);
2110
2111 desc = descs_get_desc(desc_loop, desc_counter++);
2112 build_desc47(desc);
2113
2114 desc = descs_get_desc(desc_loop, desc_counter++);
2115 build_desc5c(desc);
2116
2117 // Finish descriptor generation
2118 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2119 bat_set_desclength(bat, desc - desc_loop - DESCS_HEADER_SIZE);
2120 bat_set_length(bat, 2 + bat_get_desclength(bat));
2121 }
2122
2123 // Process transport stream loop
2124 bat_tsloop = bat_get_header2(bat);
2125 bath_init(bat_tsloop);
2126 bat_set_length(bat, PSI_MAX_SIZE); // This needed so bat_get_ts works
2127 {
2128 uint8_t *bat_n;
2129 uint8_t bat_n_counter = 0;
2130
2131 bat_n = bat_get_ts(bat, bat_n_counter++);
2132 batn_init(bat_n);
2133 batn_set_tsid(bat_n, tsid);
2134 batn_set_onid(bat_n, onid);
2135 batn_set_desclength(bat_n, 0);
2136 {
2137 // Add descriptors to transport_stream_n
2138 desc_counter = 0;
2139 desc_loop = batn_get_descs(bat_n);
2140 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2141
2142 desc = descs_get_desc(desc_loop, desc_counter++);
2143 build_desc41(desc);
2144
2145 // Finish descriptor generation
2146 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2147 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2148 }
2149
2150 bat_n = bat_get_ts(bat, bat_n_counter++);
2151 batn_init(bat_n);
2152 batn_set_tsid(bat_n, tsid + 100);
2153 batn_set_onid(bat_n, onid + 100);
2154 batn_set_desclength(bat_n, 0);
2155
2156 bat_n = bat_get_ts(bat, bat_n_counter++);
2157 batn_init(bat_n);
2158 batn_set_tsid(bat_n, tsid + 200);
2159 batn_set_onid(bat_n, onid + 200);
2160 batn_set_desclength(bat_n, 0);
2161 {
2162 // Add descriptors to transport_stream_n
2163 desc_counter = 0;
2164 desc_loop = batn_get_descs(bat_n);
2165 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2166
2167 desc = descs_get_desc(desc_loop, desc_counter++);
2168 build_desc41(desc);
2169
2170 // Finish descriptor generation
2171 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2172 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2173 }
2174
2175 bat_n = bat_get_ts(bat, bat_n_counter++);
2176 batn_init(bat_n);
2177 batn_set_tsid(bat_n, tsid + 300);
2178 batn_set_onid(bat_n, onid + 300);
2179 batn_set_desclength(bat_n, 0);
2180
2181 // Set transport_stream_loop length
2182 bat_n = bat_get_ts(bat, bat_n_counter); // Get last ts
2183 bath_set_tslength(bat_tsloop, bat_n - bat_tsloop - BAT_HEADER2_SIZE);
2184 }
2185 // Set BAT length
2186 bat_set_length(bat, 2 + bat_get_desclength(bat) + bath_get_tslength(bat_tsloop));
2187 psi_set_crc(bat);
2188
2189 output_psi_section(bat, BAT_PID, &cc);
2190
2191 free(bat);
2192 }
2193
2194 /* DVB Service Definition Table (SDT) */
generate_sdt(void)2195 static void generate_sdt(void) {
2196 uint8_t *sdt = psi_allocate();
2197 uint8_t *desc_loop, *desc;
2198 uint8_t desc_counter;
2199
2200 // Generate empty SDT
2201 sdt_init(sdt, true);
2202 psi_set_version(sdt, 0);
2203 psi_set_current(sdt);
2204 sdt_set_tsid(sdt, tsid);
2205 sdt_set_onid(sdt, onid);
2206 sdt_set_length(sdt, 0);
2207 psi_set_crc(sdt);
2208 output_psi_section(sdt, SDT_PID, &cc);
2209
2210 // Add service descriptions
2211 sdt_init(sdt, true);
2212 psi_set_version(sdt, 1);
2213 psi_set_current(sdt);
2214 sdt_set_tsid(sdt, tsid);
2215 sdt_set_onid(sdt, onid);
2216
2217 // Process transport stream loop
2218 sdt_set_length(sdt, PSI_MAX_SIZE); // This needed so sdt_get_ts works
2219 {
2220 uint8_t *sdt_n;
2221 uint8_t sdt_n_counter = 0;
2222
2223 sdt_n = sdt_get_service(sdt, sdt_n_counter++);
2224 sdtn_init(sdt_n);
2225 sdtn_set_sid(sdt_n, sid);
2226 sdtn_set_running(sdt_n, 2);
2227 sdtn_set_desclength(sdt_n, 0);
2228 {
2229 // Add descriptors to transport_stream_n
2230 desc_counter = 0;
2231 desc_loop = sdtn_get_descs(sdt_n);
2232 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2233
2234 desc = descs_get_desc(desc_loop, desc_counter++);
2235 build_desc48(desc);
2236
2237 desc = descs_get_desc(desc_loop, desc_counter++);
2238 build_desc49(desc, true);
2239
2240 desc = descs_get_desc(desc_loop, desc_counter++);
2241 build_desc51(desc);
2242
2243 desc = descs_get_desc(desc_loop, desc_counter++);
2244 build_desc57(desc);
2245
2246 desc = descs_get_desc(desc_loop, desc_counter++);
2247 build_desc5d(desc);
2248
2249 desc = descs_get_desc(desc_loop, desc_counter++);
2250 build_desc5f(desc);
2251
2252 // Finish descriptor generation
2253 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2254 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2255 }
2256
2257 sdt_n = sdt_get_service(sdt, sdt_n_counter++);
2258 sdtn_init(sdt_n);
2259 sdtn_set_sid(sdt_n, sid + 100);
2260 sdtn_set_eitschedule(sdt_n);
2261 sdtn_set_running(sdt_n, 1);
2262 sdtn_set_desclength(sdt_n, 0);
2263 {
2264 // Add descriptors to transport_stream_n
2265 desc_counter = 0;
2266 desc_loop = sdtn_get_descs(sdt_n);
2267 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2268
2269 desc = descs_get_desc(desc_loop, desc_counter++);
2270 build_desc48(desc);
2271
2272 desc = descs_get_desc(desc_loop, desc_counter++);
2273 build_desc49(desc, false);
2274
2275 desc = descs_get_desc(desc_loop, desc_counter++);
2276 build_desc5f(desc);
2277
2278 desc = descs_get_desc(desc_loop, desc_counter++);
2279 build_desc6e(desc);
2280
2281 // Finish descriptor generation
2282 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2283 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2284 }
2285
2286 sdt_n = sdt_get_service(sdt, sdt_n_counter++);
2287 sdtn_init(sdt_n);
2288 sdtn_set_sid(sdt_n, sid + 200);
2289 sdtn_set_eitschedule(sdt_n);
2290 sdtn_set_eitpresent(sdt_n);
2291 sdtn_set_running(sdt_n, 3);
2292 sdtn_set_desclength(sdt_n, 0);
2293 {
2294 // Add descriptors to transport_stream_n
2295 desc_counter = 0;
2296 desc_loop = sdtn_get_descs(sdt_n);
2297 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2298
2299 desc = descs_get_desc(desc_loop, desc_counter++);
2300 build_desc48(desc);
2301
2302 desc = descs_get_desc(desc_loop, desc_counter++);
2303 build_desc4c(desc);
2304
2305 desc = descs_get_desc(desc_loop, desc_counter++);
2306 build_desc5f(desc);
2307
2308 desc = descs_get_desc(desc_loop, desc_counter++);
2309 build_desc64(desc);
2310
2311 desc = descs_get_desc(desc_loop, desc_counter++);
2312 build_desc66(desc);
2313
2314 // Finish descriptor generation
2315 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2316 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2317 }
2318
2319 sdt_n = sdt_get_service(sdt, sdt_n_counter++);
2320 sdtn_init(sdt_n);
2321 sdtn_set_sid(sdt_n, sid + 300);
2322 sdtn_set_eitschedule(sdt_n);
2323 sdtn_set_eitpresent(sdt_n);
2324 sdtn_set_running(sdt_n, 2);
2325 sdtn_set_ca(sdt_n);
2326 sdtn_set_desclength(sdt_n, 0);
2327 {
2328 // Add descriptors to transport_stream_n
2329 desc_counter = 0;
2330 desc_loop = sdtn_get_descs(sdt_n);
2331 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2332
2333 desc = descs_get_desc(desc_loop, desc_counter++);
2334 build_desc48(desc);
2335
2336 desc = descs_get_desc(desc_loop, desc_counter++);
2337 build_desc4b(desc, false);
2338
2339 desc = descs_get_desc(desc_loop, desc_counter++);
2340 build_desc5f(desc);
2341
2342 // Finish descriptor generation
2343 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2344 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2345 }
2346
2347 // Set transport_stream_loop length
2348 sdt_n = sdt_get_service(sdt, sdt_n_counter); // Get last service
2349 sdt_set_length(sdt, sdt_n - sdt_get_service(sdt, 0));
2350 }
2351 psi_set_crc(sdt);
2352 output_psi_section(sdt, SDT_PID, &cc);
2353
2354 free(sdt);
2355 }
2356
2357 /* DVB Event Information Table (EIT) */
generate_eit(void)2358 static void generate_eit(void) {
2359 uint8_t *eit = psi_private_allocate();
2360 uint8_t *desc_loop, *desc;
2361 uint8_t desc_counter;
2362
2363 // Generate empty EIT
2364 eit_init(eit, true);
2365 psi_set_version(eit, 0);
2366 psi_set_current(eit);
2367
2368 eit_set_length(eit, 0);
2369 eit_set_sid(eit, sid);
2370 eit_set_tsid(eit, tsid);
2371 eit_set_onid(eit, onid);
2372 eit_set_segment_last_sec_number(eit, 0);
2373 eit_set_last_table_id(eit, 0);
2374 psi_set_crc(eit);
2375 output_psi_section(eit, EIT_PID, &cc);
2376
2377 // Add service descriptions
2378 eit_init(eit, true);
2379 psi_set_version(eit, 1);
2380 psi_set_current(eit);
2381 eit_set_tsid(eit, tsid);
2382 eit_set_onid(eit, onid);
2383
2384 // Process transport stream loop
2385 eit_set_length(eit, PSI_MAX_SIZE); // This needed so eit_get_ts works
2386 {
2387 uint8_t *eit_n;
2388 uint8_t eit_n_counter = 0;
2389
2390 eit_n = eit_get_event(eit, eit_n_counter++);
2391 eitn_set_event_id(eit_n, event_id);
2392 eitn_set_start_time(eit_n, dvb_time_encode_UTC(ts_0));
2393 eitn_set_duration_bcd(eit_n, dvb_time_encode_duration(86399));
2394 eitn_set_running(eit_n, 2);
2395 eitn_set_desclength(eit_n, 0);
2396 {
2397 // Add descriptors to transport_stream_n
2398 desc_counter = 0;
2399 desc_loop = eitn_get_descs(eit_n);
2400 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2401
2402 desc = descs_get_desc(desc_loop, desc_counter++);
2403 build_desc4d(desc);
2404
2405 // Finish descriptor generation
2406 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2407 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2408 }
2409
2410 eit_n = eit_get_event(eit, eit_n_counter++);
2411 eitn_set_event_id(eit_n, event_id + 100);
2412 eitn_set_start_time(eit_n, dvb_time_encode_UTC(ts_1));
2413 eitn_set_duration_bcd(eit_n, dvb_time_encode_duration(3600));
2414 eitn_set_running(eit_n, 1);
2415 eitn_set_desclength(eit_n, 0);
2416 {
2417 // Add descriptors to transport_stream_n
2418 desc_counter = 0;
2419 desc_loop = eitn_get_descs(eit_n);
2420 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2421
2422 desc = descs_get_desc(desc_loop, desc_counter++);
2423 build_desc4a_event(desc);
2424
2425 desc = descs_get_desc(desc_loop, desc_counter++);
2426 build_desc4e(desc);
2427
2428 desc = descs_get_desc(desc_loop, desc_counter++);
2429 build_desc4d(desc);
2430
2431 desc = descs_get_desc(desc_loop, desc_counter++);
2432 build_desc61(desc);
2433
2434 // Finish descriptor generation
2435 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2436 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2437 }
2438
2439 eit_n = eit_get_event(eit, eit_n_counter++);
2440 eitn_set_event_id(eit_n, event_id + 200);
2441 eitn_set_start_time(eit_n, dvb_time_encode_UTC(ts_2));
2442 eitn_set_duration_bcd(eit_n, dvb_time_encode_duration(7200));
2443 eitn_set_running(eit_n, 0);
2444 eitn_set_desclength(eit_n, 0);
2445 {
2446 // Add descriptors to transport_stream_n
2447 desc_counter = 0;
2448 desc_loop = eitn_get_descs(eit_n);
2449 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2450
2451 desc = descs_get_desc(desc_loop, desc_counter++);
2452 build_desc4a_extended_event(desc);
2453
2454 desc = descs_get_desc(desc_loop, desc_counter++);
2455 build_desc54(desc);
2456
2457 desc = descs_get_desc(desc_loop, desc_counter++);
2458 build_desc53(desc);
2459
2460 desc = descs_get_desc(desc_loop, desc_counter++);
2461 build_desc55(desc);
2462
2463 desc = descs_get_desc(desc_loop, desc_counter++);
2464 build_desc4d(desc);
2465
2466 desc = descs_get_desc(desc_loop, desc_counter++);
2467 build_desc4f(desc);
2468
2469 // Finish descriptor generation
2470 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2471 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2472 }
2473
2474 eit_n = eit_get_event(eit, eit_n_counter++);
2475 eitn_set_event_id(eit_n, event_id + 300);
2476 eitn_set_start_time(eit_n, dvb_time_encode_UTC(ts_2));
2477 eitn_set_duration_bcd(eit_n, dvb_time_encode_duration(7200));
2478 eitn_set_running(eit_n, 4);
2479 eitn_set_ca(eit_n);
2480 eitn_set_desclength(eit_n, 0);
2481 {
2482 // Add descriptors to transport_stream_n
2483 desc_counter = 0;
2484 desc_loop = eitn_get_descs(eit_n);
2485 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2486
2487 desc = descs_get_desc(desc_loop, desc_counter++);
2488 build_desc54(desc);
2489
2490 desc = descs_get_desc(desc_loop, desc_counter++);
2491 build_desc4d(desc);
2492
2493 desc = descs_get_desc(desc_loop, desc_counter++);
2494 build_desc4e(desc);
2495
2496 desc = descs_get_desc(desc_loop, desc_counter++);
2497 build_desc55(desc);
2498
2499 desc = descs_get_desc(desc_loop, desc_counter++);
2500 build_desc69(desc);
2501
2502 // Finish descriptor generation
2503 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2504 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2505 }
2506
2507 // Set transport_stream_loop length
2508 eit_n = eit_get_event(eit, eit_n_counter); // Get last service
2509 eit_set_length(eit, eit_n - eit_get_event(eit, 0));
2510 }
2511 psi_set_crc(eit);
2512 output_psi_section(eit, EIT_PID, &cc);
2513
2514 free(eit);
2515 }
2516
2517 /* DVB Time and Date Table (TDT) */
generate_tdt(void)2518 static void generate_tdt(void) {
2519 uint8_t *tdt = psi_allocate();
2520
2521 tdt_init(tdt);
2522 tdt_set_utc(tdt, dvb_time_encode_UTC(ts_0));
2523 if (dvb_time_decode_UTC(tdt_get_utc(tdt)) != ts_0)
2524 fprintf(stderr, "check tdt_get_set_utc!!!\n");
2525 output_psi_section(tdt, TDT_PID, &cc);
2526
2527 tdt_set_utc(tdt, dvb_time_encode_UTC(ts_1));
2528 if (dvb_time_decode_UTC(tdt_get_utc(tdt)) != ts_1)
2529 fprintf(stderr, "check tdt_get_set_utc!!!\n");
2530 output_psi_section(tdt, TDT_PID, &cc);
2531
2532 tdt_set_utc(tdt, dvb_time_encode_UTC(ts_2));
2533 if (dvb_time_decode_UTC(tdt_get_utc(tdt)) != ts_2)
2534 fprintf(stderr, "check tdt_get_set_utc!!!\n");
2535 output_psi_section(tdt, TDT_PID, &cc);
2536
2537 tdt_set_utc(tdt, dvb_time_encode_UTC(ts_3));
2538 if (dvb_time_decode_UTC(tdt_get_utc(tdt)) != ts_3)
2539 fprintf(stderr, "check tdt_get_set_utc!!!\n");
2540 output_psi_section(tdt, TDT_PID, &cc);
2541
2542 free(tdt);
2543 }
2544
2545 /* DVB Time Offset Table (TOT) */
generate_tot(void)2546 static void generate_tot(void) {
2547 uint8_t *tot = psi_allocate();
2548 uint8_t *desc_loop, *desc;
2549 uint8_t desc_counter;
2550
2551 tot_init(tot);
2552 tot_set_length(tot, 0);
2553 tot_set_desclength(tot, 0);
2554
2555 tot_set_utc(tot, dvb_time_encode_UTC(ts_0));
2556 if (dvb_time_decode_UTC(tot_get_utc(tot)) != ts_0)
2557 fprintf(stderr, "check tot_get_set_utc!!!\n");
2558 psi_set_crc(tot);
2559 output_psi_section(tot, TOT_PID, &cc);
2560
2561 tot_set_utc(tot, dvb_time_encode_UTC(ts_1));
2562 if (dvb_time_decode_UTC(tot_get_utc(tot)) != ts_1)
2563 fprintf(stderr, "check tot_get_set_utc!!!\n");
2564 psi_set_crc(tot);
2565 output_psi_section(tot, TOT_PID, &cc);
2566
2567 /* Change time */
2568 tot_set_utc(tot, dvb_time_encode_UTC(ts_2));
2569
2570 /* Add some descriptors */
2571 desc_loop = tot_get_descs(tot); // First descriptor
2572 tot_set_desclength(tot, DESCS_MAX_SIZE);
2573 desc_counter = 0;
2574
2575 desc = descs_get_desc(desc_loop, desc_counter++);
2576 build_desc58(desc);
2577
2578 // Finish descriptor generation
2579 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2580 tot_set_desclength(tot, desc - desc_loop - DESCS_HEADER_SIZE);
2581 tot_set_length(tot, tot_get_desclength(tot) + DESCS_HEADER_SIZE);
2582 psi_set_crc(tot);
2583
2584 output_psi_section(tot, TOT_PID, &cc);
2585
2586 free(tot);
2587 }
2588
2589 /* DVB Running Status Table (RST) */
generate_rst(void)2590 static void generate_rst(void) {
2591 uint8_t *rst = psi_allocate();
2592 uint8_t *rst_n;
2593 uint8_t j = 0;
2594
2595 // Generate empty rst
2596 rst_init(rst);
2597 rst_set_length(rst, 0);
2598 output_psi_section(rst, RST_PID, &cc);
2599
2600 // Add couple of statuses to rst
2601 rst_set_length(rst, PSI_MAX_SIZE);
2602
2603 rst_n = rst_get_status(rst, j++);
2604 rstn_init(rst_n);
2605 rstn_set_tsid(rst_n, tsid);
2606 rstn_set_onid(rst_n, onid);
2607 rstn_set_service_id(rst_n, sid);
2608 rstn_set_event_id(rst_n, event_id);
2609 rstn_set_running(rst_n, 1);
2610
2611 rst_n = rst_get_status(rst, j++);
2612 rstn_init(rst_n);
2613 rstn_set_tsid(rst_n, tsid + 100);
2614 rstn_set_onid(rst_n, onid + 100);
2615 rstn_set_service_id(rst_n, sid + 100);
2616 rstn_set_event_id(rst_n, event_id + 100);
2617 rstn_set_running(rst_n, 2);
2618
2619 rst_n = rst_get_status(rst, j++);
2620 rstn_init(rst_n);
2621 rstn_set_tsid(rst_n, tsid + 200);
2622 rstn_set_onid(rst_n, onid + 200);
2623 rstn_set_service_id(rst_n, sid + 200);
2624 rstn_set_event_id(rst_n, event_id + 200);
2625 rstn_set_running(rst_n, 3);
2626
2627 // Set correct rst length
2628 rst_n = rst_get_status(rst, j); // Get offset of the end of last status
2629 rst_set_length(rst, rst_n - rst - RST_HEADER_SIZE);
2630
2631 output_psi_section(rst, RST_PID, &cc);
2632
2633 free(rst);
2634 }
2635
2636 /* MPEG Program Map Table (PMT) */
generate_pmt(void)2637 static void generate_pmt(void) {
2638 uint8_t *pmt = psi_allocate();
2639 uint8_t *pmt_n;
2640 uint8_t pmt_n_counter;
2641 uint8_t *desc_loop, *desc;
2642 uint8_t desc_counter;
2643
2644 // Generate empty PMT
2645 pmt_init(pmt);
2646 psi_set_version(pmt, 0);
2647 psi_set_current(pmt);
2648
2649 pmt_set_length(pmt, 0);
2650 pmt_set_program(pmt, sid);
2651 pmt_set_pcrpid(pmt, pmt_pid + 10);
2652 pmt_set_desclength(pmt, 0);
2653
2654 psi_set_crc(pmt);
2655 output_psi_section(pmt, pmt_pid, &cc);
2656
2657 // Add elementary streams
2658 pmt_init(pmt);
2659 psi_set_version(pmt, 1);
2660 psi_set_current(pmt);
2661 pmt_set_pcrpid(pmt, pmt_pid + 10);
2662
2663 {
2664 // Add descriptors to program descriptors
2665 pmt_set_length(pmt, PSI_MAX_SIZE);
2666 pmt_set_desclength(pmt, DESCS_MAX_SIZE);
2667
2668 desc_counter = 0;
2669 desc_loop = pmt_get_descs(pmt);
2670
2671 desc = descs_get_desc(desc_loop, desc_counter++);
2672 build_desc0b(desc);
2673
2674 desc = descs_get_desc(desc_loop, desc_counter++);
2675 build_desc0c(desc);
2676
2677 desc = descs_get_desc(desc_loop, desc_counter++);
2678 build_desc0d(desc);
2679
2680 desc = descs_get_desc(desc_loop, desc_counter++);
2681 build_desc0e(desc);
2682
2683 desc = descs_get_desc(desc_loop, desc_counter++);
2684 build_desc0f(desc);
2685
2686 desc = descs_get_desc(desc_loop, desc_counter++);
2687 build_desc10(desc);
2688
2689 desc = descs_get_desc(desc_loop, desc_counter++);
2690 build_desc12(desc);
2691
2692 // Finish descriptor generation
2693 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2694 pmt_set_desclength(pmt, desc - desc_loop - DESCS_HEADER_SIZE);
2695 pmt_set_length(pmt, pmt_get_desclength(pmt));
2696 }
2697
2698 {
2699 pmt_set_length(pmt, PSI_MAX_SIZE); // This needed so pmt_get_es works
2700
2701 // Process elementary streams
2702 pmt_n_counter = 0;
2703
2704 pmt_n = pmt_get_es(pmt, pmt_n_counter++);
2705 pmtn_init(pmt_n);
2706 pmtn_set_streamtype(pmt_n, 0x02); // MPEG2 Video
2707 pmtn_set_pid(pmt_n, pmt_pid + 20);
2708 pmtn_set_desclength(pmt_n, 0);
2709 {
2710 // Add descriptors to transport_stream_n
2711 desc_counter = 0;
2712 desc_loop = pmtn_get_descs(pmt_n);
2713 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2714
2715 desc = descs_get_desc(desc_loop, desc_counter++);
2716 build_desc02_1(desc);
2717
2718 desc = descs_get_desc(desc_loop, desc_counter++);
2719 build_desc02_2(desc);
2720
2721 desc = descs_get_desc(desc_loop, desc_counter++);
2722 build_desc04(desc);
2723
2724 desc = descs_get_desc(desc_loop, desc_counter++);
2725 build_desc05(desc);
2726
2727 desc = descs_get_desc(desc_loop, desc_counter++);
2728 build_desc06(desc);
2729
2730 desc = descs_get_desc(desc_loop, desc_counter++);
2731 build_desc07(desc);
2732
2733 desc = descs_get_desc(desc_loop, desc_counter++);
2734 build_desc08(desc);
2735
2736 desc = descs_get_desc(desc_loop, desc_counter++);
2737 build_desc11(desc);
2738
2739 desc = descs_get_desc(desc_loop, desc_counter++);
2740 build_desc1b(desc);
2741
2742 // Finish descriptor generation
2743 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2744 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2745 }
2746
2747 pmt_n = pmt_get_es(pmt, pmt_n_counter++);
2748 pmtn_init(pmt_n);
2749 pmtn_set_streamtype(pmt_n, 0x04); // MPEG2 audio
2750 pmtn_set_pid(pmt_n, pmt_pid + 21);
2751 pmtn_set_desclength(pmt_n, 0);
2752 {
2753 // Add descriptors to transport_stream_n
2754 desc_counter = 0;
2755 desc_loop = pmtn_get_descs(pmt_n);
2756 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2757
2758 desc = descs_get_desc(desc_loop, desc_counter++);
2759 build_desc03(desc);
2760
2761 desc = descs_get_desc(desc_loop, desc_counter++);
2762 build_desc0a(desc);
2763
2764 desc = descs_get_desc(desc_loop, desc_counter++);
2765 build_desc52(desc);
2766
2767 desc = descs_get_desc(desc_loop, desc_counter++);
2768 build_desc1c(desc);
2769
2770 desc = descs_get_desc(desc_loop, desc_counter++);
2771 build_desc50(desc);
2772
2773 desc = descs_get_desc(desc_loop, desc_counter++);
2774 build_desc5e(desc);
2775
2776 desc = descs_get_desc(desc_loop, desc_counter++);
2777 build_desc6a(desc);
2778
2779 desc = descs_get_desc(desc_loop, desc_counter++);
2780 build_desc7a(desc);
2781
2782 desc = descs_get_desc(desc_loop, desc_counter++);
2783 build_desc7b(desc);
2784
2785 // Finish descriptor generation
2786 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2787 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2788 }
2789
2790 pmt_n = pmt_get_es(pmt, pmt_n_counter++);
2791 pmtn_init(pmt_n);
2792 pmtn_set_streamtype(pmt_n, 0x06); // PES Private Data (desc46 - VBI teletext)
2793 pmtn_set_pid(pmt_n, pmt_pid + 22);
2794 pmtn_set_desclength(pmt_n, 0);
2795 {
2796 // Add descriptors to transport_stream_n
2797 desc_counter = 0;
2798 desc_loop = pmtn_get_descs(pmt_n);
2799 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2800
2801 desc = descs_get_desc(desc_loop, desc_counter++);
2802 build_desc46(desc);
2803
2804 desc = descs_get_desc(desc_loop, desc_counter++);
2805 build_desc45(desc);
2806
2807 // Finish descriptor generation
2808 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2809 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2810 }
2811
2812 pmt_n = pmt_get_es(pmt, pmt_n_counter++);
2813 pmtn_init(pmt_n);
2814 pmtn_set_streamtype(pmt_n, 0x06); // PES Private Data (desc56 - Teletext)
2815 pmtn_set_pid(pmt_n, pmt_pid + 23);
2816 pmtn_set_desclength(pmt_n, 0);
2817 {
2818 // Add descriptors to transport_stream_n
2819 desc_counter = 0;
2820 desc_loop = pmtn_get_descs(pmt_n);
2821 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2822
2823 desc = descs_get_desc(desc_loop, desc_counter++);
2824 build_desc56(desc);
2825
2826 desc = descs_get_desc(desc_loop, desc_counter++);
2827 build_desc60(desc);
2828
2829 desc = descs_get_desc(desc_loop, desc_counter++);
2830 build_desc65(desc);
2831
2832 // Finish descriptor generation
2833 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2834 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2835 }
2836
2837 pmt_n = pmt_get_es(pmt, pmt_n_counter++);
2838 pmtn_init(pmt_n);
2839 pmtn_set_streamtype(pmt_n, 0x06); // PES Private Data (desc59 - Subtitles)
2840 pmtn_set_pid(pmt_n, pmt_pid + 24);
2841 pmtn_set_desclength(pmt_n, 0);
2842 {
2843 // Add descriptors to transport_stream_n
2844 desc_counter = 0;
2845 desc_loop = pmtn_get_descs(pmt_n);
2846 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2847
2848 desc = descs_get_desc(desc_loop, desc_counter++);
2849 build_desc59(desc);
2850
2851 // Finish descriptor generation
2852 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2853 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2854 }
2855
2856 pmt_n = pmt_get_es(pmt, pmt_n_counter++);
2857 pmtn_init(pmt_n);
2858 pmtn_set_streamtype(pmt_n, 0x06);
2859 pmtn_set_pid(pmt_n, pmt_pid + 25);
2860 pmtn_set_desclength(pmt_n, 0);
2861 {
2862 // Add descriptors to transport_stream_n
2863 desc_counter = 0;
2864 desc_loop = pmtn_get_descs(pmt_n);
2865 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2866
2867 desc = descs_get_desc(desc_loop, desc_counter++);
2868 build_desc1e(desc);
2869
2870 desc = descs_get_desc(desc_loop, desc_counter++);
2871 build_desc1d(desc);
2872
2873 desc = descs_get_desc(desc_loop, desc_counter++);
2874 build_desc1f(desc);
2875
2876 desc = descs_get_desc(desc_loop, desc_counter++);
2877 build_desc20(desc);
2878
2879 desc = descs_get_desc(desc_loop, desc_counter++);
2880 build_desc21(desc);
2881
2882 desc = descs_get_desc(desc_loop, desc_counter++);
2883 build_desc22(desc);
2884
2885 desc = descs_get_desc(desc_loop, desc_counter++);
2886 build_desc23(desc);
2887
2888 desc = descs_get_desc(desc_loop, desc_counter++);
2889 build_desc27(desc);
2890
2891 desc = descs_get_desc(desc_loop, desc_counter++);
2892 build_desc2c(desc);
2893
2894 // Finish descriptor generation
2895 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2896 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2897 }
2898
2899 pmt_n = pmt_get_es(pmt, pmt_n_counter++);
2900 pmtn_init(pmt_n);
2901 pmtn_set_streamtype(pmt_n, 0x1b);
2902 pmtn_set_pid(pmt_n, pmt_pid + 26);
2903 pmtn_set_desclength(pmt_n, 0);
2904 {
2905 // Add descriptors to transport_stream_n
2906 desc_counter = 0;
2907 desc_loop = pmtn_get_descs(pmt_n);
2908 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2909
2910 desc = descs_get_desc(desc_loop, desc_counter++);
2911 build_desc24_1(desc);
2912
2913 desc = descs_get_desc(desc_loop, desc_counter++);
2914 build_desc24_2(desc);
2915
2916 desc = descs_get_desc(desc_loop, desc_counter++);
2917 build_desc24_3(desc);
2918
2919 desc = descs_get_desc(desc_loop, desc_counter++);
2920 build_desc25(desc);
2921
2922 desc = descs_get_desc(desc_loop, desc_counter++);
2923 build_desc26_1(desc);
2924
2925 desc = descs_get_desc(desc_loop, desc_counter++);
2926 build_desc26_2(desc);
2927
2928 desc = descs_get_desc(desc_loop, desc_counter++);
2929 build_desc28(desc);
2930
2931 desc = descs_get_desc(desc_loop, desc_counter++);
2932 build_desc2a(desc);
2933
2934 desc = descs_get_desc(desc_loop, desc_counter++);
2935 build_desc6b(desc);
2936
2937 // Finish descriptor generation
2938 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2939 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2940 }
2941
2942 pmt_n = pmt_get_es(pmt, pmt_n_counter++);
2943 pmtn_init(pmt_n);
2944 pmtn_set_streamtype(pmt_n, 0x0f); // AAC
2945 pmtn_set_pid(pmt_n, pmt_pid + 27);
2946 pmtn_set_desclength(pmt_n, 0);
2947 {
2948 // Add descriptors to transport_stream_n
2949 desc_counter = 0;
2950 desc_loop = pmtn_get_descs(pmt_n);
2951 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
2952
2953 /* DVB Descriptor 0x42: Stuffing descriptor */
2954 desc = descs_get_desc(desc_loop, desc_counter++);
2955 build_desc0f(desc);
2956 desc42_init(desc); /* Every descriptor can be stuffed */
2957
2958 desc = descs_get_desc(desc_loop, desc_counter++);
2959 build_desc2b(desc);
2960
2961 desc = descs_get_desc(desc_loop, desc_counter++);
2962 build_desc7c(desc);
2963
2964 // Finish descriptor generation
2965 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
2966 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
2967 }
2968
2969 pmt_n = pmt_get_es(pmt, pmt_n_counter++);
2970 pmtn_init(pmt_n);
2971 pmtn_set_streamtype(pmt_n, PMT_STREAMTYPE_SCTE_35);
2972 pmtn_set_pid(pmt_n, scte35_pid);
2973 pmtn_set_desclength(pmt_n, 0);
2974
2975 // Set transport_stream_loop length
2976 pmt_n = pmt_get_es(pmt, pmt_n_counter); // Get last service
2977 pmt_set_length(pmt, pmt_n - pmt_get_es(pmt, 0) + pmt_get_desclength(pmt));
2978 }
2979 psi_set_crc(pmt);
2980 output_psi_section(pmt, pmt_pid, &cc);
2981
2982 free(pmt);
2983 }
2984
2985 /* DVB Discontinuity Information Table (DIT) */
generate_dit(void)2986 static void generate_dit(void) {
2987 uint8_t *dit = psi_allocate();
2988
2989 dit_init(dit);
2990
2991 dit_set_transition_flag(dit, true);
2992 output_psi_section(dit, DIT_PID, &cc);
2993
2994 dit_set_transition_flag(dit, false);
2995 output_psi_section(dit, DIT_PID, &cc);
2996
2997 free(dit);
2998 }
2999
3000 /* Selection Information Table (SIT) */
generate_sit(void)3001 static void generate_sit(void) {
3002 uint8_t *sit = psi_allocate();
3003 uint8_t *sit_n;
3004 uint8_t sit_n_counter;
3005 uint8_t *desc_loop, *desc;
3006 uint8_t desc_counter;
3007
3008 // Generate empty SIT
3009 sit_init(sit);
3010 psi_set_version(sit, 0);
3011 psi_set_current(sit);
3012 sit_set_length(sit, 0);
3013 sit_set_desclength(sit, 0);
3014 psi_set_crc(sit);
3015 output_psi_section(sit, SIT_PID, &cc);
3016
3017 // Add elementary streams
3018 sit_init(sit);
3019 psi_set_version(sit, 1);
3020 psi_set_current(sit);
3021 sit_set_length(sit, 0);
3022 sit_set_desclength(sit, 0);
3023
3024 {
3025 // Add descriptors to program descriptors
3026 sit_set_length(sit, PSI_MAX_SIZE);
3027 sit_set_desclength(sit, DESCS_MAX_SIZE);
3028
3029 desc_counter = 0;
3030 desc_loop = sit_get_descs(sit);
3031
3032 desc = descs_get_desc(desc_loop, desc_counter++);
3033 build_desc63(desc);
3034
3035 // Finish descriptor generation
3036 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
3037 sit_set_desclength(sit, desc - desc_loop - DESCS_HEADER_SIZE);
3038 sit_set_length(sit, sit_get_desclength(sit));
3039 }
3040
3041 {
3042 sit_set_length(sit, PSI_MAX_SIZE); // This needed so sit_get_es works
3043
3044 // Process elementary streams
3045 sit_n_counter = 0;
3046
3047 sit_n = sit_get_service(sit, sit_n_counter++);
3048 sitn_init(sit_n);
3049 sitn_set_sid(sit_n, sid);
3050 sitn_set_running(sit_n, 1);
3051 sitn_set_desclength(sit_n, 0);
3052 {
3053 // Add descriptors to transport_stream_n
3054 desc_counter = 0;
3055 desc_loop = sitn_get_descs(sit_n);
3056 descs_set_length(desc_loop, DESCS_MAX_SIZE); // This is needed so descs_get_desc(x, n) works
3057
3058 desc = descs_get_desc(desc_loop, desc_counter++);
3059 build_desc05(desc);
3060
3061 desc = descs_get_desc(desc_loop, desc_counter++);
3062 build_desc05(desc);
3063
3064 desc = descs_get_desc(desc_loop, desc_counter++);
3065 build_desc05(desc);
3066
3067 // Finish descriptor generation
3068 desc = descs_get_desc(desc_loop, desc_counter); // Get next descriptor pos
3069 descs_set_length(desc_loop, desc - desc_loop - DESCS_HEADER_SIZE);
3070 }
3071
3072 sit_n = sit_get_service(sit, sit_n_counter++);
3073 sitn_init(sit_n);
3074 sitn_set_sid(sit_n, sid + 1000);
3075 sitn_set_running(sit_n, 3);
3076 sitn_set_desclength(sit_n, 0);
3077
3078 // Set transport_stream_loop length
3079 sit_n = sit_get_service(sit, sit_n_counter); // Get last service
3080 sit_set_length(sit, sit_n - sit_get_service(sit, 0) + sit_get_desclength(sit));
3081 }
3082
3083 psi_set_crc(sit);
3084 output_psi_section(sit, SIT_PID, &cc);
3085
3086 free(sit);
3087 }
3088
3089 /* SCTE 35 Splice Information Table */
generate_scte35(void)3090 static void generate_scte35(void) {
3091 uint8_t *scte35 = psi_allocate();
3092
3093 // Generate empty section
3094 scte35_init(scte35);
3095 psi_set_length(scte35, PSI_MAX_SIZE);
3096 scte35_set_pts_adjustment(scte35, 0);
3097 scte35_null_init(scte35);
3098 scte35_set_desclength(scte35, 0);
3099 psi_set_length(scte35,
3100 scte35_get_descl(scte35) + PSI_CRC_SIZE - scte35 - PSI_HEADER_SIZE);
3101 psi_set_crc(scte35);
3102 output_psi_section(scte35, scte35_pid, &cc);
3103
3104 // Generate insert section
3105 scte35_init(scte35);
3106 psi_set_length(scte35, PSI_MAX_SIZE);
3107 scte35_set_pts_adjustment(scte35, 0);
3108 scte35_insert_init(scte35,
3109 SCTE35_INSERT_HEADER2_SIZE +
3110 SCTE35_SPLICE_TIME_HEADER_SIZE + SCTE35_SPLICE_TIME_TIME_SIZE +
3111 SCTE35_BREAK_DURATION_HEADER_SIZE + SCTE35_INSERT_FOOTER_SIZE);
3112 scte35_insert_set_cancel(scte35, false);
3113 scte35_insert_set_event_id(scte35, 4242);
3114 scte35_insert_set_out_of_network(scte35, true);
3115 scte35_insert_set_program_splice(scte35, true);
3116 scte35_insert_set_duration(scte35, true);
3117 scte35_insert_set_splice_immediate(scte35, false);
3118
3119 uint8_t *splice_time = scte35_insert_get_splice_time(scte35);
3120 scte35_splice_time_init(splice_time);
3121 scte35_splice_time_set_time_specified(splice_time, true);
3122 scte35_splice_time_set_pts_time(splice_time, 270000000);
3123
3124 uint8_t *duration = scte35_insert_get_break_duration(scte35);
3125 scte35_break_duration_init(duration);
3126 scte35_break_duration_set_auto_return(duration, true);
3127 scte35_break_duration_set_duration(duration, 27000000);
3128
3129 scte35_insert_set_unique_program_id(scte35, 2424);
3130 scte35_insert_set_avail_num(scte35, 0);
3131 scte35_insert_set_avails_expected(scte35, 0);
3132 scte35_set_desclength(scte35, 0);
3133 psi_set_length(scte35,
3134 scte35_get_descl(scte35) + PSI_CRC_SIZE - scte35 - PSI_HEADER_SIZE);
3135 psi_set_crc(scte35);
3136 output_psi_section(scte35, scte35_pid, &cc);
3137
3138 free(scte35);
3139 }
3140
main(void)3141 int main(void)
3142 {
3143 generate_pat();
3144 generate_cat();
3145 generate_tsdt();
3146 generate_nit();
3147 generate_bat();
3148 generate_sdt();
3149 generate_eit();
3150 generate_tdt();
3151 generate_tot();
3152 generate_rst();
3153 generate_pmt();
3154 generate_dit();
3155 generate_sit();
3156 generate_scte35();
3157
3158 return EXIT_SUCCESS;
3159 }
3160