2011-02-16 16:57:42 +00:00
|
|
|
/*
|
|
|
|
|
* mpegtspacketizer.h -
|
|
|
|
|
* Copyright (C) 2007 Alessandro Decina
|
|
|
|
|
*
|
|
|
|
|
* Authors:
|
|
|
|
|
* Alessandro Decina <alessandro@nnva.org>
|
|
|
|
|
*
|
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU Library General Public
|
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
|
* Library General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU Library General Public
|
|
|
|
|
* License along with this library; if not, write to the
|
2012-11-03 20:38:00 +00:00
|
|
|
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
|
|
|
|
* Boston, MA 02110-1301, USA.
|
2011-02-16 16:57:42 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef GST_MPEGTS_PACKETIZER_H
|
|
|
|
|
#define GST_MPEGTS_PACKETIZER_H
|
|
|
|
|
|
|
|
|
|
#include <gst/gst.h>
|
|
|
|
|
#include <gst/base/gstadapter.h>
|
|
|
|
|
#include <glib.h>
|
|
|
|
|
|
2013-06-23 06:43:23 +00:00
|
|
|
#include <gst/mpegts/mpegts.h>
|
2012-02-23 17:46:09 +00:00
|
|
|
#include "gstmpegdefs.h"
|
|
|
|
|
|
2011-02-16 16:57:42 +00:00
|
|
|
#define MPEGTS_NORMAL_PACKETSIZE 188
|
|
|
|
|
#define MPEGTS_M2TS_PACKETSIZE 192
|
|
|
|
|
#define MPEGTS_DVB_ASI_PACKETSIZE 204
|
|
|
|
|
#define MPEGTS_ATSC_PACKETSIZE 208
|
|
|
|
|
|
|
|
|
|
#define MPEGTS_MIN_PACKETSIZE MPEGTS_NORMAL_PACKETSIZE
|
|
|
|
|
#define MPEGTS_MAX_PACKETSIZE MPEGTS_ATSC_PACKETSIZE
|
|
|
|
|
|
2013-07-29 06:18:24 +00:00
|
|
|
#define MPEGTS_AFC_DISCONTINUITY_FLAG 0x80
|
2020-01-10 15:52:58 +00:00
|
|
|
#define MPEGTS_AFC_RANDOM_ACCESS_FLAG 0x40
|
2013-07-29 06:18:24 +00:00
|
|
|
#define MPEGTS_AFC_ELEMENTARY_STREAM_PRIORITY 0x20
|
|
|
|
|
#define MPEGTS_AFC_PCR_FLAG 0x10
|
|
|
|
|
#define MPEGTS_AFC_OPCR_FLAG 0x08
|
|
|
|
|
#define MPEGTS_AFC_SPLICING_POINT_FLAG 0x04
|
|
|
|
|
#define MPEGTS_AFC_TRANSPORT_PRIVATE_DATA_FLAG 0x02
|
|
|
|
|
#define MPEGTS_AFC_EXTENSION_FLAG 0x01
|
2011-02-16 16:57:42 +00:00
|
|
|
|
2012-02-23 17:46:09 +00:00
|
|
|
#define MAX_WINDOW 512
|
|
|
|
|
|
2011-02-16 16:57:42 +00:00
|
|
|
G_BEGIN_DECLS
|
|
|
|
|
|
|
|
|
|
#define GST_TYPE_MPEGTS_PACKETIZER \
|
|
|
|
|
(mpegts_packetizer_get_type())
|
|
|
|
|
#define GST_MPEGTS_PACKETIZER(obj) \
|
|
|
|
|
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MPEGTS_PACKETIZER,MpegTSPacketizer2))
|
|
|
|
|
#define GST_MPEGTS_PACKETIZER_CLASS(klass) \
|
|
|
|
|
(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_MPEGTS_PACKETIZER,MpegTSPacketizer2Class))
|
|
|
|
|
#define GST_IS_MPEGTS_PACKETIZER(obj) \
|
|
|
|
|
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MPEGTS_PACKETIZER))
|
|
|
|
|
#define GST_IS_MPEGTS_PACKETIZER_CLASS(klass) \
|
|
|
|
|
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_MPEGTS_PACKETIZER))
|
|
|
|
|
|
|
|
|
|
typedef struct _MpegTSPacketizer2 MpegTSPacketizer2;
|
|
|
|
|
typedef struct _MpegTSPacketizer2Class MpegTSPacketizer2Class;
|
|
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
|
{
|
2013-06-23 06:43:23 +00:00
|
|
|
guint16 pid;
|
2012-05-21 15:48:54 +00:00
|
|
|
guint continuity_counter;
|
|
|
|
|
|
2013-06-23 06:43:23 +00:00
|
|
|
/* Section data (always newly allocated) */
|
2012-05-21 15:48:54 +00:00
|
|
|
guint8 *section_data;
|
2012-06-04 06:39:11 +00:00
|
|
|
/* Current offset in section_data */
|
2012-05-21 15:48:54 +00:00
|
|
|
guint16 section_offset;
|
2013-06-23 06:43:23 +00:00
|
|
|
|
|
|
|
|
/* Values for pending section */
|
2012-06-04 06:39:11 +00:00
|
|
|
/* table_id of the pending section_data */
|
2013-06-23 06:43:23 +00:00
|
|
|
guint8 table_id;
|
|
|
|
|
guint section_length;
|
|
|
|
|
guint8 version_number;
|
|
|
|
|
guint16 subtable_extension;
|
|
|
|
|
guint8 section_number;
|
|
|
|
|
guint8 last_section_number;
|
2012-05-21 15:48:54 +00:00
|
|
|
|
2011-02-16 16:57:42 +00:00
|
|
|
GSList *subtables;
|
2012-05-21 15:48:54 +00:00
|
|
|
|
2012-06-04 06:39:11 +00:00
|
|
|
/* Upstream offset of the data contained in the section */
|
2011-02-16 16:57:42 +00:00
|
|
|
guint64 offset;
|
|
|
|
|
} MpegTSPacketizerStream;
|
|
|
|
|
|
2013-07-05 15:11:46 +00:00
|
|
|
/* Maximum number of MpegTSPcr
|
|
|
|
|
* 256 should be sufficient for most multiplexes */
|
|
|
|
|
#define MAX_PCR_OBS_CHANNELS 256
|
|
|
|
|
|
mpegtsdemux: New PCR<=>Offset estimation code
This allows:
* Better duration estimation
* More accurate PCR location
* Overall more accurate running-time location and calculation
Location and values of PCR are recorded in groups (PCROffsetGroup)
with notable PCR/Offset observations in them (when bitrate changed
for example). PCR and offset are stored as 32bit values to
reduce memory usage (they are differences against that group's
first_{pcr|offset}.
Those groups each contain a global PCR offset (pcr_offset) which
indicates how far in the stream that group is.
Whenever new PCR values are observed, we store them in a sliding
window estimator (PCROffsetGroupCurrent).
When a reset/wrapover/gap is detected, we close the current group with
current values and start a new one (the pcr_offset of that new group
is also calculated).
When a notable change in bitrate is observed (+/- 10%), we record
new values in the current group. This is a compromise between
storing all PCR/offset observations and none, while at the same time
providing better information for running-time<=>offset calculation
in VBR streams.
Whenever a new non-contiguous group is start (due to seeking for example)
we re-evaluate the pcr_offset of each groups. This allows detecting as
quickly as possible PCR wrapover/reset.
When wanting to find the offset of a certain running-time, one can
iterate the groups by looking at the pcr_offset (which in essence *is*
the running-time of that group in the overall stream).
Once a group (or neighbouring groups if the running-time is between two
groups) is found, once can use the recorded values to find the most
accurate offset.
Right now this code is only used in pull-mode , but could also
be activated later on for any seekable stream, like live timeshift
with queue2.
Future improvements:
* some heuristics to "compress" the stored values in groups so as to keep
the memory usage down while still keeping a decent amount of notable
points.
* After a seek compare expected and obtained PCR/Offset and if the
difference is too big, re-calculate position with newly observed
values and seek to that more accurate position.
Note that this code will *not* provide keyframe-accurate seeking, but
will allow a much more accurate PCR/running-time/offset location on
any random stream.
For past (observed) values it will be as accurate as can be.
For future values it will be better than the current situation.
Finally the more you seek, the more accurate your positioning will be.
2013-07-26 05:54:30 +00:00
|
|
|
/* PCR/offset structure */
|
|
|
|
|
typedef struct _PCROffset
|
|
|
|
|
{
|
|
|
|
|
/* PCR value (units: 1/27MHz) */
|
2014-08-05 09:45:55 +00:00
|
|
|
guint64 pcr;
|
mpegtsdemux: New PCR<=>Offset estimation code
This allows:
* Better duration estimation
* More accurate PCR location
* Overall more accurate running-time location and calculation
Location and values of PCR are recorded in groups (PCROffsetGroup)
with notable PCR/Offset observations in them (when bitrate changed
for example). PCR and offset are stored as 32bit values to
reduce memory usage (they are differences against that group's
first_{pcr|offset}.
Those groups each contain a global PCR offset (pcr_offset) which
indicates how far in the stream that group is.
Whenever new PCR values are observed, we store them in a sliding
window estimator (PCROffsetGroupCurrent).
When a reset/wrapover/gap is detected, we close the current group with
current values and start a new one (the pcr_offset of that new group
is also calculated).
When a notable change in bitrate is observed (+/- 10%), we record
new values in the current group. This is a compromise between
storing all PCR/offset observations and none, while at the same time
providing better information for running-time<=>offset calculation
in VBR streams.
Whenever a new non-contiguous group is start (due to seeking for example)
we re-evaluate the pcr_offset of each groups. This allows detecting as
quickly as possible PCR wrapover/reset.
When wanting to find the offset of a certain running-time, one can
iterate the groups by looking at the pcr_offset (which in essence *is*
the running-time of that group in the overall stream).
Once a group (or neighbouring groups if the running-time is between two
groups) is found, once can use the recorded values to find the most
accurate offset.
Right now this code is only used in pull-mode , but could also
be activated later on for any seekable stream, like live timeshift
with queue2.
Future improvements:
* some heuristics to "compress" the stored values in groups so as to keep
the memory usage down while still keeping a decent amount of notable
points.
* After a seek compare expected and obtained PCR/Offset and if the
difference is too big, re-calculate position with newly observed
values and seek to that more accurate position.
Note that this code will *not* provide keyframe-accurate seeking, but
will allow a much more accurate PCR/running-time/offset location on
any random stream.
For past (observed) values it will be as accurate as can be.
For future values it will be better than the current situation.
Finally the more you seek, the more accurate your positioning will be.
2013-07-26 05:54:30 +00:00
|
|
|
|
|
|
|
|
/* The offset (units: bytes) */
|
2014-08-05 09:45:55 +00:00
|
|
|
guint64 offset;
|
mpegtsdemux: New PCR<=>Offset estimation code
This allows:
* Better duration estimation
* More accurate PCR location
* Overall more accurate running-time location and calculation
Location and values of PCR are recorded in groups (PCROffsetGroup)
with notable PCR/Offset observations in them (when bitrate changed
for example). PCR and offset are stored as 32bit values to
reduce memory usage (they are differences against that group's
first_{pcr|offset}.
Those groups each contain a global PCR offset (pcr_offset) which
indicates how far in the stream that group is.
Whenever new PCR values are observed, we store them in a sliding
window estimator (PCROffsetGroupCurrent).
When a reset/wrapover/gap is detected, we close the current group with
current values and start a new one (the pcr_offset of that new group
is also calculated).
When a notable change in bitrate is observed (+/- 10%), we record
new values in the current group. This is a compromise between
storing all PCR/offset observations and none, while at the same time
providing better information for running-time<=>offset calculation
in VBR streams.
Whenever a new non-contiguous group is start (due to seeking for example)
we re-evaluate the pcr_offset of each groups. This allows detecting as
quickly as possible PCR wrapover/reset.
When wanting to find the offset of a certain running-time, one can
iterate the groups by looking at the pcr_offset (which in essence *is*
the running-time of that group in the overall stream).
Once a group (or neighbouring groups if the running-time is between two
groups) is found, once can use the recorded values to find the most
accurate offset.
Right now this code is only used in pull-mode , but could also
be activated later on for any seekable stream, like live timeshift
with queue2.
Future improvements:
* some heuristics to "compress" the stored values in groups so as to keep
the memory usage down while still keeping a decent amount of notable
points.
* After a seek compare expected and obtained PCR/Offset and if the
difference is too big, re-calculate position with newly observed
values and seek to that more accurate position.
Note that this code will *not* provide keyframe-accurate seeking, but
will allow a much more accurate PCR/running-time/offset location on
any random stream.
For past (observed) values it will be as accurate as can be.
For future values it will be better than the current situation.
Finally the more you seek, the more accurate your positioning will be.
2013-07-26 05:54:30 +00:00
|
|
|
} PCROffset;
|
|
|
|
|
|
|
|
|
|
/* Flags used on groups */
|
|
|
|
|
enum
|
|
|
|
|
{
|
|
|
|
|
/* Closed groups: There is a contiguous next group */
|
|
|
|
|
PCR_GROUP_FLAG_CLOSED = 1 << 0,
|
|
|
|
|
/* estimated: the pcr_offset has been estimated and is not
|
|
|
|
|
* guaranteed to be 100% accurate */
|
|
|
|
|
PCR_GROUP_FLAG_ESTIMATED = 1 << 1,
|
|
|
|
|
/* reset: there is a pcr reset between the end of this
|
|
|
|
|
* group and the next one.
|
|
|
|
|
* This flag is exclusive with CLOSED. */
|
|
|
|
|
PCR_GROUP_FLAG_RESET = 1 << 2,
|
|
|
|
|
/* reset: there is a pcr wrapover between the end of this
|
|
|
|
|
* group and the next one.
|
|
|
|
|
* This flag is exclusive with CLOSED. */
|
|
|
|
|
PCR_GROUP_FLAG_WRAPOVER = 1 << 3
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* PCROffsetGroup: A group of PCR observations.
|
|
|
|
|
* All values in a group have got the same reference pcr and
|
|
|
|
|
* byte offset (first_pcr/first_offset).
|
|
|
|
|
*/
|
|
|
|
|
#define DEFAULT_ALLOCATED_OFFSET 16
|
|
|
|
|
typedef struct _PCROffsetGroup
|
|
|
|
|
{
|
|
|
|
|
/* Flags (see PCR_GROUP_FLAG_* above) */
|
|
|
|
|
guint flags;
|
|
|
|
|
|
|
|
|
|
/* First raw PCR of this group. Units: 1/27MHz.
|
|
|
|
|
* All values[].pcr are differences against first_pcr */
|
|
|
|
|
guint64 first_pcr;
|
|
|
|
|
/* Offset of this group in bytes.
|
|
|
|
|
* All values[].offset are differences against first_offset */
|
|
|
|
|
guint64 first_offset;
|
|
|
|
|
|
|
|
|
|
/* Dynamically allocated table of PCROffset */
|
|
|
|
|
PCROffset *values;
|
|
|
|
|
/* number of PCROffset allocated in values */
|
|
|
|
|
guint nb_allocated;
|
|
|
|
|
/* number of *actual* PCROffset contained in values */
|
|
|
|
|
guint last_value;
|
|
|
|
|
|
|
|
|
|
/* Offset since the very first PCR value observed in the whole
|
|
|
|
|
* stream. Units: 1/27MHz.
|
|
|
|
|
* This will take into account gaps/wraparounds/resets/... and is
|
|
|
|
|
* used to determine running times.
|
|
|
|
|
* The value is only guaranteed to be 100% accurate if the group
|
|
|
|
|
* does not have the ESTIMATED flag.
|
|
|
|
|
* If the value is estimated, the pcr_offset shall be recalculated
|
|
|
|
|
* (based on previous groups) whenever it is accessed.
|
|
|
|
|
*/
|
|
|
|
|
guint64 pcr_offset;
|
|
|
|
|
|
|
|
|
|
/* FIXME : Cache group bitrate ? */
|
|
|
|
|
} PCROffsetGroup;
|
|
|
|
|
|
|
|
|
|
/* Number of PCRs needed before bitrate estimation can start */
|
|
|
|
|
/* Note: the reason we use 10 is because PCR should normally be
|
|
|
|
|
* received at least every 100ms so this gives us close to
|
|
|
|
|
* a 1s moving window to calculate bitrate */
|
|
|
|
|
#define PCR_BITRATE_NEEDED 10
|
|
|
|
|
|
|
|
|
|
/* PCROffsetCurrent: The PCR/Offset window iterator
|
|
|
|
|
* This is used to estimate/observe incoming PCR/offset values
|
|
|
|
|
* Points to a group (which it is filling) */
|
|
|
|
|
typedef struct _PCROffsetCurrent
|
|
|
|
|
{
|
|
|
|
|
/* The PCROffsetGroup we are filling.
|
|
|
|
|
* If NULL, a group needs to be identified */
|
|
|
|
|
PCROffsetGroup *group;
|
|
|
|
|
|
|
|
|
|
/* Table of pending values we are iterating over */
|
|
|
|
|
PCROffset pending[PCR_BITRATE_NEEDED];
|
|
|
|
|
|
|
|
|
|
/* base offset/pcr from the group */
|
|
|
|
|
guint64 first_pcr;
|
|
|
|
|
guint64 first_offset;
|
|
|
|
|
|
|
|
|
|
/* The previous reference PCROffset
|
|
|
|
|
* This corresponds to the last entry of the group we are filling
|
|
|
|
|
* and is used to calculate prev_bitrate */
|
|
|
|
|
PCROffset prev;
|
|
|
|
|
|
|
|
|
|
/* The last PCROffset in pending[] */
|
|
|
|
|
PCROffset last_value;
|
|
|
|
|
|
|
|
|
|
/* Location of first pending PCR/offset observation in pending */
|
|
|
|
|
guint first;
|
|
|
|
|
/* Location of last pending PCR/offset observation in pending */
|
|
|
|
|
guint last;
|
|
|
|
|
/* Location of next write in pending */
|
|
|
|
|
guint write;
|
|
|
|
|
|
|
|
|
|
/* bitrate is always in bytes per second */
|
|
|
|
|
|
|
|
|
|
/* cur_bitrate is the bitrate of the pending values: d(last-first) */
|
|
|
|
|
guint64 cur_bitrate;
|
|
|
|
|
|
|
|
|
|
/* prev_bitrate is the bitrate between reference PCROffset
|
|
|
|
|
* and the first pending value. Used to detect changes
|
|
|
|
|
* in bitrate */
|
|
|
|
|
guint64 prev_bitrate;
|
|
|
|
|
} PCROffsetCurrent;
|
|
|
|
|
|
2013-07-05 15:11:46 +00:00
|
|
|
typedef struct _MpegTSPCR
|
|
|
|
|
{
|
|
|
|
|
guint16 pid;
|
|
|
|
|
|
|
|
|
|
/* Following variables are only active/used when
|
|
|
|
|
* calculate_skew is TRUE */
|
|
|
|
|
GstClockTime base_time;
|
|
|
|
|
GstClockTime base_pcrtime;
|
|
|
|
|
GstClockTime prev_out_time;
|
|
|
|
|
GstClockTime prev_in_time;
|
|
|
|
|
GstClockTime last_pcrtime;
|
|
|
|
|
gint64 window[MAX_WINDOW];
|
|
|
|
|
guint window_pos;
|
|
|
|
|
guint window_size;
|
|
|
|
|
gboolean window_filling;
|
|
|
|
|
gint64 window_min;
|
|
|
|
|
gint64 skew;
|
|
|
|
|
gint64 prev_send_diff;
|
|
|
|
|
|
|
|
|
|
/* Offset to apply to PCR to handle wraparounds */
|
|
|
|
|
guint64 pcroffset;
|
|
|
|
|
|
|
|
|
|
/* Used for bitrate calculation */
|
mpegtsdemux: New PCR<=>Offset estimation code
This allows:
* Better duration estimation
* More accurate PCR location
* Overall more accurate running-time location and calculation
Location and values of PCR are recorded in groups (PCROffsetGroup)
with notable PCR/Offset observations in them (when bitrate changed
for example). PCR and offset are stored as 32bit values to
reduce memory usage (they are differences against that group's
first_{pcr|offset}.
Those groups each contain a global PCR offset (pcr_offset) which
indicates how far in the stream that group is.
Whenever new PCR values are observed, we store them in a sliding
window estimator (PCROffsetGroupCurrent).
When a reset/wrapover/gap is detected, we close the current group with
current values and start a new one (the pcr_offset of that new group
is also calculated).
When a notable change in bitrate is observed (+/- 10%), we record
new values in the current group. This is a compromise between
storing all PCR/offset observations and none, while at the same time
providing better information for running-time<=>offset calculation
in VBR streams.
Whenever a new non-contiguous group is start (due to seeking for example)
we re-evaluate the pcr_offset of each groups. This allows detecting as
quickly as possible PCR wrapover/reset.
When wanting to find the offset of a certain running-time, one can
iterate the groups by looking at the pcr_offset (which in essence *is*
the running-time of that group in the overall stream).
Once a group (or neighbouring groups if the running-time is between two
groups) is found, once can use the recorded values to find the most
accurate offset.
Right now this code is only used in pull-mode , but could also
be activated later on for any seekable stream, like live timeshift
with queue2.
Future improvements:
* some heuristics to "compress" the stored values in groups so as to keep
the memory usage down while still keeping a decent amount of notable
points.
* After a seek compare expected and obtained PCR/Offset and if the
difference is too big, re-calculate position with newly observed
values and seek to that more accurate position.
Note that this code will *not* provide keyframe-accurate seeking, but
will allow a much more accurate PCR/running-time/offset location on
any random stream.
For past (observed) values it will be as accurate as can be.
For future values it will be better than the current situation.
Finally the more you seek, the more accurate your positioning will be.
2013-07-26 05:54:30 +00:00
|
|
|
/* List of PCR/offset observations */
|
|
|
|
|
GList *groups;
|
2013-07-05 15:11:46 +00:00
|
|
|
|
mpegtsdemux: New PCR<=>Offset estimation code
This allows:
* Better duration estimation
* More accurate PCR location
* Overall more accurate running-time location and calculation
Location and values of PCR are recorded in groups (PCROffsetGroup)
with notable PCR/Offset observations in them (when bitrate changed
for example). PCR and offset are stored as 32bit values to
reduce memory usage (they are differences against that group's
first_{pcr|offset}.
Those groups each contain a global PCR offset (pcr_offset) which
indicates how far in the stream that group is.
Whenever new PCR values are observed, we store them in a sliding
window estimator (PCROffsetGroupCurrent).
When a reset/wrapover/gap is detected, we close the current group with
current values and start a new one (the pcr_offset of that new group
is also calculated).
When a notable change in bitrate is observed (+/- 10%), we record
new values in the current group. This is a compromise between
storing all PCR/offset observations and none, while at the same time
providing better information for running-time<=>offset calculation
in VBR streams.
Whenever a new non-contiguous group is start (due to seeking for example)
we re-evaluate the pcr_offset of each groups. This allows detecting as
quickly as possible PCR wrapover/reset.
When wanting to find the offset of a certain running-time, one can
iterate the groups by looking at the pcr_offset (which in essence *is*
the running-time of that group in the overall stream).
Once a group (or neighbouring groups if the running-time is between two
groups) is found, once can use the recorded values to find the most
accurate offset.
Right now this code is only used in pull-mode , but could also
be activated later on for any seekable stream, like live timeshift
with queue2.
Future improvements:
* some heuristics to "compress" the stored values in groups so as to keep
the memory usage down while still keeping a decent amount of notable
points.
* After a seek compare expected and obtained PCR/Offset and if the
difference is too big, re-calculate position with newly observed
values and seek to that more accurate position.
Note that this code will *not* provide keyframe-accurate seeking, but
will allow a much more accurate PCR/running-time/offset location on
any random stream.
For past (observed) values it will be as accurate as can be.
For future values it will be better than the current situation.
Finally the more you seek, the more accurate your positioning will be.
2013-07-26 05:54:30 +00:00
|
|
|
/* Current PCR/offset observations (used to update pcroffsets) */
|
|
|
|
|
PCROffsetCurrent *current;
|
2013-07-05 15:11:46 +00:00
|
|
|
} MpegTSPCR;
|
|
|
|
|
|
2011-02-16 16:57:42 +00:00
|
|
|
struct _MpegTSPacketizer2 {
|
2012-05-21 15:48:54 +00:00
|
|
|
GObject parent;
|
2011-02-16 16:57:42 +00:00
|
|
|
|
2014-07-03 11:39:19 +00:00
|
|
|
GMutex group_lock;
|
|
|
|
|
|
2011-02-16 16:57:42 +00:00
|
|
|
GstAdapter *adapter;
|
|
|
|
|
/* streams hashed by pid */
|
2012-03-01 16:56:34 +00:00
|
|
|
/* FIXME : be more memory efficient (see how it's done in mpegtsbase) */
|
2011-02-16 16:57:42 +00:00
|
|
|
MpegTSPacketizerStream **streams;
|
2012-05-21 15:48:54 +00:00
|
|
|
gboolean disposed;
|
|
|
|
|
guint16 packet_size;
|
2011-02-16 16:57:42 +00:00
|
|
|
|
|
|
|
|
/* current offset of the tip of the adapter */
|
2012-05-21 15:48:54 +00:00
|
|
|
guint64 offset;
|
2011-02-16 16:57:42 +00:00
|
|
|
gboolean empty;
|
2012-02-23 17:46:09 +00:00
|
|
|
|
|
|
|
|
/* clock skew calculation */
|
|
|
|
|
gboolean calculate_skew;
|
2012-03-01 16:53:41 +00:00
|
|
|
|
2012-03-01 16:56:34 +00:00
|
|
|
/* offset/bitrate calculator */
|
|
|
|
|
gboolean calculate_offset;
|
|
|
|
|
|
2013-07-05 15:11:46 +00:00
|
|
|
/* Shortcuts for adapter usage */
|
|
|
|
|
guint8 *map_data;
|
|
|
|
|
gsize map_offset;
|
|
|
|
|
gsize map_size;
|
|
|
|
|
gboolean need_sync;
|
|
|
|
|
|
|
|
|
|
/* Reference offset */
|
|
|
|
|
guint64 refoffset;
|
|
|
|
|
|
mpegtsdemux: New PCR<=>Offset estimation code
This allows:
* Better duration estimation
* More accurate PCR location
* Overall more accurate running-time location and calculation
Location and values of PCR are recorded in groups (PCROffsetGroup)
with notable PCR/Offset observations in them (when bitrate changed
for example). PCR and offset are stored as 32bit values to
reduce memory usage (they are differences against that group's
first_{pcr|offset}.
Those groups each contain a global PCR offset (pcr_offset) which
indicates how far in the stream that group is.
Whenever new PCR values are observed, we store them in a sliding
window estimator (PCROffsetGroupCurrent).
When a reset/wrapover/gap is detected, we close the current group with
current values and start a new one (the pcr_offset of that new group
is also calculated).
When a notable change in bitrate is observed (+/- 10%), we record
new values in the current group. This is a compromise between
storing all PCR/offset observations and none, while at the same time
providing better information for running-time<=>offset calculation
in VBR streams.
Whenever a new non-contiguous group is start (due to seeking for example)
we re-evaluate the pcr_offset of each groups. This allows detecting as
quickly as possible PCR wrapover/reset.
When wanting to find the offset of a certain running-time, one can
iterate the groups by looking at the pcr_offset (which in essence *is*
the running-time of that group in the overall stream).
Once a group (or neighbouring groups if the running-time is between two
groups) is found, once can use the recorded values to find the most
accurate offset.
Right now this code is only used in pull-mode , but could also
be activated later on for any seekable stream, like live timeshift
with queue2.
Future improvements:
* some heuristics to "compress" the stored values in groups so as to keep
the memory usage down while still keeping a decent amount of notable
points.
* After a seek compare expected and obtained PCR/Offset and if the
difference is too big, re-calculate position with newly observed
values and seek to that more accurate position.
Note that this code will *not* provide keyframe-accurate seeking, but
will allow a much more accurate PCR/running-time/offset location on
any random stream.
For past (observed) values it will be as accurate as can be.
For future values it will be better than the current situation.
Finally the more you seek, the more accurate your positioning will be.
2013-07-26 05:54:30 +00:00
|
|
|
/* Number of seen pcr/offset observations (FIXME : kill later) */
|
2013-07-05 15:11:46 +00:00
|
|
|
guint nb_seen_offsets;
|
|
|
|
|
|
|
|
|
|
/* Last inputted timestamp */
|
|
|
|
|
GstClockTime last_in_time;
|
|
|
|
|
|
|
|
|
|
/* offset to observations table */
|
|
|
|
|
guint8 pcrtablelut[0x2000];
|
|
|
|
|
MpegTSPCR *observations[MAX_PCR_OBS_CHANNELS];
|
|
|
|
|
guint8 lastobsid;
|
2014-10-29 11:58:37 +00:00
|
|
|
GstClockTime pcr_discont_threshold;
|
2020-11-05 11:48:27 +00:00
|
|
|
|
|
|
|
|
/* PTS/DTS of last buffer */
|
|
|
|
|
GstClockTime last_pts;
|
|
|
|
|
GstClockTime last_dts;
|
2021-09-05 09:57:18 +00:00
|
|
|
|
|
|
|
|
/* Extra time offset to handle values before initial PCR.
|
|
|
|
|
* This will be added to all converted timestamps */
|
|
|
|
|
GstClockTime extra_shift;
|
2011-02-16 16:57:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct _MpegTSPacketizer2Class {
|
|
|
|
|
GObjectClass object_class;
|
|
|
|
|
};
|
|
|
|
|
|
2013-06-23 06:43:23 +00:00
|
|
|
#define FLAGS_SCRAMBLED(f) (f & 0xc0)
|
|
|
|
|
#define FLAGS_HAS_AFC(f) (f & 0x20)
|
|
|
|
|
#define FLAGS_HAS_PAYLOAD(f) (f & 0x10)
|
|
|
|
|
#define FLAGS_CONTINUITY_COUNTER(f) (f & 0x0f)
|
|
|
|
|
|
2011-02-16 16:57:42 +00:00
|
|
|
typedef struct
|
|
|
|
|
{
|
2012-05-21 15:48:54 +00:00
|
|
|
gint16 pid;
|
|
|
|
|
guint8 payload_unit_start_indicator;
|
2013-06-23 06:43:23 +00:00
|
|
|
guint8 scram_afc_cc;
|
2011-02-16 16:57:42 +00:00
|
|
|
guint8 *payload;
|
|
|
|
|
|
2012-03-29 15:55:09 +00:00
|
|
|
guint8 *data_start;
|
2011-02-16 16:57:42 +00:00
|
|
|
guint8 *data_end;
|
2012-03-29 15:55:09 +00:00
|
|
|
guint8 *data;
|
2011-02-16 16:57:42 +00:00
|
|
|
|
2012-05-21 15:48:54 +00:00
|
|
|
guint8 afc_flags;
|
2011-02-16 16:57:42 +00:00
|
|
|
guint64 pcr;
|
|
|
|
|
guint64 offset;
|
|
|
|
|
} MpegTSPacketizerPacket;
|
|
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
|
{
|
|
|
|
|
guint8 table_id;
|
|
|
|
|
/* the spec says sub_table_extension is the fourth and fifth byte of a
|
|
|
|
|
* section when the section_syntax_indicator is set to a value of "1". If
|
|
|
|
|
* section_syntax_indicator is 0, sub_table_extension will be set to 0 */
|
2013-06-23 06:43:23 +00:00
|
|
|
guint16 subtable_extension;
|
|
|
|
|
guint8 version_number;
|
|
|
|
|
guint8 last_section_number;
|
|
|
|
|
/* table of bits, whether the section was seen or not.
|
|
|
|
|
* Use MPEGTS_BIT_* macros to check */
|
|
|
|
|
/* Size is 32, because there's a maximum of 256 (32*8) section_number */
|
|
|
|
|
guint8 seen_section[32];
|
2011-02-16 16:57:42 +00:00
|
|
|
} MpegTSPacketizerStreamSubtable;
|
|
|
|
|
|
2013-06-23 06:43:23 +00:00
|
|
|
#define MPEGTS_BIT_SET(field, offs) ((field)[(offs) >> 3] |= (1 << ((offs) & 0x7)))
|
|
|
|
|
#define MPEGTS_BIT_UNSET(field, offs) ((field)[(offs) >> 3] &= ~(1 << ((offs) & 0x7)))
|
|
|
|
|
#define MPEGTS_BIT_IS_SET(field, offs) ((field)[(offs) >> 3] & (1 << ((offs) & 0x7)))
|
|
|
|
|
|
2011-02-16 16:57:42 +00:00
|
|
|
typedef enum {
|
|
|
|
|
PACKET_BAD = FALSE,
|
|
|
|
|
PACKET_OK = TRUE,
|
|
|
|
|
PACKET_NEED_MORE
|
|
|
|
|
} MpegTSPacketizerPacketReturn;
|
|
|
|
|
|
2012-07-13 14:22:11 +00:00
|
|
|
G_GNUC_INTERNAL GType mpegts_packetizer_get_type(void);
|
|
|
|
|
|
|
|
|
|
G_GNUC_INTERNAL MpegTSPacketizer2 *mpegts_packetizer_new (void);
|
|
|
|
|
G_GNUC_INTERNAL void mpegts_packetizer_clear (MpegTSPacketizer2 *packetizer);
|
2013-05-24 08:59:59 +00:00
|
|
|
G_GNUC_INTERNAL void mpegts_packetizer_flush (MpegTSPacketizer2 *packetizer, gboolean hard);
|
2012-07-13 14:22:11 +00:00
|
|
|
G_GNUC_INTERNAL void mpegts_packetizer_push (MpegTSPacketizer2 *packetizer, GstBuffer *buffer);
|
|
|
|
|
G_GNUC_INTERNAL gboolean mpegts_packetizer_has_packets (MpegTSPacketizer2 *packetizer);
|
|
|
|
|
G_GNUC_INTERNAL MpegTSPacketizerPacketReturn mpegts_packetizer_next_packet (MpegTSPacketizer2 *packetizer,
|
2011-02-16 16:57:42 +00:00
|
|
|
MpegTSPacketizerPacket *packet);
|
2012-07-13 14:22:11 +00:00
|
|
|
G_GNUC_INTERNAL MpegTSPacketizerPacketReturn
|
2012-03-01 16:53:41 +00:00
|
|
|
mpegts_packetizer_process_next_packet(MpegTSPacketizer2 * packetizer);
|
2012-07-13 14:22:11 +00:00
|
|
|
G_GNUC_INTERNAL void mpegts_packetizer_clear_packet (MpegTSPacketizer2 *packetizer,
|
2012-04-19 12:20:52 +00:00
|
|
|
MpegTSPacketizerPacket *packet);
|
2012-07-13 14:22:11 +00:00
|
|
|
G_GNUC_INTERNAL void mpegts_packetizer_remove_stream(MpegTSPacketizer2 *packetizer,
|
2011-02-16 16:57:42 +00:00
|
|
|
gint16 pid);
|
|
|
|
|
|
2014-06-25 12:50:05 +00:00
|
|
|
G_GNUC_INTERNAL GstMpegtsSection *mpegts_packetizer_push_section (MpegTSPacketizer2 *packetzer,
|
2013-07-07 06:29:37 +00:00
|
|
|
MpegTSPacketizerPacket *packet, GList **remaining);
|
2011-02-16 16:57:42 +00:00
|
|
|
|
2012-03-01 16:56:34 +00:00
|
|
|
/* Only valid if calculate_offset is TRUE */
|
2012-07-13 14:22:11 +00:00
|
|
|
G_GNUC_INTERNAL GstClockTime
|
2012-03-01 16:56:34 +00:00
|
|
|
mpegts_packetizer_offset_to_ts (MpegTSPacketizer2 * packetizer,
|
2012-06-26 16:59:32 +00:00
|
|
|
guint64 offset, guint16 pcr_pid);
|
2012-07-13 14:22:11 +00:00
|
|
|
G_GNUC_INTERNAL guint64
|
2012-03-01 16:56:34 +00:00
|
|
|
mpegts_packetizer_ts_to_offset (MpegTSPacketizer2 * packetizer,
|
2012-06-26 16:59:32 +00:00
|
|
|
GstClockTime ts, guint16 pcr_pid);
|
2012-07-13 14:22:11 +00:00
|
|
|
G_GNUC_INTERNAL GstClockTime
|
2012-03-01 16:56:34 +00:00
|
|
|
mpegts_packetizer_pts_to_ts (MpegTSPacketizer2 * packetizer,
|
2012-06-26 16:59:32 +00:00
|
|
|
GstClockTime pts, guint16 pcr_pid);
|
2014-10-20 10:30:50 +00:00
|
|
|
G_GNUC_INTERNAL GstClockTime
|
2022-03-24 17:55:48 +00:00
|
|
|
mpegts_packetizer_pts_to_ts_unchecked (MpegTSPacketizer2 * packetizer,
|
|
|
|
|
GstClockTime pts, guint16 pcr_pid);
|
|
|
|
|
G_GNUC_INTERNAL GstClockTime
|
2014-10-20 10:30:50 +00:00
|
|
|
mpegts_packetizer_get_current_time (MpegTSPacketizer2 * packetizer,
|
|
|
|
|
guint16 pcr_pid);
|
2012-07-13 14:22:11 +00:00
|
|
|
G_GNUC_INTERNAL void
|
mpegtsdemux: New PCR<=>Offset estimation code
This allows:
* Better duration estimation
* More accurate PCR location
* Overall more accurate running-time location and calculation
Location and values of PCR are recorded in groups (PCROffsetGroup)
with notable PCR/Offset observations in them (when bitrate changed
for example). PCR and offset are stored as 32bit values to
reduce memory usage (they are differences against that group's
first_{pcr|offset}.
Those groups each contain a global PCR offset (pcr_offset) which
indicates how far in the stream that group is.
Whenever new PCR values are observed, we store them in a sliding
window estimator (PCROffsetGroupCurrent).
When a reset/wrapover/gap is detected, we close the current group with
current values and start a new one (the pcr_offset of that new group
is also calculated).
When a notable change in bitrate is observed (+/- 10%), we record
new values in the current group. This is a compromise between
storing all PCR/offset observations and none, while at the same time
providing better information for running-time<=>offset calculation
in VBR streams.
Whenever a new non-contiguous group is start (due to seeking for example)
we re-evaluate the pcr_offset of each groups. This allows detecting as
quickly as possible PCR wrapover/reset.
When wanting to find the offset of a certain running-time, one can
iterate the groups by looking at the pcr_offset (which in essence *is*
the running-time of that group in the overall stream).
Once a group (or neighbouring groups if the running-time is between two
groups) is found, once can use the recorded values to find the most
accurate offset.
Right now this code is only used in pull-mode , but could also
be activated later on for any seekable stream, like live timeshift
with queue2.
Future improvements:
* some heuristics to "compress" the stored values in groups so as to keep
the memory usage down while still keeping a decent amount of notable
points.
* After a seek compare expected and obtained PCR/Offset and if the
difference is too big, re-calculate position with newly observed
values and seek to that more accurate position.
Note that this code will *not* provide keyframe-accurate seeking, but
will allow a much more accurate PCR/running-time/offset location on
any random stream.
For past (observed) values it will be as accurate as can be.
For future values it will be better than the current situation.
Finally the more you seek, the more accurate your positioning will be.
2013-07-26 05:54:30 +00:00
|
|
|
mpegts_packetizer_set_current_pcr_offset (MpegTSPacketizer2 * packetizer,
|
|
|
|
|
GstClockTime offset, guint16 pcr_pid);
|
|
|
|
|
G_GNUC_INTERNAL void
|
2012-03-01 16:56:34 +00:00
|
|
|
mpegts_packetizer_set_reference_offset (MpegTSPacketizer2 * packetizer,
|
|
|
|
|
guint64 refoffset);
|
2014-10-29 11:58:37 +00:00
|
|
|
G_GNUC_INTERNAL void
|
|
|
|
|
mpegts_packetizer_set_pcr_discont_threshold (MpegTSPacketizer2 * packetizer,
|
|
|
|
|
GstClockTime threshold);
|
2011-02-16 16:57:42 +00:00
|
|
|
G_END_DECLS
|
|
|
|
|
|
|
|
|
|
#endif /* GST_MPEGTS_PACKETIZER_H */
|
