6ab717085900dc7355edd0e2b69fdd64ca8f6ddb
[platform/upstream/gstreamer.git] / subprojects / gst-plugins-bad / gst / mpegtsmux / tsmux / tsmux.c
1 /*
2  * Copyright 2006 BBC and Fluendo S.A.
3  *
4  * This library is licensed under 3 different licenses and you
5  * can choose to use it under the terms of any one of them. The
6  * three licenses are the MPL 1.1, the LGPL, and the MIT license.
7  *
8  * MPL:
9  *
10  * The contents of this file are subject to the Mozilla Public License
11  * Version 1.1 (the "License"); you may not use this file except in
12  * compliance with the License. You may obtain a copy of the License at
13  * http://www.mozilla.org/MPL/.
14  *
15  * Software distributed under the License is distributed on an "AS IS"
16  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
17  * License for the specific language governing rights and limitations
18  * under the License.
19  *
20  * LGPL:
21  *
22  * This library is free software; you can redistribute it and/or
23  * modify it under the terms of the GNU Library General Public
24  * License as published by the Free Software Foundation; either
25  * version 2 of the License, or (at your option) any later version.
26  *
27  * This library is distributed in the hope that it will be useful,
28  * but WITHOUT ANY WARRANTY; without even the implied warranty of
29  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
30  * Library General Public License for more details.
31  *
32  * You should have received a copy of the GNU Library General Public
33  * License along with this library; if not, write to the
34  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
35  * Boston, MA 02110-1301, USA.
36  *
37  * MIT:
38  *
39  * Unless otherwise indicated, Source Code is licensed under MIT license.
40  * See further explanation attached in License Statement (distributed in the file
41  * LICENSE).
42  *
43  * Permission is hereby granted, free of charge, to any person obtaining a copy of
44  * this software and associated documentation files (the "Software"), to deal in
45  * the Software without restriction, including without limitation the rights to
46  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
47  * of the Software, and to permit persons to whom the Software is furnished to do
48  * so, subject to the following conditions:
49  *
50  * The above copyright notice and this permission notice shall be included in all
51  * copies or substantial portions of the Software.
52  *
53  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
54  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
55  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
56  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
57  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
58  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
59  * SOFTWARE.
60  *
61  * SPDX-License-Identifier: MPL-1.1 OR MIT OR LGPL-2.0-or-later
62  */
63
64 #ifdef HAVE_CONFIG_H
65 #include "config.h"
66 #endif
67
68 #include <string.h>
69
70 #include <gst/mpegts/mpegts.h>
71
72 #include "tsmux.h"
73 #include "tsmuxstream.h"
74
75 #define GST_CAT_DEFAULT gst_base_ts_mux_debug
76
77 /* Maximum total data length for a PAT section is 1024 bytes, minus an
78  * 8 byte header, then the length of each program entry is 32 bits,
79  * then finally a 32 bit CRC. Thus the maximum number of programs in this mux
80  * is (1024 - 8 - 4) / 4 = 253 because it only supports single section PATs */
81 #define TSMUX_MAX_PROGRAMS 253
82
83 #define TSMUX_SECTION_HDR_SIZE 8
84
85 #define TSMUX_DEFAULT_NETWORK_ID 0x0001
86 #define TSMUX_DEFAULT_TS_ID 0x0001
87
88 /* The last byte of the PCR in the header defines the byte position
89  * at which PCR should be calculated */
90 #define PCR_BYTE_OFFSET 11
91
92 /* HACK: We use a fixed buffering offset for the PCR at the moment -
93  * this is the amount 'in advance' of the stream that the PCR sits.
94  * 1/8 second atm */
95 #define TSMUX_PCR_OFFSET (TSMUX_CLOCK_FREQ / 8)
96
97 /* Base for all written PCR and DTS/PTS,
98  * so we have some slack to go backwards */
99 #define CLOCK_BASE (TSMUX_CLOCK_FREQ * 10 * 360)
100
101 static gboolean tsmux_write_pat (TsMux * mux);
102 static gboolean tsmux_write_pmt (TsMux * mux, TsMuxProgram * program);
103 static gboolean tsmux_write_scte_null (TsMux * mux, TsMuxProgram * program);
104 static gint64 get_next_pcr (TsMux * mux, gint64 cur_ts);
105 static gint64 get_current_pcr (TsMux * mux, gint64 cur_ts);
106 static gint64 write_new_pcr (TsMux * mux, TsMuxStream * stream, gint64 cur_pcr,
107     gint64 next_pcr);
108 static gboolean tsmux_write_ts_header (TsMux * mux, guint8 * buf,
109     TsMuxPacketInfo * pi, guint stream_avail, guint * payload_len_out,
110     guint * payload_offset_out);
111
112 static void
113 tsmux_section_free (TsMuxSection * section)
114 {
115   gst_mpegts_section_unref (section->section);
116   g_slice_free (TsMuxSection, section);
117 }
118
119 /**
120  * tsmux_new:
121  *
122  * Create a new muxer session.
123  *
124  * Returns: A new #TsMux object.
125  */
126 TsMux *
127 tsmux_new (void)
128 {
129   TsMux *mux;
130
131   mux = g_slice_new0 (TsMux);
132
133   mux->transport_id = TSMUX_DEFAULT_TS_ID;
134
135   mux->next_pgm_no = TSMUX_START_PROGRAM_ID;
136   mux->next_pmt_pid = TSMUX_START_PMT_PID;
137   mux->next_stream_pid = TSMUX_START_ES_PID;
138
139   mux->pat_changed = TRUE;
140   mux->next_pat_pcr = -1;
141   mux->pat_interval = TSMUX_DEFAULT_PAT_INTERVAL;
142
143   mux->si_changed = TRUE;
144   mux->si_interval = TSMUX_DEFAULT_SI_INTERVAL;
145
146   mux->pcr_interval = TSMUX_DEFAULT_PCR_INTERVAL;
147
148   mux->next_si_pcr = -1;
149
150   mux->si_sections = g_hash_table_new_full (g_direct_hash, g_direct_equal,
151       NULL, (GDestroyNotify) tsmux_section_free);
152
153   mux->new_stream_func = (TsMuxNewStreamFunc) tsmux_stream_new;
154   mux->new_stream_data = NULL;
155
156   mux->first_pcr_ts = G_MININT64;
157
158   return mux;
159 }
160
161 /**
162  * tsmux_set_write_func:
163  * @mux: a #TsMux
164  * @func: a user callback function
165  * @user_data: user data passed to @func
166  *
167  * Set the callback function and user data to be called when @mux has output to
168  * produce. @user_data will be passed as user data in @func.
169  */
170 void
171 tsmux_set_write_func (TsMux * mux, TsMuxWriteFunc func, void *user_data)
172 {
173   g_return_if_fail (mux != NULL);
174
175   mux->write_func = func;
176   mux->write_func_data = user_data;
177 }
178
179 /**
180  * tsmux_set_alloc_func:
181  * @mux: a #TsMux
182  * @func: a user callback function
183  * @user_data: user data passed to @func
184  *
185  * Set the callback function and user data to be called when @mux needs
186  * a new buffer to write a packet into.
187  * @user_data will be passed as user data in @func.
188  */
189 void
190 tsmux_set_alloc_func (TsMux * mux, TsMuxAllocFunc func, void *user_data)
191 {
192   g_return_if_fail (mux != NULL);
193
194   mux->alloc_func = func;
195   mux->alloc_func_data = user_data;
196 }
197
198 /**
199  * tsmux_set_new_stream_func:
200  * @mux: a #TsMux
201  * @func: a user callback function
202  * @user_data: user data passed to @func
203  *
204  * Set the callback function and user data to be called when @mux needs
205  * to create a new stream.
206  * @user_data will be passed as user data in @func.
207  */
208 void
209 tsmux_set_new_stream_func (TsMux * mux, TsMuxNewStreamFunc func,
210     void *user_data)
211 {
212   g_return_if_fail (mux != NULL);
213
214   mux->new_stream_func = func;
215   mux->new_stream_data = user_data;
216 }
217
218 /**
219  * tsmux_set_pat_interval:
220  * @mux: a #TsMux
221  * @freq: a new PAT interval
222  *
223  * Set the interval (in cycles of the 90kHz clock) for writing out the PAT table.
224  *
225  * Many transport stream clients might have problems if the PAT table is not
226  * inserted in the stream at regular intervals, especially when initially trying
227  * to figure out the contents of the stream.
228  */
229 void
230 tsmux_set_pat_interval (TsMux * mux, guint freq)
231 {
232   g_return_if_fail (mux != NULL);
233
234   mux->pat_interval = freq;
235 }
236
237 /**
238  * tsmux_set_pcr_interval:
239  * @mux: a #TsMux
240  * @freq: a new PCR interval
241  *
242  * Set the interval (in cycles of the 90kHz clock) for writing the PCR.
243  */
244 void
245 tsmux_set_pcr_interval (TsMux * mux, guint freq)
246 {
247   g_return_if_fail (mux != NULL);
248
249   mux->pcr_interval = freq;
250 }
251
252 /**
253  * tsmux_get_pat_interval:
254  * @mux: a #TsMux
255  *
256  * Get the configured PAT interval. See also tsmux_set_pat_interval().
257  *
258  * Returns: the configured PAT interval
259  */
260 guint
261 tsmux_get_pat_interval (TsMux * mux)
262 {
263   g_return_val_if_fail (mux != NULL, 0);
264
265   return mux->pat_interval;
266 }
267
268 /**
269  * tsmux_resend_pat:
270  * @mux: a #TsMux
271  *
272  * Resends the PAT before the next stream packet.
273  */
274 void
275 tsmux_resend_pat (TsMux * mux)
276 {
277   g_return_if_fail (mux != NULL);
278
279   mux->next_pat_pcr = -1;
280 }
281
282 /**
283  * tsmux_set_si_interval:
284  * @mux: a #TsMux
285  * @freq: a new SI table interval
286  *
287  * Set the interval (in cycles of the 90kHz clock) for writing out the SI tables.
288  *
289  */
290 void
291 tsmux_set_si_interval (TsMux * mux, guint freq)
292 {
293   g_return_if_fail (mux != NULL);
294
295   mux->si_interval = freq;
296 }
297
298 /**
299  * tsmux_get_si_interval:
300  * @mux: a #TsMux
301  *
302  * Get the configured SI table interval. See also tsmux_set_si_interval().
303  *
304  * Returns: the configured SI interval
305  */
306 guint
307 tsmux_get_si_interval (TsMux * mux)
308 {
309   g_return_val_if_fail (mux != NULL, 0);
310
311   return mux->si_interval;
312 }
313
314 /**
315  * tsmux_resend_si:
316  * @mux: a #TsMux
317  *
318  * Resends the SI tables before the next stream packet.
319  *
320  */
321 void
322 tsmux_resend_si (TsMux * mux)
323 {
324   g_return_if_fail (mux != NULL);
325
326   mux->next_si_pcr = -1;
327 }
328
329 /**
330  * tsmux_add_mpegts_si_section:
331  * @mux: a #TsMux
332  * @section: (transfer full): a #GstMpegtsSection to add
333  *
334  * Add a Service Information #GstMpegtsSection to the stream
335  *
336  * Returns: %TRUE on success, %FALSE otherwise
337  */
338 gboolean
339 tsmux_add_mpegts_si_section (TsMux * mux, GstMpegtsSection * section)
340 {
341   TsMuxSection *tsmux_section;
342
343   g_return_val_if_fail (mux != NULL, FALSE);
344   g_return_val_if_fail (section != NULL, FALSE);
345   g_return_val_if_fail (mux->si_sections != NULL, FALSE);
346
347   tsmux_section = g_slice_new0 (TsMuxSection);
348
349   GST_DEBUG ("Adding mpegts section with type %d to mux",
350       section->section_type);
351
352   tsmux_section->section = section;
353   tsmux_section->pi.pid = section->pid;
354
355   g_hash_table_insert (mux->si_sections,
356       GINT_TO_POINTER (section->section_type), tsmux_section);
357
358   mux->si_changed = TRUE;
359
360   return TRUE;
361 }
362
363
364 /**
365  * tsmux_free:
366  * @mux: a #TsMux
367  *
368  * Free all resources associated with @mux. After calling this function @mux can
369  * not be used anymore.
370  */
371 void
372 tsmux_free (TsMux * mux)
373 {
374   GList *cur;
375
376   g_return_if_fail (mux != NULL);
377
378   /* Free PAT section */
379   if (mux->pat.section)
380     gst_mpegts_section_unref (mux->pat.section);
381
382   /* Free all programs */
383   for (cur = mux->programs; cur; cur = cur->next) {
384     TsMuxProgram *program = (TsMuxProgram *) cur->data;
385
386     tsmux_program_free (program);
387   }
388   g_list_free (mux->programs);
389
390   /* Free all streams */
391   for (cur = mux->streams; cur; cur = cur->next) {
392     TsMuxStream *stream = (TsMuxStream *) cur->data;
393
394     tsmux_stream_free (stream);
395   }
396   g_list_free (mux->streams);
397
398   /* Free SI table sections */
399   g_hash_table_unref (mux->si_sections);
400
401   g_slice_free (TsMux, mux);
402 }
403
404 static gint
405 tsmux_program_compare (TsMuxProgram * program, gint * needle)
406 {
407   return (program->pgm_number - *needle);
408 }
409
410 /**
411  * tsmux_program_new:
412  * @mux: a #TsMux
413  *
414  * Create a new program in the missing session @mux.
415  *
416  * Returns: a new #TsMuxProgram or %NULL when the maximum number of programs has
417  * been reached.
418  */
419 TsMuxProgram *
420 tsmux_program_new (TsMux * mux, gint prog_id)
421 {
422   TsMuxProgram *program;
423
424   g_return_val_if_fail (mux != NULL, NULL);
425
426   /* Ensure we have room for another program */
427   if (mux->nb_programs == TSMUX_MAX_PROGRAMS)
428     return NULL;
429
430   program = g_slice_new0 (TsMuxProgram);
431
432   program->pmt_changed = TRUE;
433   program->pmt_interval = TSMUX_DEFAULT_PMT_INTERVAL;
434
435   program->next_pmt_pcr = -1;
436
437   if (prog_id == 0) {
438     program->pgm_number = mux->next_pgm_no++;
439     while (g_list_find_custom (mux->programs, &program->pgm_number,
440             (GCompareFunc) tsmux_program_compare) != NULL) {
441       program->pgm_number = mux->next_pgm_no++;
442     }
443   } else {
444     program->pgm_number = prog_id;
445     while (g_list_find_custom (mux->programs, &program->pgm_number,
446             (GCompareFunc) tsmux_program_compare) != NULL) {
447       program->pgm_number++;
448     }
449   }
450
451   program->pmt_pid = mux->next_pmt_pid++;
452   program->pcr_stream = NULL;
453
454   /* SCTE35 is disabled by default */
455   program->scte35_pid = 0;
456   program->scte35_null_interval = TSMUX_DEFAULT_SCTE_35_NULL_INTERVAL;
457   program->next_scte35_pcr = -1;
458
459   /* mux->streams owns the streams */
460   program->streams = g_ptr_array_new_full (1, NULL);
461
462   mux->programs = g_list_prepend (mux->programs, program);
463   mux->nb_programs++;
464   mux->pat_changed = TRUE;
465
466   return program;
467 }
468
469 gboolean
470 tsmux_program_delete (TsMux * mux, TsMuxProgram * program)
471 {
472   g_return_val_if_fail (mux != NULL, FALSE);
473
474   if (mux->nb_programs == 0)
475     return FALSE;
476
477   if (!program)
478     return FALSE;
479
480   mux->programs = g_list_remove (mux->programs, program);
481   mux->nb_programs--;
482   mux->pat_changed = TRUE;
483   tsmux_program_free ((TsMuxProgram *) program);
484
485   return TRUE;
486 }
487
488 /**
489  * tsmux_set_pmt_interval:
490  * @program: a #TsMuxProgram
491  * @freq: a new PMT interval
492  *
493  * Set the interval (in cycles of the 90kHz clock) for writing out the PMT table.
494  *
495  * Many transport stream clients might have problems if the PMT table is not
496  * inserted in the stream at regular intervals, especially when initially trying
497  * to figure out the contents of the stream.
498  */
499 void
500 tsmux_set_pmt_interval (TsMuxProgram * program, guint freq)
501 {
502   g_return_if_fail (program != NULL);
503
504   program->pmt_interval = freq;
505 }
506
507 /**
508  * tsmux_get_pmt_interval:
509  * @program: a #TsMuxProgram
510  *
511  * Get the configured PMT interval. See also tsmux_set_pmt_interval().
512  *
513  * Returns: the configured PMT interval
514  */
515 guint
516 tsmux_get_pmt_interval (TsMuxProgram * program)
517 {
518   g_return_val_if_fail (program != NULL, 0);
519
520   return program->pmt_interval;
521 }
522
523 /**
524  * tsmux_program_set_scte35_interval:
525  * @program: a #TsMuxProgram
526  * @freq: a new SCTE-35 NULL interval
527  *
528  * Set the interval (in cycles of the 90kHz clock) for sending out the SCTE-35
529  * NULL command. This is only effective is the SCTE-35 PID is not 0.
530  */
531 void
532 tsmux_program_set_scte35_interval (TsMuxProgram * program, guint interval)
533 {
534   g_return_if_fail (program != NULL);
535
536   program->scte35_null_interval = interval;
537 }
538
539 /**
540  * tsmux_resend_pmt:
541  * @program: a #TsMuxProgram
542  *
543  * Resends the PMT before the next stream packet.
544  */
545 void
546 tsmux_resend_pmt (TsMuxProgram * program)
547 {
548   g_return_if_fail (program != NULL);
549
550   program->next_pmt_pcr = -1;
551 }
552
553 /**
554  * tsmux_program_set_scte35_pid:
555  * @program: a #TsMuxProgram
556  * @pid: The pid to use, or 0 to deactivate usage.
557  *
558  * Set the @pid to use for sending SCTE-35 packets on the given
559  * @program.
560  *
561  * This needs to be called as early as possible if SCTE-35 sections
562  * are even going to be used with the given @program so that the PMT
563  * can be properly configured.
564  */
565 void
566 tsmux_program_set_scte35_pid (TsMuxProgram * program, guint16 pid)
567 {
568   TsMuxSection *section;
569   GstMpegtsSCTESIT *sit;
570   g_return_if_fail (program != NULL);
571
572   program->scte35_pid = pid;
573   /* Create/Update the section */
574   if (program->scte35_null_section) {
575     tsmux_section_free (program->scte35_null_section);
576     program->scte35_null_section = NULL;
577   }
578   if (pid != 0) {
579     program->scte35_null_section = section = g_slice_new0 (TsMuxSection);
580     section->pi.pid = pid;
581     sit = gst_mpegts_scte_null_new ();
582     section->section = gst_mpegts_section_from_scte_sit (sit, pid);
583   }
584 }
585
586 /**
587  * tsmux_program_get_scte35_pid:
588  * @program: a #TsMuxProgram
589  *
590  * Get the PID configured for sending SCTE-35 packets.
591  *
592  * Returns: the configured SCTE-35 PID, or 0 if not active.
593  */
594 guint16
595 tsmux_program_get_scte35_pid (TsMuxProgram * program)
596 {
597   g_return_val_if_fail (program != NULL, 0);
598
599   return program->scte35_pid;
600 }
601
602 /**
603  * tsmux_program_add_stream:
604  * @program: a #TsMuxProgram
605  * @stream: a #TsMuxStream
606  *
607  * Add @stream to @program.
608  */
609 void
610 tsmux_program_add_stream (TsMuxProgram * program, TsMuxStream * stream)
611 {
612   GPtrArray *streams;
613   guint i;
614   gint pmt_index, array_index = -1 /* append */ ;
615   guint16 pid;
616
617   g_return_if_fail (program != NULL);
618   g_return_if_fail (stream != NULL);
619
620   streams = program->streams;
621   pmt_index = stream->pmt_index;
622   pid = tsmux_stream_get_pid (stream);
623
624   if (pmt_index >= 0) {
625     /* Insert into streams with known indices */
626     for (i = 0; i < streams->len; i++) {
627       TsMuxStream *s = g_ptr_array_index (streams, i);
628
629       if (s->pmt_index < 0 || pmt_index < s->pmt_index) {
630         array_index = i;
631         GST_DEBUG ("PID 0x%04x: Using known-order index %d/%u",
632             pid, array_index, streams->len);
633         break;
634       }
635     }
636   } else {
637     /* Insert after streams with known indices, sorted by PID */
638     for (i = 0; i < streams->len; i++) {
639       TsMuxStream *s = g_ptr_array_index (streams, i);
640
641       if (s->pmt_index < 0 && pid < tsmux_stream_get_pid (s)) {
642         array_index = i;
643         GST_DEBUG ("PID 0x%04x: Using PID-order index %d/%u",
644             pid, array_index, streams->len);
645         break;
646       }
647     }
648   }
649
650   g_ptr_array_insert (streams, array_index, stream);
651   program->pmt_changed = TRUE;
652 }
653
654 /**
655  * tsmux_program_set_pcr_stream:
656  * @program: a #TsMuxProgram
657  * @stream: a #TsMuxStream
658  *
659  * Set @stream as the PCR stream for @program, overwriting the previously
660  * configured PCR stream. When @stream is NULL, program will have no PCR stream
661  * configured.
662  */
663 void
664 tsmux_program_set_pcr_stream (TsMuxProgram * program, TsMuxStream * stream)
665 {
666   g_return_if_fail (program != NULL);
667
668   if (program->pcr_stream == stream)
669     return;
670
671   if (program->pcr_stream != NULL)
672     tsmux_stream_pcr_unref (program->pcr_stream);
673   if (stream)
674     tsmux_stream_pcr_ref (stream);
675   program->pcr_stream = stream;
676
677   program->pmt_changed = TRUE;
678 }
679
680 /**
681  * tsmux_get_new_pid:
682  * @mux: a #TsMux
683  *
684  * Get a new free PID.
685  *
686  * Returns: a new free PID.
687  */
688 guint16
689 tsmux_get_new_pid (TsMux * mux)
690 {
691   g_return_val_if_fail (mux != NULL, -1);
692
693   /* make sure this PID is free
694    * (and not taken by a specific earlier request) */
695   do {
696     mux->next_stream_pid++;
697   } while (tsmux_find_stream (mux, mux->next_stream_pid));
698
699   return mux->next_stream_pid;
700 }
701
702 /**
703  * tsmux_create_stream:
704  * @mux: a #TsMux
705  * @stream_type: the stream type
706  * @pid: the PID of the new stream.
707  *
708  * Create a new stream of @stream_type in the muxer session @mux.
709  *
710  * When @pid is set to #TSMUX_PID_AUTO, a new free PID will automatically
711  * be allocated for the new stream.
712  *
713  * Returns: a new #TsMuxStream.
714  */
715 TsMuxStream *
716 tsmux_create_stream (TsMux * mux, guint stream_type, guint16 pid,
717     gchar * language)
718 {
719   TsMuxStream *stream;
720   guint16 new_pid;
721
722   g_return_val_if_fail (mux != NULL, NULL);
723   g_return_val_if_fail (mux->new_stream_func != NULL, NULL);
724
725   if (pid == TSMUX_PID_AUTO) {
726     new_pid = tsmux_get_new_pid (mux);
727   } else {
728     new_pid = pid & 0x1FFF;
729   }
730
731   /* Ensure we're not creating a PID collision */
732   if (tsmux_find_stream (mux, new_pid))
733     return NULL;
734
735   stream = mux->new_stream_func (new_pid, stream_type, mux->new_stream_data);
736
737   mux->streams = g_list_prepend (mux->streams, stream);
738   mux->nb_streams++;
739
740   if (language) {
741     strncpy (stream->language, language, 4);
742     stream->language[3] = 0;
743   } else {
744     stream->language[0] = 0;
745   }
746
747   return stream;
748 }
749
750 /**
751  * tsmux_find_stream:
752  * @mux: a #TsMux
753  * @pid: the PID to find.
754  *
755  * Find the stream associated with PID.
756  *
757  * Returns: a #TsMuxStream with @pid or NULL when the stream was not found.
758  */
759 TsMuxStream *
760 tsmux_find_stream (TsMux * mux, guint16 pid)
761 {
762   TsMuxStream *found = NULL;
763   GList *cur;
764
765   g_return_val_if_fail (mux != NULL, NULL);
766
767   for (cur = mux->streams; cur; cur = cur->next) {
768     TsMuxStream *stream = (TsMuxStream *) cur->data;
769
770     if (tsmux_stream_get_pid (stream) == pid) {
771       found = stream;
772       break;
773     }
774   }
775   return found;
776 }
777
778 static gboolean
779 tsmux_program_remove_stream (TsMuxProgram * program, TsMuxStream * stream)
780 {
781   GPtrArray *streams = program->streams;
782
783   if (!g_ptr_array_remove (streams, stream)) {
784     g_warn_if_reached ();
785     return FALSE;
786   }
787
788   return streams->len == 0;
789 }
790
791
792 gboolean
793 tsmux_remove_stream (TsMux * mux, guint16 pid, TsMuxProgram * program)
794 {
795   GList *cur;
796   gboolean ret = FALSE;
797
798   g_return_val_if_fail (mux != NULL, FALSE);
799
800   for (cur = mux->streams; cur; cur = cur->next) {
801     TsMuxStream *stream = (TsMuxStream *) cur->data;
802
803     if (tsmux_stream_get_pid (stream) == pid) {
804       ret = tsmux_program_remove_stream (program, stream);
805       mux->streams = g_list_remove (mux->streams, stream);
806       tsmux_stream_free (stream);
807       break;
808     }
809   }
810
811   if (ret)
812     tsmux_program_delete (mux, program);
813
814   return ret;
815 }
816
817 static gboolean
818 tsmux_get_buffer (TsMux * mux, GstBuffer ** buf)
819 {
820   g_return_val_if_fail (buf, FALSE);
821
822   if (G_UNLIKELY (!mux->alloc_func))
823     return FALSE;
824
825   mux->alloc_func (buf, mux->alloc_func_data);
826
827   if (!*buf)
828     return FALSE;
829
830   g_assert (gst_buffer_get_size (*buf) == TSMUX_PACKET_LENGTH);
831   return TRUE;
832 }
833
834 static gboolean
835 tsmux_packet_out (TsMux * mux, GstBuffer * buf, gint64 pcr)
836 {
837   g_return_val_if_fail (buf, FALSE);
838
839   if (G_UNLIKELY (mux->write_func == NULL)) {
840     gst_buffer_unref (buf);
841     return TRUE;
842   }
843
844   if (mux->bitrate) {
845     GST_BUFFER_PTS (buf) =
846         gst_util_uint64_scale (mux->n_bytes * 8, GST_SECOND, mux->bitrate);
847
848     /* Check and insert a PCR observation for each program if needed,
849      * but only for programs that have written their SI at least once,
850      * so the stream starts with PAT/PMT */
851     if (mux->first_pcr_ts != G_MININT64) {
852       GList *cur;
853
854       for (cur = mux->programs; cur; cur = cur->next) {
855         TsMuxProgram *program = (TsMuxProgram *) cur->data;
856         TsMuxStream *stream = program->pcr_stream;
857         gint64 cur_pcr, next_pcr, new_pcr;
858
859         if (!program->wrote_si)
860           continue;
861
862         cur_pcr = get_current_pcr (mux, 0);
863         next_pcr = get_next_pcr (mux, 0);
864         new_pcr = write_new_pcr (mux, stream, cur_pcr, next_pcr);
865
866         if (new_pcr != -1) {
867           GstBuffer *pcr_buf = NULL;
868           GstMapInfo map;
869
870           if (!tsmux_get_buffer (mux, &pcr_buf)) {
871             goto error;
872           }
873
874           gst_buffer_map (pcr_buf, &map, GST_MAP_WRITE);
875           tsmux_write_ts_header (mux, map.data, &stream->pi, 0, NULL, NULL);
876           gst_buffer_unmap (pcr_buf, &map);
877
878           stream->pi.flags &= TSMUX_PACKET_FLAG_PES_FULL_HEADER;
879           if (!tsmux_packet_out (mux, pcr_buf, new_pcr))
880             goto error;
881         }
882       }
883     }
884   }
885
886   mux->n_bytes += gst_buffer_get_size (buf);
887
888   return mux->write_func (buf, mux->write_func_data, pcr);
889
890 error:
891   gst_buffer_unref (buf);
892   return FALSE;
893 }
894
895 /*
896  * adaptation_field() {
897  *   adaptation_field_length                              8 uimsbf
898  *   if(adaptation_field_length >0) {
899  *     discontinuity_indicator                            1 bslbf
900  *     random_access_indicator                            1 bslbf
901  *     elementary_stream_priority_indicator               1 bslbf
902  *     PCR_flag                                           1 bslbf
903  *     OPCR_flag                                          1 bslbf
904  *     splicing_point_flag                                1 bslbf
905  *     transport_private_data_flag                        1 bslbf
906  *     adaptation_field_extension_flag                    1 bslbf
907  *     if(PCR_flag == '1') {
908  *       program_clock_reference_base                    33 uimsbf
909  *       reserved                                         6 bslbf
910  *       program_clock_reference_extension                9 uimsbf
911  *     }
912  *     if(OPCR_flag == '1') {
913  *       original_program_clock_reference_base           33 uimsbf
914  *       reserved                                         6 bslbf
915  *       original_program_clock_reference_extension       9 uimsbf
916  *     }
917  *     if (splicing_point_flag == '1') {
918  *       splice_countdown                                 8 tcimsbf
919  *     }
920  *     if(transport_private_data_flag == '1') {
921  *       transport_private_data_length                    8 uimsbf
922  *       for (i=0; i<transport_private_data_length;i++){
923  *         private_data_byte                              8 bslbf
924  *       }
925  *     }
926  *     if (adaptation_field_extension_flag == '1' ) {
927  *       adaptation_field_extension_length                8 uimsbf
928  *       ltw_flag                                         1 bslbf
929  *       piecewise_rate_flag                              1 bslbf
930  *       seamless_splice_flag                             1 bslbf
931  *       reserved                                         5 bslbf
932  *       if (ltw_flag == '1') {
933  *         ltw_valid_flag                                 1 bslbf
934  *         ltw_offset                                    15 uimsbf
935  *       }
936  *       if (piecewise_rate_flag == '1') {
937  *         reserved                                       2 bslbf
938  *         piecewise_rate                                22 uimsbf
939  *       }
940  *       if (seamless_splice_flag == '1'){
941  *         splice_type                                    4 bslbf
942  *         DTS_next_AU[32..30]                            3 bslbf
943  *         marker_bit                                     1 bslbf
944  *         DTS_next_AU[29..15]                           15 bslbf
945  *         marker_bit                                     1 bslbf
946  *         DTS_next_AU[14..0]                            15 bslbf
947  *         marker_bit                                     1 bslbf
948  *       }
949  *       for ( i=0;i<N;i++) {
950  *         reserved                                       8 bslbf
951  *       }
952  *     }
953  *     for (i=0;i<N;i++){
954  *       stuffing_byte                                    8 bslbf
955  *     }
956  *   }
957  * }
958  */
959 static gboolean
960 tsmux_write_adaptation_field (guint8 * buf,
961     TsMuxPacketInfo * pi, guint8 min_length, guint8 * written)
962 {
963   guint8 pos = 2;
964   guint8 flags = 0;
965
966   g_assert (min_length <= TSMUX_PAYLOAD_LENGTH);
967
968   /* Write out all the fields from the packet info only if the
969    * user set the flag to request the adaptation field - if the flag
970    * isn't set, we're just supposed to write stuffing bytes */
971   if (pi->flags & TSMUX_PACKET_FLAG_ADAPTATION) {
972     TS_DEBUG ("writing adaptation fields");
973     if (pi->flags & TSMUX_PACKET_FLAG_DISCONT)
974       flags |= 0x80;
975     if (pi->flags & TSMUX_PACKET_FLAG_RANDOM_ACCESS)
976       flags |= 0x40;
977     if (pi->flags & TSMUX_PACKET_FLAG_PRIORITY)
978       flags |= 0x20;
979     if (pi->flags & TSMUX_PACKET_FLAG_WRITE_PCR) {
980       guint64 pcr_base;
981       guint32 pcr_ext;
982
983       pcr_base = (pi->pcr / 300);
984       pcr_ext = (pi->pcr % 300);
985
986       flags |= 0x10;
987       TS_DEBUG ("Writing PCR %" G_GUINT64_FORMAT " + ext %u", pcr_base,
988           pcr_ext);
989       buf[pos++] = (pcr_base >> 25) & 0xff;
990       buf[pos++] = (pcr_base >> 17) & 0xff;
991       buf[pos++] = (pcr_base >> 9) & 0xff;
992       buf[pos++] = (pcr_base >> 1) & 0xff;
993       buf[pos++] = ((pcr_base << 7) & 0x80) | 0x7e | ((pcr_ext >> 8) & 0x01);   /* set 6 reserve bits to 1 */
994       buf[pos++] = (pcr_ext) & 0xff;
995     }
996     if (pi->flags & TSMUX_PACKET_FLAG_WRITE_OPCR) {
997       guint64 opcr_base;
998       guint32 opcr_ext;
999
1000       opcr_base = (pi->opcr / 300);
1001       opcr_ext = (pi->opcr % 300);
1002
1003       flags |= 0x08;
1004       TS_DEBUG ("Writing OPCR");
1005       buf[pos++] = (opcr_base >> 25) & 0xff;
1006       buf[pos++] = (opcr_base >> 17) & 0xff;
1007       buf[pos++] = (opcr_base >> 9) & 0xff;
1008       buf[pos++] = (opcr_base >> 1) & 0xff;
1009       buf[pos++] = ((opcr_base << 7) & 0x80) | 0x7e | ((opcr_ext >> 8) & 0x01); /* set 6 reserve bits to 1 */
1010       buf[pos++] = (opcr_ext) & 0xff;
1011     }
1012     if (pi->flags & TSMUX_PACKET_FLAG_WRITE_SPLICE) {
1013       flags |= 0x04;
1014       buf[pos++] = pi->splice_countdown;
1015     }
1016     if (pi->private_data_len > 0) {
1017       flags |= 0x02;
1018       /* Private data to write, ensure we have enough room */
1019       if ((1 + pi->private_data_len) > (TSMUX_PAYLOAD_LENGTH - pos))
1020         return FALSE;
1021       buf[pos++] = pi->private_data_len;
1022       memcpy (&(buf[pos]), pi->private_data, pi->private_data_len);
1023       pos += pi->private_data_len;
1024       TS_DEBUG ("%u bytes of private data", pi->private_data_len);
1025     }
1026     if (pi->flags & TSMUX_PACKET_FLAG_WRITE_ADAPT_EXT) {
1027       flags |= 0x01;
1028       TS_DEBUG ("FIXME: write Adaptation extension");
1029       /* Write an empty extension for now */
1030       buf[pos++] = 1;
1031       buf[pos++] = 0x1f;        /* lower 5 bits are reserved, and should be all 1 */
1032     }
1033   }
1034   /* Write the flags at the start */
1035   buf[1] = flags;
1036
1037   /* Stuffing bytes if needed */
1038   while (pos < min_length)
1039     buf[pos++] = 0xff;
1040
1041   /* Write the adaptation field length, which doesn't include its own byte */
1042   buf[0] = pos - 1;
1043
1044   if (written)
1045     *written = pos;
1046
1047   return TRUE;
1048 }
1049
1050 static gboolean
1051 tsmux_write_ts_header (TsMux * mux, guint8 * buf, TsMuxPacketInfo * pi,
1052     guint stream_avail, guint * payload_len_out, guint * payload_offset_out)
1053 {
1054   guint8 *tmp;
1055   guint8 adaptation_flag = 0;
1056   guint8 adapt_min_length = 0;
1057   guint8 adapt_len = 0;
1058   guint payload_len;
1059   gboolean write_adapt = FALSE;
1060
1061   /* Sync byte */
1062   buf[0] = TSMUX_SYNC_BYTE;
1063
1064   TS_DEBUG ("PID 0x%04x, counter = 0x%01x, %u bytes avail", pi->pid,
1065       mux->pid_packet_counts[pi->pid] & 0x0f, stream_avail);
1066
1067   /* 3 bits:
1068    *   transport_error_indicator
1069    *   payload_unit_start_indicator
1070    *   transport_priority: (00)
1071    * 13 bits: PID
1072    */
1073   tmp = buf + 1;
1074   if (pi->packet_start_unit_indicator) {
1075     tsmux_put16 (&tmp, 0x4000 | pi->pid);
1076   } else
1077     tsmux_put16 (&tmp, pi->pid);
1078
1079   /* 2 bits: scrambling_control (NOT SUPPORTED) (00)
1080    * 2 bits: adaptation field control (1x has_adaptation_field | x1 has_payload)
1081    * 4 bits: continuity counter (xxxx)
1082    */
1083
1084   if (pi->flags & TSMUX_PACKET_FLAG_ADAPTATION) {
1085     write_adapt = TRUE;
1086   }
1087
1088   if (stream_avail < TSMUX_PAYLOAD_LENGTH) {
1089     /* Need an adaptation field regardless for stuffing */
1090     adapt_min_length = TSMUX_PAYLOAD_LENGTH - stream_avail;
1091     write_adapt = TRUE;
1092   }
1093
1094   if (write_adapt) {
1095     gboolean res;
1096
1097     /* Flag the adaptation field presence */
1098     adaptation_flag |= 0x20;
1099     res = tsmux_write_adaptation_field (buf + TSMUX_HEADER_LENGTH,
1100         pi, adapt_min_length, &adapt_len);
1101     if (G_UNLIKELY (res == FALSE))
1102       return FALSE;
1103
1104     /* Should have written at least the number of bytes we requested */
1105     g_assert (adapt_len >= adapt_min_length);
1106   }
1107
1108   /* The amount of packet data we wrote is the remaining space after
1109    * the adaptation field */
1110   payload_len = TSMUX_PAYLOAD_LENGTH - adapt_len;
1111
1112   if (payload_len_out)
1113     *payload_len_out = payload_len;
1114   else
1115     g_assert (payload_len == 0);
1116
1117   if (payload_offset_out)
1118     *payload_offset_out = TSMUX_HEADER_LENGTH + adapt_len;
1119
1120   /* Now if we are going to write out some payload, flag that fact */
1121   if (payload_len > 0 && stream_avail > 0) {
1122     /* Flag the presence of a payload */
1123     adaptation_flag |= 0x10;
1124
1125     /* We must have enough data to fill the payload, or some calculation
1126      * went wrong */
1127     g_assert (payload_len <= stream_avail);
1128
1129     /* Packet with payload, increment the continuity counter */
1130     mux->pid_packet_counts[pi->pid]++;
1131   }
1132
1133   adaptation_flag |= mux->pid_packet_counts[pi->pid] & 0x0f;
1134
1135   /* Write the byte of transport_scrambling_control, adaptation_field_control
1136    * + continuity counter out */
1137   buf[3] = adaptation_flag;
1138
1139
1140   if (write_adapt) {
1141     TS_DEBUG ("Adaptation field of size >= %d + %d bytes payload",
1142         adapt_len, payload_len);
1143   } else {
1144     TS_DEBUG ("Payload of %d bytes only", payload_len);
1145   }
1146
1147   return TRUE;
1148 }
1149
1150 static gboolean
1151 tsmux_section_write_packet (TsMux * mux, TsMuxSection * section)
1152 {
1153   guint8 *data;
1154   gsize data_size;
1155   guint payload_written = 0;
1156   gboolean ret = FALSE;
1157
1158   g_return_val_if_fail (section != NULL, FALSE);
1159   g_return_val_if_fail (mux != NULL, FALSE);
1160
1161   data = gst_mpegts_section_packetize (section->section, &data_size);
1162   if (!data) {
1163     GST_WARNING ("Could not packetize section");
1164     return FALSE;
1165   }
1166
1167   /* Mark the start of new PES unit */
1168   section->pi.packet_start_unit_indicator = TRUE;
1169
1170   /* Mark payload data size */
1171   section->pi.stream_avail = data_size;
1172
1173   while (section->pi.stream_avail > 0) {
1174     GstBuffer *buf;
1175     GstMapInfo map;
1176     guint len, offset;
1177
1178     if (!tsmux_get_buffer (mux, &buf))
1179       goto done;
1180
1181     if (!gst_buffer_map (buf, &map, GST_MAP_WRITE)) {
1182       gst_buffer_unref (buf);
1183       goto done;
1184     }
1185
1186     if (section->pi.packet_start_unit_indicator) {
1187       /* We need room for a pointer byte */
1188       if (!tsmux_write_ts_header (mux, map.data, &section->pi,
1189               section->pi.stream_avail + 1, &len, &offset)) {
1190         gst_buffer_unmap (buf, &map);
1191         gst_buffer_unref (buf);
1192         goto done;
1193       }
1194
1195       /* Write the pointer byte */
1196       map.data[offset++] = 0x00;
1197       len--;
1198     } else if (!tsmux_write_ts_header (mux, map.data, &section->pi,
1199             section->pi.stream_avail, &len, &offset)) {
1200       gst_buffer_unmap (buf, &map);
1201       gst_buffer_unref (buf);
1202       goto done;
1203     }
1204
1205     GST_DEBUG ("Creating section packet for offset %u with length %u; %u bytes"
1206         " remaining", payload_written, len, section->pi.stream_avail - len);
1207
1208     memcpy (map.data + offset, data + payload_written, len);
1209     gst_buffer_unmap (buf, &map);
1210
1211     /* Push the packet without PCR */
1212     if (G_UNLIKELY (!tsmux_packet_out (mux, buf, -1)))
1213       goto done;
1214
1215     section->pi.stream_avail -= len;
1216     payload_written += len;
1217     section->pi.packet_start_unit_indicator = FALSE;
1218   }
1219
1220   ret = TRUE;
1221
1222 done:
1223   return ret;
1224 }
1225
1226 /**
1227  * tsmux_send_section:
1228  * @mux: a #TsMux
1229  * @section: (transfer full): a #GstMpegtsSection to add
1230  *
1231  * Send a @section immediately on the stream.
1232  *
1233  * Returns: %TRUE on success, %FALSE otherwise
1234  */
1235 gboolean
1236 tsmux_send_section (TsMux * mux, GstMpegtsSection * section)
1237 {
1238   gboolean ret;
1239   TsMuxSection tsmux_section;
1240
1241   g_return_val_if_fail (mux != NULL, FALSE);
1242   g_return_val_if_fail (section != NULL, FALSE);
1243
1244   memset (&tsmux_section, 0, sizeof (tsmux_section));
1245
1246   GST_DEBUG ("Sending mpegts section with type %d to mux",
1247       section->section_type);
1248
1249   tsmux_section.section = section;
1250   tsmux_section.pi.pid = section->pid;
1251
1252   ret = tsmux_section_write_packet (mux, &tsmux_section);
1253   gst_mpegts_section_unref (section);
1254
1255   return ret;
1256 }
1257
1258 static void
1259 tsmux_write_si_foreach (gpointer key, gpointer value, gpointer user_data)
1260 {
1261   GstMpegtsSectionType section_type = GPOINTER_TO_INT (key);
1262   TsMuxSection *section = value;
1263   TsMux *mux = user_data;
1264
1265   if (!tsmux_section_write_packet (mux, section))
1266     GST_WARNING ("Failed to send SI section (type %d)", section_type);
1267 }
1268
1269 static gboolean
1270 tsmux_write_si (TsMux * mux)
1271 {
1272   g_hash_table_foreach (mux->si_sections, tsmux_write_si_foreach, mux);
1273   mux->si_changed = FALSE;
1274   return TRUE;
1275 }
1276
1277 static void
1278 tsmux_write_null_ts_header (guint8 * buf)
1279 {
1280   *buf++ = TSMUX_SYNC_BYTE;
1281   *buf++ = 0x1f;
1282   *buf++ = 0xff;
1283   *buf++ = 0x10;
1284 }
1285
1286 static gint64
1287 ts_to_pcr (gint64 ts)
1288 {
1289   if (ts == G_MININT64) {
1290     return 0;
1291   }
1292
1293   return (ts - TSMUX_PCR_OFFSET) * (TSMUX_SYS_CLOCK_FREQ / TSMUX_CLOCK_FREQ);
1294 }
1295
1296 /* Calculate the PCR to write into the current packet */
1297 static gint64
1298 get_current_pcr (TsMux * mux, gint64 cur_ts)
1299 {
1300   if (!mux->bitrate)
1301     return ts_to_pcr (cur_ts);
1302
1303   if (mux->first_pcr_ts == G_MININT64) {
1304     g_assert (cur_ts != G_MININT64);
1305     mux->first_pcr_ts = cur_ts;
1306     GST_DEBUG ("First PCR offset is %" G_GUINT64_FORMAT, cur_ts);
1307   }
1308
1309   return ts_to_pcr (mux->first_pcr_ts) +
1310       gst_util_uint64_scale ((mux->n_bytes + PCR_BYTE_OFFSET) * 8,
1311       TSMUX_SYS_CLOCK_FREQ, mux->bitrate);
1312 }
1313
1314 /* Predict the PCR at the next packet if possible */
1315 static gint64
1316 get_next_pcr (TsMux * mux, gint64 cur_ts)
1317 {
1318   if (!mux->bitrate)
1319     return ts_to_pcr (cur_ts);
1320
1321   if (mux->first_pcr_ts == G_MININT64) {
1322     g_assert (cur_ts != G_MININT64);
1323     mux->first_pcr_ts = cur_ts;
1324     GST_DEBUG ("First PCR offset is %" G_GUINT64_FORMAT, cur_ts);
1325   }
1326
1327   return ts_to_pcr (mux->first_pcr_ts) +
1328       gst_util_uint64_scale ((mux->n_bytes + TSMUX_PACKET_LENGTH +
1329           PCR_BYTE_OFFSET) * 8, TSMUX_SYS_CLOCK_FREQ, mux->bitrate);
1330 }
1331
1332 static gint64
1333 write_new_pcr (TsMux * mux, TsMuxStream * stream, gint64 cur_pcr,
1334     gint64 next_pcr)
1335 {
1336   if (stream->next_pcr == -1 || next_pcr > stream->next_pcr) {
1337     stream->pi.flags |=
1338         TSMUX_PACKET_FLAG_ADAPTATION | TSMUX_PACKET_FLAG_WRITE_PCR;
1339     stream->pi.pcr = cur_pcr;
1340
1341     if (mux->bitrate && stream->next_pcr != -1 && cur_pcr >= stream->next_pcr) {
1342       GST_WARNING ("Writing PCR %" G_GUINT64_FORMAT " missed the target %"
1343           G_GUINT64_FORMAT " by %f ms", cur_pcr, stream->next_pcr,
1344           (double) (cur_pcr - stream->next_pcr) / 27000.0);
1345     }
1346     /* Next PCR deadline is now plus the scheduled interval */
1347     stream->next_pcr = cur_pcr + mux->pcr_interval * 300;
1348   } else {
1349     cur_pcr = -1;
1350   }
1351
1352   return cur_pcr;
1353 }
1354
1355 static gboolean
1356 rewrite_si (TsMux * mux, gint64 cur_ts)
1357 {
1358   gboolean write_pat;
1359   gboolean write_si;
1360   GList *cur;
1361   gint64 next_pcr;
1362
1363   next_pcr = get_next_pcr (mux, cur_ts);
1364
1365   /* check if we need to rewrite pat */
1366   if (mux->next_pat_pcr == -1 || mux->pat_changed)
1367     write_pat = TRUE;
1368   else if (next_pcr > mux->next_pat_pcr)
1369     write_pat = TRUE;
1370   else
1371     write_pat = FALSE;
1372
1373   if (write_pat) {
1374     if (mux->next_pat_pcr == -1)
1375       mux->next_pat_pcr = next_pcr + mux->pat_interval * 300;
1376     else
1377       mux->next_pat_pcr += mux->pat_interval * 300;
1378
1379     if (!tsmux_write_pat (mux))
1380       return FALSE;
1381
1382     next_pcr = get_next_pcr (mux, cur_ts);
1383   }
1384
1385   /* check if we need to rewrite sit */
1386   if (mux->next_si_pcr == -1 || mux->si_changed)
1387     write_si = TRUE;
1388   else if (next_pcr > mux->next_si_pcr)
1389     write_si = TRUE;
1390   else
1391     write_si = FALSE;
1392
1393   if (write_si) {
1394     if (mux->next_si_pcr == -1)
1395       mux->next_si_pcr = next_pcr + mux->si_interval * 300;
1396     else
1397       mux->next_si_pcr += mux->si_interval * 300;
1398
1399     if (!tsmux_write_si (mux))
1400       return FALSE;
1401
1402     next_pcr = get_current_pcr (mux, cur_ts);
1403   }
1404
1405   /* check if we need to rewrite any of the current pmts */
1406   for (cur = mux->programs; cur; cur = cur->next) {
1407     TsMuxProgram *program = (TsMuxProgram *) cur->data;
1408     gboolean write_pmt;
1409
1410     if (program->next_pmt_pcr == -1 || program->pmt_changed)
1411       write_pmt = TRUE;
1412     else if (next_pcr > program->next_pmt_pcr)
1413       write_pmt = TRUE;
1414     else
1415       write_pmt = FALSE;
1416
1417     if (write_pmt) {
1418       if (program->next_pmt_pcr == -1)
1419         program->next_pmt_pcr = next_pcr + program->pmt_interval * 300;
1420       else
1421         program->next_pmt_pcr += program->pmt_interval * 300;
1422
1423       if (!tsmux_write_pmt (mux, program))
1424         return FALSE;
1425
1426       next_pcr = get_current_pcr (mux, cur_ts);
1427     }
1428
1429     if (program->scte35_pid != 0) {
1430       gboolean write_scte_null = FALSE;
1431       if (program->next_scte35_pcr == -1)
1432         write_scte_null = TRUE;
1433       else if (next_pcr > program->next_scte35_pcr)
1434         write_scte_null = TRUE;
1435
1436       if (write_scte_null) {
1437         GST_DEBUG ("next scte35 pcr %" G_GINT64_FORMAT,
1438             program->next_scte35_pcr);
1439         if (program->next_scte35_pcr == -1)
1440           program->next_scte35_pcr =
1441               next_pcr + program->scte35_null_interval * 300;
1442         else
1443           program->next_scte35_pcr += program->scte35_null_interval * 300;
1444         GST_DEBUG ("next scte35 NOW pcr %" G_GINT64_FORMAT,
1445             program->next_scte35_pcr);
1446
1447         if (!tsmux_write_scte_null (mux, program))
1448           return FALSE;
1449
1450         next_pcr = get_current_pcr (mux, cur_ts);
1451       }
1452     }
1453
1454     program->wrote_si = TRUE;
1455   }
1456
1457   return TRUE;
1458 }
1459
1460 static gboolean
1461 pad_stream (TsMux * mux, TsMuxStream * stream, gint64 cur_ts)
1462 {
1463   guint64 bitrate;
1464   GstBuffer *buf = NULL;
1465   GstMapInfo map;
1466   gboolean ret = TRUE;
1467   GstClockTimeDiff diff;
1468   guint64 start_n_bytes;
1469
1470   if (!mux->bitrate)
1471     goto done;
1472
1473   if (!GST_CLOCK_STIME_IS_VALID (cur_ts))
1474     goto done;
1475
1476   if (!GST_CLOCK_STIME_IS_VALID (stream->first_ts))
1477     stream->first_ts = cur_ts;
1478
1479   diff = GST_CLOCK_DIFF (stream->first_ts, cur_ts);
1480   if (diff == 0)
1481     goto done;
1482
1483   ret = FALSE;
1484   start_n_bytes = mux->n_bytes;
1485   do {
1486     GST_LOG ("Transport stream bitrate: %" G_GUINT64_FORMAT " over %"
1487         G_GUINT64_FORMAT " bytes, duration %" GST_TIME_FORMAT,
1488         gst_util_uint64_scale (mux->n_bytes * 8, TSMUX_CLOCK_FREQ, diff),
1489         mux->n_bytes, GST_TIME_ARGS (diff * GST_SECOND / TSMUX_CLOCK_FREQ));
1490
1491     /* calculate what the overall bitrate will be if we add 1 more packet */
1492     bitrate =
1493         gst_util_uint64_scale ((mux->n_bytes + TSMUX_PACKET_LENGTH) * 8,
1494         TSMUX_CLOCK_FREQ, diff);
1495
1496     if (bitrate <= mux->bitrate) {
1497       gint64 new_pcr;
1498
1499       if (!tsmux_get_buffer (mux, &buf))
1500         goto done;
1501
1502       if (!gst_buffer_map (buf, &map, GST_MAP_WRITE)) {
1503         gst_buffer_unref (buf);
1504         goto done;
1505       }
1506
1507       new_pcr = write_new_pcr (mux, stream, get_current_pcr (mux, cur_ts),
1508           get_next_pcr (mux, cur_ts));
1509       if (new_pcr != -1) {
1510         GST_LOG ("Writing PCR-only packet on PID 0x%04x", stream->pi.pid);
1511         tsmux_write_ts_header (mux, map.data, &stream->pi, 0, NULL, NULL);
1512       } else {
1513         GST_LOG ("Writing null stuffing packet");
1514         if (!rewrite_si (mux, cur_ts)) {
1515           gst_buffer_unmap (buf, &map);
1516           gst_buffer_unref (buf);
1517           goto done;
1518         }
1519         tsmux_write_null_ts_header (map.data);
1520         memset (map.data + TSMUX_HEADER_LENGTH, 0xFF, TSMUX_PAYLOAD_LENGTH);
1521       }
1522
1523       gst_buffer_unmap (buf, &map);
1524
1525       stream->pi.flags &= TSMUX_PACKET_FLAG_PES_FULL_HEADER;
1526       if (!tsmux_packet_out (mux, buf, new_pcr))
1527         goto done;
1528     }
1529   } while (bitrate < mux->bitrate);
1530
1531   if (mux->n_bytes != start_n_bytes) {
1532     GST_LOG ("Finished padding the mux");
1533   }
1534
1535   ret = TRUE;
1536
1537 done:
1538   return ret;
1539 }
1540
1541 /**
1542  * tsmux_write_stream_packet:
1543  * @mux: a #TsMux
1544  * @stream: a #TsMuxStream
1545  *
1546  * Write a packet of @stream.
1547  *
1548  * Returns: TRUE if the packet could be written.
1549  */
1550 gboolean
1551 tsmux_write_stream_packet (TsMux * mux, TsMuxStream * stream)
1552 {
1553   guint payload_len, payload_offs;
1554   TsMuxPacketInfo *pi = &stream->pi;
1555   gboolean res;
1556   gint64 new_pcr = -1;
1557   GstBuffer *buf = NULL;
1558   GstMapInfo map;
1559
1560   g_return_val_if_fail (mux != NULL, FALSE);
1561   g_return_val_if_fail (stream != NULL, FALSE);
1562
1563   if (tsmux_stream_is_pcr (stream)) {
1564     gint64 cur_ts = CLOCK_BASE;
1565     if (tsmux_stream_get_dts (stream) != G_MININT64)
1566       cur_ts += tsmux_stream_get_dts (stream);
1567     else
1568       cur_ts += tsmux_stream_get_pts (stream);
1569
1570     if (!rewrite_si (mux, cur_ts))
1571       goto fail;
1572
1573     if (!pad_stream (mux, stream, cur_ts))
1574       goto fail;
1575
1576     new_pcr =
1577         write_new_pcr (mux, stream, get_current_pcr (mux, cur_ts),
1578         get_next_pcr (mux, cur_ts));
1579   }
1580
1581   pi->packet_start_unit_indicator = tsmux_stream_at_pes_start (stream);
1582   if (pi->packet_start_unit_indicator) {
1583     tsmux_stream_initialize_pes_packet (stream);
1584     if (stream->dts != G_MININT64)
1585       stream->dts += CLOCK_BASE;
1586     if (stream->pts != G_MININT64)
1587       stream->pts += CLOCK_BASE;
1588   }
1589   pi->stream_avail = tsmux_stream_bytes_avail (stream);
1590
1591   /* obtain buffer */
1592   if (!tsmux_get_buffer (mux, &buf))
1593     return FALSE;
1594
1595   gst_buffer_map (buf, &map, GST_MAP_WRITE);
1596
1597   if (!tsmux_write_ts_header (mux, map.data, pi, pi->stream_avail, &payload_len,
1598           &payload_offs))
1599     goto fail;
1600
1601
1602   if (!tsmux_stream_get_data (stream, map.data + payload_offs, payload_len))
1603     goto fail;
1604
1605   gst_buffer_unmap (buf, &map);
1606
1607   GST_DEBUG ("Writing PES of size %d", (int) gst_buffer_get_size (buf));
1608   res = tsmux_packet_out (mux, buf, new_pcr);
1609
1610   /* Reset all dynamic flags */
1611   stream->pi.flags &= TSMUX_PACKET_FLAG_PES_FULL_HEADER;
1612
1613   return res;
1614
1615   /* ERRORS */
1616 fail:
1617   {
1618     if (buf) {
1619       gst_buffer_unmap (buf, &map);
1620       gst_buffer_unref (buf);
1621     }
1622     return FALSE;
1623   }
1624 }
1625
1626 /**
1627  * tsmux_program_free:
1628  * @program: a #TsMuxProgram
1629  *
1630  * Free the resources of @program. After this call @program can not be used
1631  * anymore.
1632  */
1633 void
1634 tsmux_program_free (TsMuxProgram * program)
1635 {
1636   g_return_if_fail (program != NULL);
1637
1638   /* Free PMT section */
1639   if (program->pmt.section)
1640     gst_mpegts_section_unref (program->pmt.section);
1641   if (program->scte35_null_section)
1642     tsmux_section_free (program->scte35_null_section);
1643
1644   g_ptr_array_free (program->streams, TRUE);
1645   g_slice_free (TsMuxProgram, program);
1646 }
1647
1648 /**
1649  * tsmux_program_set_pmt_pid:
1650  * @program: A #TsmuxProgram
1651  * @pmt_pid: PID to write PMT for this program
1652  */
1653 void
1654 tsmux_program_set_pmt_pid (TsMuxProgram * program, guint16 pmt_pid)
1655 {
1656   program->pmt_pid = pmt_pid;
1657 }
1658
1659 static gint
1660 compare_program_number (gconstpointer a, gconstpointer b)
1661 {
1662   const GstMpegtsPatProgram *pgm1 = *(const GstMpegtsPatProgram * const *) a;
1663   const GstMpegtsPatProgram *pgm2 = *(const GstMpegtsPatProgram * const *) b;
1664   gint num1 = pgm1->program_number, num2 = pgm2->program_number;
1665
1666   return num1 - num2;
1667 }
1668
1669 static gboolean
1670 tsmux_write_pat (TsMux * mux)
1671 {
1672
1673   if (mux->pat_changed) {
1674     /* program_association_section ()
1675      * for (i = 0; i < N; i++) {
1676      *    program_number                         16   uimsbf
1677      *    reserved                                3   bslbf
1678      *    network_PID_or_program_map_PID         13   uimbsf
1679      * }
1680      * CRC_32                                    32   rbchof
1681      */
1682     GList *cur;
1683     GPtrArray *pat;
1684
1685     pat = gst_mpegts_pat_new ();
1686
1687     for (cur = mux->programs; cur; cur = cur->next) {
1688       GstMpegtsPatProgram *pat_pgm;
1689       TsMuxProgram *program = (TsMuxProgram *) cur->data;
1690
1691       pat_pgm = gst_mpegts_pat_program_new ();
1692       pat_pgm->program_number = program->pgm_number;
1693       pat_pgm->network_or_program_map_PID = program->pmt_pid;
1694
1695       g_ptr_array_add (pat, pat_pgm);
1696     }
1697
1698     g_ptr_array_sort (pat, compare_program_number);
1699
1700     if (mux->pat.section)
1701       gst_mpegts_section_unref (mux->pat.section);
1702
1703     mux->pat.section = gst_mpegts_section_from_pat (pat, mux->transport_id);
1704
1705     mux->pat.section->version_number = mux->pat_version++;
1706
1707     TS_DEBUG ("PAT has %d programs", mux->nb_programs);
1708     mux->pat_changed = FALSE;
1709   }
1710
1711   return tsmux_section_write_packet (mux, &mux->pat);
1712 }
1713
1714 static gboolean
1715 tsmux_write_pmt (TsMux * mux, TsMuxProgram * program)
1716 {
1717
1718   if (program->pmt_changed) {
1719     /* program_association_section ()
1720      * reserved                                   3   bslbf
1721      * PCR_PID                                   13   uimsbf
1722      * reserved                                   4   bslbf
1723      * program_info_length                       12   uimsbf
1724      * for (i = 0; i < N; i++)
1725      *   descriptor ()
1726      *
1727      * for (i = 0; i < N1; i++) {
1728      *    stream_type                             8   uimsbf
1729      *    reserved                                3   bslbf
1730      *    elementary_PID                         13   uimbsf
1731      *    reserved                                4   bslbf
1732      *    ES_info_length                         12   uimbsf
1733      *    for (i = 0; i < N1; i++) {
1734      *      descriptor ();
1735      *    }
1736      * }
1737      */
1738     GstMpegtsDescriptor *descriptor;
1739     GstMpegtsPMT *pmt;
1740 #if 0
1741     /* See note about bluray descriptors below */
1742     guint8 desc[] = { 0x0F, 0xFF, 0xFC, 0xFC };
1743 #endif
1744     guint i;
1745
1746     pmt = gst_mpegts_pmt_new ();
1747
1748     if (program->pcr_stream == NULL)
1749       pmt->pcr_pid = 0x1FFF;
1750     else
1751       pmt->pcr_pid = tsmux_stream_get_pid (program->pcr_stream);
1752
1753 #if 0
1754     /* FIXME : These two descriptors should not be added in all PMT
1755      * but only in "bluray-compatible" mpeg-ts output. I even have my
1756      * doubt whether the DTCP descriptor is even needed */
1757     descriptor = gst_mpegts_descriptor_from_registration ("HDMV", NULL, 0);
1758     g_ptr_array_add (pmt->descriptors, descriptor);
1759
1760     /* DTCP descriptor, see
1761      * http://www.dtcp.com/documents/dtcp/info-20150204-dtcp-v1-rev%201-71.pdf */
1762     descriptor = gst_mpegts_descriptor_from_custom (0x88, desc, 4);
1763     g_ptr_array_add (pmt->descriptors, descriptor);
1764 #endif
1765
1766     /* Will SCTE-35 be potentially used ? */
1767     if (program->scte35_pid != 0) {
1768       descriptor = gst_mpegts_descriptor_from_registration ("CUEI", NULL, 0);
1769       g_ptr_array_add (pmt->descriptors, descriptor);
1770     }
1771
1772     /* Write out the entries */
1773     for (i = 0; i < program->streams->len; i++) {
1774       GstMpegtsPMTStream *pmt_stream;
1775       TsMuxStream *stream = g_ptr_array_index (program->streams, i);
1776
1777       pmt_stream = gst_mpegts_pmt_stream_new ();
1778
1779       /* FIXME: Use API to retrieve this from the stream */
1780       pmt_stream->stream_type = stream->stream_type;
1781       pmt_stream->pid = tsmux_stream_get_pid (stream);
1782
1783       /* Write any ES descriptors needed */
1784       tsmux_stream_get_es_descrs (stream, pmt_stream);
1785       g_ptr_array_add (pmt->streams, pmt_stream);
1786     }
1787
1788     /* Will SCTE-35 be potentially used ? */
1789     if (program->scte35_pid != 0) {
1790       GstMpegtsPMTStream *pmt_stream = gst_mpegts_pmt_stream_new ();
1791       pmt_stream->stream_type = GST_MPEGTS_STREAM_TYPE_SCTE_SIT;
1792       pmt_stream->pid = program->scte35_pid;
1793       g_ptr_array_add (pmt->streams, pmt_stream);
1794     }
1795
1796     TS_DEBUG ("PMT for program %d has %d streams",
1797         program->pgm_number, program->streams->len);
1798
1799     pmt->program_number = program->pgm_number;
1800
1801     program->pmt.pi.pid = program->pmt_pid;
1802     program->pmt_changed = FALSE;
1803
1804     if (program->pmt.section)
1805       gst_mpegts_section_unref (program->pmt.section);
1806
1807     program->pmt.section = gst_mpegts_section_from_pmt (pmt, program->pmt_pid);
1808     program->pmt.section->version_number = program->pmt_version++;
1809   }
1810
1811   return tsmux_section_write_packet (mux, &program->pmt);
1812 }
1813
1814 static gboolean
1815 tsmux_write_scte_null (TsMux * mux, TsMuxProgram * program)
1816 {
1817   /* SCTE-35 NULL section is created when PID is set */
1818   GST_LOG ("Writing SCTE NULL packet");
1819   return tsmux_section_write_packet (mux, program->scte35_null_section);
1820 }
1821
1822 void
1823 tsmux_set_bitrate (TsMux * mux, guint64 bitrate)
1824 {
1825   mux->bitrate = bitrate;
1826 }