gstreamer/subprojects/gst-plugins-bad/gst-libs/gst/mpegts/gst-atsc-section.c

1763 lines
45 KiB
C
Raw Normal View History

/*
* Copyright (C) 2014 Stefan Ringel
*
* Authors:
* Stefan Ringel <linuxtv@stefanringel.de>
*
* 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
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
libs: fix API export/import and 'inconsistent linkage' on MSVC For each lib we build export its own API in headers when we're building it, otherwise import the API from the headers. This fixes linker warnings on Windows when building with MSVC. The problem was that we had defined all GST_*_API decorators unconditionally to GST_EXPORT. This was intentional and only supposed to be temporary, but caused linker warnings because we tell the linker that we want to export all symbols even those from externall DLLs, and when the linker notices that they were in external DLLS and not present locally it warns. What we need to do when building each library is: export the library's own symbols and import all other symbols. To this end we define e.g. BUILDING_GST_FOO and then we define the GST_FOO_API decorator either to export or to import symbols depending on whether BUILDING_GST_FOO is set or not. That way external users of each library API automatically get the import. While we're at it, add new GST_API_EXPORT in config.h and use that for GST_*_API decorators instead of GST_EXPORT. The right export define depends on the toolchain and whether we're using -fvisibility=hidden or not, so it's better to set it to the right thing directly than hard-coding a compiler whitelist in the public header. We put the export define into config.h instead of passing it via the command line to the compiler because it might contain spaces and brackets and in the autotools scenario we'd have to pass that through multiple layers of plumbing and Makefile/shell escaping and we're just not going to be *that* lucky. The export define is only used if we're compiling our lib, not by external users of the lib headers, so it's not a problem to put it into config.h Also, this means all .c files of libs need to include config.h to get the export marker defined, so fix up a few that didn't include config.h. This commit depends on a common submodule commit that makes gst-glib-gen.mak add an #include "config.h" to generated enum/marshal .c files for the autotools build. https://bugzilla.gnome.org/show_bug.cgi?id=797185
2018-09-24 10:52:22 +00:00
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <string.h>
#include <stdlib.h>
#include "mpegts.h"
#include "gstmpegts-private.h"
/**
* SECTION:gst-atsc-section
* @title: ATSC variants of MPEG-TS sections
* @short_description: Sections for the various ATSC specifications
* @include: gst/mpegts/mpegts.h
*
* The list of section types defined and used by the ATSC specifications can be
* seen in %GstMpegtsSectionATSCTableID.
*
* # Supported ATSC MPEG-TS sections
* These are the sections for which parsing and packetizing code exists.
*
* ## Master Guide Table (MGT)
* See:
* * gst_mpegts_section_get_atsc_mgt()
* * %GstMpegtsAtscMGT
* * %GstMpegtsAtscMGTTable
* * gst_mpegts_atsc_mgt_new()
*
* ## Terrestrial (TVCT) and Cable (CVCT) Virtual Channel Table
* See:
* * gst_mpegts_section_get_atsc_tvct()
* * gst_mpegts_section_get_atsc_cvct()
* * %GstMpegtsAtscVCT
* * %GstMpegtsAtscVCTSource
*
* ## Rating Region Table (RRT)
* See:
* * gst_mpegts_section_get_atsc_rrt()
* * %GstMpegtsAtscRRT
* * gst_mpegts_atsc_rrt_new()
*
* ## Event Information Table (EIT)
* See:
* * gst_mpegts_section_get_atsc_eit()
* * %GstMpegtsAtscEIT
* * %GstMpegtsAtscEITEvent
*
* ## Extended Text Table (ETT)
* See:
* * gst_mpegts_section_get_atsc_ett()
* * %GstMpegtsAtscETT
*
* ## System Time Table (STT)
* See:
* * gst_mpegts_section_get_atsc_stt()
* * %GstMpegtsAtscSTT
* * gst_mpegts_atsc_stt_new()
*
* # API
*/
/* Terrestrial/Cable Virtual Channel Table TVCT/CVCT */
static GstMpegtsAtscVCTSource *
_gst_mpegts_atsc_vct_source_copy (GstMpegtsAtscVCTSource * source)
{
GstMpegtsAtscVCTSource *copy;
copy = g_memdup2 (source, sizeof (GstMpegtsAtscVCTSource));
copy->descriptors = g_ptr_array_ref (source->descriptors);
return copy;
}
static void
_gst_mpegts_atsc_vct_source_free (GstMpegtsAtscVCTSource * source)
{
2014-07-08 18:43:32 +00:00
g_free (source->short_name);
if (source->descriptors)
g_ptr_array_unref (source->descriptors);
g_free (source);
}
G_DEFINE_BOXED_TYPE (GstMpegtsAtscVCTSource, gst_mpegts_atsc_vct_source,
(GBoxedCopyFunc) _gst_mpegts_atsc_vct_source_copy,
(GFreeFunc) _gst_mpegts_atsc_vct_source_free);
static GstMpegtsAtscVCT *
_gst_mpegts_atsc_vct_copy (GstMpegtsAtscVCT * vct)
{
GstMpegtsAtscVCT *copy;
copy = g_memdup2 (vct, sizeof (GstMpegtsAtscVCT));
copy->sources = g_ptr_array_ref (vct->sources);
copy->descriptors = g_ptr_array_ref (vct->descriptors);
return copy;
}
static void
_gst_mpegts_atsc_vct_free (GstMpegtsAtscVCT * vct)
{
if (vct->sources)
g_ptr_array_unref (vct->sources);
if (vct->descriptors)
g_ptr_array_unref (vct->descriptors);
g_free (vct);
}
G_DEFINE_BOXED_TYPE (GstMpegtsAtscVCT, gst_mpegts_atsc_vct,
(GBoxedCopyFunc) _gst_mpegts_atsc_vct_copy,
(GFreeFunc) _gst_mpegts_atsc_vct_free);
static gpointer
_parse_atsc_vct (GstMpegtsSection * section)
{
GstMpegtsAtscVCT *vct = NULL;
guint8 *data, *end, source_nb;
guint32 tmp32;
guint16 descriptors_loop_length, tmp16;
guint i;
GError *err = NULL;
vct = g_new0 (GstMpegtsAtscVCT, 1);
data = section->data;
end = data + section->section_length;
vct->transport_stream_id = section->subtable_extension;
/* Skip already parsed data */
data += 8;
/* minimum size */
if (end - data < 2 + 2 + 4)
goto error;
vct->protocol_version = *data;
data += 1;
source_nb = *data;
data += 1;
vct->sources = g_ptr_array_new_full (source_nb,
(GDestroyNotify) _gst_mpegts_atsc_vct_source_free);
for (i = 0; i < source_nb; i++) {
GstMpegtsAtscVCTSource *source;
/* minimum 32 bytes for a entry, 2 bytes second descriptor
loop-length, 4 bytes crc */
if (end - data < 32 + 2 + 4)
goto error;
source = g_new0 (GstMpegtsAtscVCTSource, 1);
g_ptr_array_add (vct->sources, source);
source->short_name =
g_convert ((gchar *) data, 14, "utf-8", "utf-16be", NULL, NULL, &err);
if (err) {
GST_WARNING ("Failed to convert VCT Source short_name to utf-8: %d %s",
err->code, err->message);
GST_MEMDUMP ("UTF-16 string", data, 14);
g_error_free (err);
}
data += 14;
tmp32 = GST_READ_UINT32_BE (data);
source->major_channel_number = (tmp32 >> 18) & 0x03FF;
source->minor_channel_number = (tmp32 >> 8) & 0x03FF;
source->modulation_mode = tmp32 & 0xF;
data += 4;
source->carrier_frequency = GST_READ_UINT32_BE (data);
data += 4;
source->channel_TSID = GST_READ_UINT16_BE (data);
data += 2;
source->program_number = GST_READ_UINT16_BE (data);
data += 2;
tmp16 = GST_READ_UINT16_BE (data);
source->ETM_location = (tmp16 >> 14) & 0x3;
source->access_controlled = (tmp16 >> 13) & 0x1;
source->hidden = (tmp16 >> 12) & 0x1;
/* only used in CVCT */
source->path_select = (tmp16 >> 11) & 0x1;
source->out_of_band = (tmp16 >> 10) & 0x1;
source->hide_guide = (tmp16 >> 9) & 0x1;
source->service_type = tmp16 & 0x3f;
data += 2;
source->source_id = GST_READ_UINT16_BE (data);
data += 2;
descriptors_loop_length = GST_READ_UINT16_BE (data) & 0x03FF;
data += 2;
if (end - data < descriptors_loop_length + 6)
goto error;
source->descriptors =
gst_mpegts_parse_descriptors (data, descriptors_loop_length);
if (source->descriptors == NULL)
goto error;
data += descriptors_loop_length;
}
descriptors_loop_length = GST_READ_UINT16_BE (data) & 0x03FF;
data += 2;
if (end - data < descriptors_loop_length + 4)
goto error;
vct->descriptors =
gst_mpegts_parse_descriptors (data, descriptors_loop_length);
if (vct->descriptors == NULL)
goto error;
return (gpointer) vct;
error:
_gst_mpegts_atsc_vct_free (vct);
return NULL;
}
/**
* gst_mpegts_section_get_atsc_tvct:
* @section: a #GstMpegtsSection of type %GST_MPEGTS_SECTION_ATSC_TVCT
*
* Returns the #GstMpegtsAtscVCT contained in the @section
*
* Returns: The #GstMpegtsAtscVCT contained in the section, or %NULL if an error
* happened.
*/
const GstMpegtsAtscVCT *
gst_mpegts_section_get_atsc_tvct (GstMpegtsSection * section)
{
g_return_val_if_fail (section->section_type == GST_MPEGTS_SECTION_ATSC_TVCT,
NULL);
g_return_val_if_fail (section->cached_parsed || section->data, NULL);
if (!section->cached_parsed)
section->cached_parsed =
__common_section_checks (section, 16, _parse_atsc_vct,
(GDestroyNotify) _gst_mpegts_atsc_vct_free);
return (const GstMpegtsAtscVCT *) section->cached_parsed;
}
/**
* gst_mpegts_section_get_atsc_cvct:
* @section: a #GstMpegtsSection of type %GST_MPEGTS_SECTION_ATSC_CVCT
*
* Returns the #GstMpegtsAtscVCT contained in the @section
*
* Returns: The #GstMpegtsAtscVCT contained in the section, or %NULL if an error
* happened.
*/
const GstMpegtsAtscVCT *
gst_mpegts_section_get_atsc_cvct (GstMpegtsSection * section)
{
g_return_val_if_fail (section->section_type == GST_MPEGTS_SECTION_ATSC_CVCT,
NULL);
g_return_val_if_fail (section->cached_parsed || section->data, NULL);
if (!section->cached_parsed)
section->cached_parsed =
__common_section_checks (section, 16, _parse_atsc_vct,
(GDestroyNotify) _gst_mpegts_atsc_vct_free);
return (const GstMpegtsAtscVCT *) section->cached_parsed;
}
/* MGT */
static GstMpegtsAtscMGTTable *
_gst_mpegts_atsc_mgt_table_copy (GstMpegtsAtscMGTTable * mgt_table)
{
GstMpegtsAtscMGTTable *copy;
copy = g_memdup2 (mgt_table, sizeof (GstMpegtsAtscMGTTable));
copy->descriptors = g_ptr_array_ref (mgt_table->descriptors);
return copy;
}
static void
_gst_mpegts_atsc_mgt_table_free (GstMpegtsAtscMGTTable * mgt_table)
{
g_ptr_array_unref (mgt_table->descriptors);
g_free (mgt_table);
}
G_DEFINE_BOXED_TYPE (GstMpegtsAtscMGTTable, gst_mpegts_atsc_mgt_table,
(GBoxedCopyFunc) _gst_mpegts_atsc_mgt_table_copy,
(GFreeFunc) _gst_mpegts_atsc_mgt_table_free);
static GstMpegtsAtscMGT *
_gst_mpegts_atsc_mgt_copy (GstMpegtsAtscMGT * mgt)
{
GstMpegtsAtscMGT *copy;
copy = g_memdup2 (mgt, sizeof (GstMpegtsAtscMGT));
copy->tables = g_ptr_array_ref (mgt->tables);
copy->descriptors = g_ptr_array_ref (mgt->descriptors);
return copy;
}
static void
_gst_mpegts_atsc_mgt_free (GstMpegtsAtscMGT * mgt)
{
g_ptr_array_unref (mgt->tables);
g_ptr_array_unref (mgt->descriptors);
g_free (mgt);
}
G_DEFINE_BOXED_TYPE (GstMpegtsAtscMGT, gst_mpegts_atsc_mgt,
(GBoxedCopyFunc) _gst_mpegts_atsc_mgt_copy,
(GFreeFunc) _gst_mpegts_atsc_mgt_free);
static gpointer
_parse_atsc_mgt (GstMpegtsSection * section)
{
GstMpegtsAtscMGT *mgt = NULL;
guint i = 0;
guint8 *data, *end;
guint16 descriptors_loop_length;
mgt = g_new0 (GstMpegtsAtscMGT, 1);
data = section->data;
end = data + section->section_length;
/* Skip already parsed data */
data += 8;
mgt->protocol_version = GST_READ_UINT8 (data);
data += 1;
mgt->tables_defined = GST_READ_UINT16_BE (data);
data += 2;
mgt->tables = g_ptr_array_new_full (mgt->tables_defined,
(GDestroyNotify) _gst_mpegts_atsc_mgt_table_free);
for (i = 0; i < mgt->tables_defined && data + 11 < end; i++) {
GstMpegtsAtscMGTTable *mgt_table;
if (data + 11 >= end) {
GST_WARNING ("MGT data too short to parse inner table num %d", i);
goto error;
}
mgt_table = g_new0 (GstMpegtsAtscMGTTable, 1);
g_ptr_array_add (mgt->tables, mgt_table);
mgt_table->table_type = GST_READ_UINT16_BE (data);
data += 2;
mgt_table->pid = GST_READ_UINT16_BE (data) & 0x1FFF;
data += 2;
mgt_table->version_number = GST_READ_UINT8 (data) & 0x1F;
data += 1;
mgt_table->number_bytes = GST_READ_UINT32_BE (data);
data += 4;
descriptors_loop_length = GST_READ_UINT16_BE (data) & 0x0FFF;
data += 2;
if (data + descriptors_loop_length >= end) {
GST_WARNING ("MGT data too short to parse inner table descriptors (table "
"num %d", i);
goto error;
}
mgt_table->descriptors =
gst_mpegts_parse_descriptors (data, descriptors_loop_length);
data += descriptors_loop_length;
}
descriptors_loop_length = GST_READ_UINT16_BE (data) & 0xFFF;
data += 2;
if (data + descriptors_loop_length >= end) {
GST_WARNING ("MGT data too short to parse descriptors");
goto error;
}
mgt->descriptors =
gst_mpegts_parse_descriptors (data, descriptors_loop_length);
return (gpointer) mgt;
error:
_gst_mpegts_atsc_mgt_free (mgt);
return NULL;
}
static gboolean
_packetize_mgt (GstMpegtsSection * section)
{
const GstMpegtsAtscMGT *mgt;
guint8 *pos, *data;
gsize length;
guint i, j;
mgt = gst_mpegts_section_get_atsc_mgt (section);
if (mgt == NULL)
return FALSE;
if (mgt->tables_defined != mgt->tables->len)
return FALSE;
/* 8 byte common section fields
* 1 byte protocol version
* 2 byte tables_defined
* 2 byte reserved / descriptors_length
* 4 byte CRC
*/
length = 17;
for (i = 0; i < mgt->tables->len; i++) {
GstMpegtsAtscMGTTable *mgt_table = g_ptr_array_index (mgt->tables, 1);
/* 2 byte table_type
* 2 byte reserved / table_type_PID
* 1 byte reserved / table_type_version_number
* 4 byte number bytes
* 2 byte reserved / table_type_descriptors_length
*/
length += 11;
if (mgt_table->descriptors) {
for (j = 0; j < mgt_table->descriptors->len; j++) {
GstMpegtsDescriptor *descriptor =
g_ptr_array_index (mgt_table->descriptors, j);
length += descriptor->length + 2;
}
}
}
if (mgt->descriptors) {
for (i = 0; i < mgt->descriptors->len; i++) {
GstMpegtsDescriptor *descriptor = g_ptr_array_index (mgt->descriptors, i);
length += descriptor->length + 2;
}
}
_packetize_common_section (section, length);
data = section->data + 8;
/* protocol_version - 8 bit */
GST_WRITE_UINT8 (data, mgt->protocol_version);
data += 1;
/* tables_defined - 16 bit uimsbf */
GST_WRITE_UINT16_BE (data, mgt->tables_defined);
data += 2;
for (i = 0; i < mgt->tables_defined; i++) {
GstMpegtsAtscMGTTable *mgt_table = g_ptr_array_index (mgt->tables, 1);
/* table_type - 16 bit uimsbf */
GST_WRITE_UINT16_BE (data, mgt_table->table_type);
data += 2;
/* 3 bit reserved, 13 bit table_type_PID uimsbf */
GST_WRITE_UINT16_BE (data, mgt_table->pid | 0xe000);
data += 2;
/* 3 bit reserved, 5 bit table_type_version_number uimsbf */
GST_WRITE_UINT8 (data, mgt_table->version_number | 0xe0);
data += 1;
/* 4 bit reserved, 12 bit table_type_descriptor_length uimsbf */
pos = data;
*data++ = 0xF0;
*data++ = 0x00;
_packetize_descriptor_array (mgt_table->descriptors, &data);
/* Go back and update the descriptor length */
GST_WRITE_UINT16_BE (pos, (data - pos - 2) | 0xF000);
}
/* 4 bit reserved, 12 bit descriptor_length uimsbf */
pos = data;
*data++ = 0xF0;
*data++ = 0x00;
_packetize_descriptor_array (mgt->descriptors, &data);
/* Go back and update the descriptor length */
GST_WRITE_UINT16_BE (pos, (data - pos - 2) | 0xF000);
return TRUE;
}
/**
* gst_mpegts_section_from_atsc_mgt:
* @mgt: (transfer full): a #GstMpegtsAtscMGT to create the #GstMpegtsSection from
*
* Returns: (transfer full): the #GstMpegtsSection
* Since: 1.18
*/
GstMpegtsSection *
gst_mpegts_section_from_atsc_mgt (GstMpegtsAtscMGT * mgt)
{
GstMpegtsSection *section;
g_return_val_if_fail (mgt != NULL, NULL);
section = _gst_mpegts_section_init (0x1ffb,
GST_MTS_TABLE_ID_ATSC_MASTER_GUIDE);
section->subtable_extension = 0x0000;
section->cached_parsed = (gpointer) mgt;
section->packetizer = _packetize_mgt;
section->destroy_parsed = (GDestroyNotify) _gst_mpegts_atsc_mgt_free;
return section;
}
/**
* gst_mpegts_section_get_atsc_mgt:
* @section: a #GstMpegtsSection of type %GST_MPEGTS_SECTION_ATSC_MGT
*
* Returns the #GstMpegtsAtscMGT contained in the @section.
*
* Returns: The #GstMpegtsAtscMGT contained in the section, or %NULL if an error
* happened.
*/
const GstMpegtsAtscMGT *
gst_mpegts_section_get_atsc_mgt (GstMpegtsSection * section)
{
g_return_val_if_fail (section->section_type == GST_MPEGTS_SECTION_ATSC_MGT,
NULL);
g_return_val_if_fail (section->cached_parsed || section->data, NULL);
if (!section->cached_parsed)
section->cached_parsed =
__common_section_checks (section, 17, _parse_atsc_mgt,
(GDestroyNotify) _gst_mpegts_atsc_mgt_free);
return (const GstMpegtsAtscMGT *) section->cached_parsed;
}
/**
* gst_mpegts_section_atsc_mgt_new:
*
* Returns: (transfer full): #GstMpegtsAtscMGT
* Since: 1.18
*/
GstMpegtsAtscMGT *
gst_mpegts_atsc_mgt_new (void)
{
GstMpegtsAtscMGT *mgt;
mgt = g_new0 (GstMpegtsAtscMGT, 1);
mgt->tables = g_ptr_array_new_with_free_func ((GDestroyNotify)
_gst_mpegts_atsc_mgt_table_free);
mgt->descriptors = g_ptr_array_new_with_free_func ((GDestroyNotify)
gst_mpegts_descriptor_free);
return mgt;
}
/* Multi string structure */
static GstMpegtsAtscStringSegment *
_gst_mpegts_atsc_string_segment_copy (GstMpegtsAtscStringSegment * seg)
{
GstMpegtsAtscStringSegment *copy;
copy = g_memdup2 (seg, sizeof (GstMpegtsAtscStringSegment));
return copy;
}
static void
_gst_mpegts_atsc_string_segment_free (GstMpegtsAtscStringSegment * seg)
{
g_free (seg->cached_string);
g_free (seg);
}
static void
_gst_mpegts_atsc_string_segment_decode_string (GstMpegtsAtscStringSegment * seg)
{
const gchar *from_encoding;
g_return_if_fail (seg->cached_string == NULL);
if (seg->compression_type != 0) {
GST_FIXME ("Compressed strings not yet supported");
return;
}
/* FIXME add more encodings */
switch (seg->mode) {
case 0x3F:
from_encoding = "UTF-16BE";
break;
default:
from_encoding = NULL;
break;
}
if (from_encoding != NULL && seg->compressed_data_size > 0) {
GError *err = NULL;
seg->cached_string =
g_convert ((gchar *) seg->compressed_data,
(gssize) seg->compressed_data_size, "UTF-8", from_encoding, NULL, NULL,
&err);
if (err) {
GST_WARNING ("Failed to convert input string from codeset %s",
from_encoding);
g_error_free (err);
}
} else {
seg->cached_string =
g_strndup ((gchar *) seg->compressed_data, seg->compressed_data_size);
}
}
const gchar *
gst_mpegts_atsc_string_segment_get_string (GstMpegtsAtscStringSegment * seg)
{
if (!seg->cached_string)
_gst_mpegts_atsc_string_segment_decode_string (seg);
return seg->cached_string;
}
gboolean
gst_mpegts_atsc_string_segment_set_string (GstMpegtsAtscStringSegment * seg,
gchar * string, guint8 compression_type, guint8 mode)
{
const gchar *to_encoding = NULL;
gboolean ret = FALSE;
gsize written;
GError *err = NULL;
unsigned long len;
if (compression_type) {
GST_FIXME ("Compressed strings not yet supported");
goto done;
}
switch (mode) {
case 0x3f:
to_encoding = "UTF-16BE";
break;
default:
break;
}
if (seg->cached_string)
g_free (seg->cached_string);
if (seg->compressed_data)
g_free (seg->compressed_data);
seg->cached_string = g_strdup (string);
seg->compression_type = compression_type;
seg->mode = mode;
len = strlen (string);
if (to_encoding && len) {
gchar *converted = g_convert (string, len, to_encoding, "UTF-8",
NULL, &written, &err);
if (err) {
GST_WARNING ("Failed to convert input string to codeset %s (%s)",
to_encoding, err->message);
g_error_free (err);
goto done;
}
seg->compressed_data = (guint8 *) g_strndup (converted, written);
seg->compressed_data_size = written;
g_free (converted);
} else {
seg->compressed_data = (guint8 *) g_strndup (string, len);
seg->compressed_data_size = len;
}
ret = TRUE;
done:
return ret;
}
G_DEFINE_BOXED_TYPE (GstMpegtsAtscStringSegment, gst_mpegts_atsc_string_segment,
(GBoxedCopyFunc) _gst_mpegts_atsc_string_segment_copy,
(GFreeFunc) _gst_mpegts_atsc_string_segment_free);
static GstMpegtsAtscMultString *
_gst_mpegts_atsc_mult_string_copy (GstMpegtsAtscMultString * mstring)
{
GstMpegtsAtscMultString *copy;
copy = g_memdup2 (mstring, sizeof (GstMpegtsAtscMultString));
copy->segments = g_ptr_array_ref (mstring->segments);
return copy;
}
static void
_gst_mpegts_atsc_mult_string_free (GstMpegtsAtscMultString * mstring)
{
g_ptr_array_unref (mstring->segments);
g_free (mstring);
}
G_DEFINE_BOXED_TYPE (GstMpegtsAtscMultString, gst_mpegts_atsc_mult_string,
(GBoxedCopyFunc) _gst_mpegts_atsc_mult_string_copy,
(GFreeFunc) _gst_mpegts_atsc_mult_string_free);
static GPtrArray *
_parse_atsc_mult_string (guint8 * data, guint datasize)
{
guint8 num_strings;
GPtrArray *res = NULL;
guint8 *end = data + datasize;
gint i;
if (datasize > 0) {
/* 1 is the minimum entry size, so no need to check here */
num_strings = GST_READ_UINT8 (data);
data += 1;
res =
g_ptr_array_new_full (num_strings,
(GDestroyNotify) _gst_mpegts_atsc_mult_string_free);
for (i = 0; i < num_strings; i++) {
GstMpegtsAtscMultString *mstring;
guint8 num_segments;
gint j;
mstring = g_new0 (GstMpegtsAtscMultString, 1);
g_ptr_array_add (res, mstring);
mstring->segments =
g_ptr_array_new_full (num_strings,
(GDestroyNotify) _gst_mpegts_atsc_string_segment_free);
/* each entry needs at least 4 bytes (lang code and segments number) */
if (end - data < 4) {
GST_WARNING ("Data too short for multstring parsing %d",
(gint) (end - data));
goto error;
}
mstring->iso_639_langcode[0] = GST_READ_UINT8 (data);
data += 1;
mstring->iso_639_langcode[1] = GST_READ_UINT8 (data);
data += 1;
mstring->iso_639_langcode[2] = GST_READ_UINT8 (data);
data += 1;
num_segments = GST_READ_UINT8 (data);
data += 1;
for (j = 0; j < num_segments; j++) {
GstMpegtsAtscStringSegment *seg;
seg = g_new0 (GstMpegtsAtscStringSegment, 1);
g_ptr_array_add (mstring->segments, seg);
/* each entry needs at least 3 bytes */
if (end - data < 3) {
GST_WARNING ("Data too short for multstring parsing %d", datasize);
goto error;
}
seg->compression_type = GST_READ_UINT8 (data);
data += 1;
seg->mode = GST_READ_UINT8 (data);
data += 1;
seg->compressed_data_size = GST_READ_UINT8 (data);
data += 1;
if (end - data < seg->compressed_data_size) {
GST_WARNING ("Data too short for multstring parsing %d", datasize);
goto error;
}
if (seg->compressed_data_size)
seg->compressed_data = data;
data += seg->compressed_data_size;
}
}
}
return res;
error:
if (res)
g_ptr_array_unref (res);
return NULL;
}
static void
_packetize_atsc_mult_string (GPtrArray * strings, guint8 ** data)
{
guint i;
if (strings == NULL)
return;
/* 8 bit number_strings */
GST_WRITE_UINT8 (*data, strings->len);
*data += 1;
for (i = 0; i < strings->len; i++) {
GstMpegtsAtscMultString *string;
guint j;
string = g_ptr_array_index (strings, i);
/* 24 bit ISO_639_langcode */
GST_WRITE_UINT8 (*data, string->iso_639_langcode[0]);
*data += 1;
GST_WRITE_UINT8 (*data, string->iso_639_langcode[1]);
*data += 1;
GST_WRITE_UINT8 (*data, string->iso_639_langcode[2]);
*data += 1;
/* 8 bit number_segments */
GST_WRITE_UINT8 (*data, string->segments->len);
*data += 1;
for (j = 0; j < string->segments->len; j++) {
GstMpegtsAtscStringSegment *seg;
seg = g_ptr_array_index (string->segments, j);
/* 8 bit compression_type */
GST_WRITE_UINT8 (*data, seg->compression_type);
*data += 1;
/* 8 bit mode */
GST_WRITE_UINT8 (*data, seg->mode);
*data += 1;
/* 8 bit number_bytes */
GST_WRITE_UINT8 (*data, seg->compressed_data_size);
*data += 1;
/* number_bytes compressed string */
memcpy (*data, seg->compressed_data, seg->compressed_data_size);
*data += seg->compressed_data_size;
}
}
}
static gsize
_get_atsc_mult_string_packetized_length (GPtrArray * strings)
{
gsize length = 1;
guint i;
for (i = 0; i < strings->len; i++) {
GstMpegtsAtscMultString *string;
guint j;
string = g_ptr_array_index (strings, i);
length += 4;
for (j = 0; j < string->segments->len; j++) {
GstMpegtsAtscStringSegment *seg;
seg = g_ptr_array_index (string->segments, j);
length += 3 + seg->compressed_data_size;
}
}
return length;
}
/* EIT */
static GstMpegtsAtscEITEvent *
_gst_mpegts_atsc_eit_event_copy (GstMpegtsAtscEITEvent * event)
{
GstMpegtsAtscEITEvent *copy;
copy = g_memdup2 (event, sizeof (GstMpegtsAtscEITEvent));
copy->titles = g_ptr_array_ref (event->titles);
copy->descriptors = g_ptr_array_ref (event->descriptors);
return copy;
}
static void
_gst_mpegts_atsc_eit_event_free (GstMpegtsAtscEITEvent * event)
{
if (event->titles)
g_ptr_array_unref (event->titles);
if (event->descriptors)
g_ptr_array_unref (event->descriptors);
g_free (event);
}
G_DEFINE_BOXED_TYPE (GstMpegtsAtscEITEvent, gst_mpegts_atsc_eit_event,
(GBoxedCopyFunc) _gst_mpegts_atsc_eit_event_copy,
(GFreeFunc) _gst_mpegts_atsc_eit_event_free);
static GstMpegtsAtscEIT *
_gst_mpegts_atsc_eit_copy (GstMpegtsAtscEIT * eit)
{
GstMpegtsAtscEIT *copy;
copy = g_memdup2 (eit, sizeof (GstMpegtsAtscEIT));
copy->events = g_ptr_array_ref (eit->events);
return copy;
}
static void
_gst_mpegts_atsc_eit_free (GstMpegtsAtscEIT * eit)
{
if (eit->events)
g_ptr_array_unref (eit->events);
g_free (eit);
}
G_DEFINE_BOXED_TYPE (GstMpegtsAtscEIT, gst_mpegts_atsc_eit,
(GBoxedCopyFunc) _gst_mpegts_atsc_eit_copy,
(GFreeFunc) _gst_mpegts_atsc_eit_free);
static gpointer
_parse_atsc_eit (GstMpegtsSection * section)
{
GstMpegtsAtscEIT *eit = NULL;
guint i = 0;
guint8 *data, *end;
guint8 num_events;
eit = g_new0 (GstMpegtsAtscEIT, 1);
data = section->data;
end = data + section->section_length;
eit->source_id = section->subtable_extension;
/* Skip already parsed data */
data += 8;
eit->protocol_version = GST_READ_UINT8 (data);
data += 1;
num_events = GST_READ_UINT8 (data);
data += 1;
eit->events = g_ptr_array_new_with_free_func ((GDestroyNotify)
_gst_mpegts_atsc_eit_event_free);
for (i = 0; i < num_events; i++) {
GstMpegtsAtscEITEvent *event;
guint32 tmp;
guint8 text_length;
guint16 descriptors_loop_length;
if (end - data < 12) {
GST_WARNING ("PID %d invalid EIT entry length %d with %u events",
section->pid, (gint) (end - 4 - data), num_events);
goto error;
}
event = g_new0 (GstMpegtsAtscEITEvent, 1);
g_ptr_array_add (eit->events, event);
event->event_id = GST_READ_UINT16_BE (data) & 0x3FFF;
data += 2;
event->start_time = GST_READ_UINT32_BE (data);
data += 4;
tmp = GST_READ_UINT32_BE (data);
data += 4;
event->etm_location = (tmp >> 28) & 0x3;
event->length_in_seconds = (tmp >> 8) & 0x0FFFFF;
text_length = tmp & 0xFF;
if (text_length > end - data - 4 - 2) {
GST_WARNING ("PID %d invalid EIT entry length %d with %u events",
section->pid, (gint) (end - 4 - data), num_events);
goto error;
}
event->titles = _parse_atsc_mult_string (data, text_length);
data += text_length;
descriptors_loop_length = GST_READ_UINT16_BE (data) & 0x0FFF;
data += 2;
if (end - data - 4 < descriptors_loop_length) {
GST_WARNING ("PID %d invalid EIT entry length %d with %u events",
section->pid, (gint) (end - 4 - data), num_events);
goto error;
}
event->descriptors =
gst_mpegts_parse_descriptors (data, descriptors_loop_length);
data += descriptors_loop_length;
}
if (data != end - 4) {
GST_WARNING ("PID %d invalid EIT parsed %d length %d",
section->pid, (gint) (data - section->data), section->section_length);
goto error;
}
return (gpointer) eit;
error:
_gst_mpegts_atsc_eit_free (eit);
return NULL;
}
/**
* gst_mpegts_section_get_atsc_eit:
* @section: a #GstMpegtsSection of type %GST_MPEGTS_SECTION_ATSC_EIT
*
* Returns the #GstMpegtsAtscEIT contained in the @section.
*
* Returns: The #GstMpegtsAtscEIT contained in the section, or %NULL if an error
* happened.
*/
const GstMpegtsAtscEIT *
gst_mpegts_section_get_atsc_eit (GstMpegtsSection * section)
{
g_return_val_if_fail (section->section_type == GST_MPEGTS_SECTION_ATSC_EIT,
NULL);
g_return_val_if_fail (section->cached_parsed || section->data, NULL);
if (!section->cached_parsed)
section->cached_parsed =
__common_section_checks (section, 14, _parse_atsc_eit,
(GDestroyNotify) _gst_mpegts_atsc_eit_free);
return (const GstMpegtsAtscEIT *) section->cached_parsed;
}
static GstMpegtsAtscETT *
_gst_mpegts_atsc_ett_copy (GstMpegtsAtscETT * ett)
{
GstMpegtsAtscETT *copy;
copy = g_memdup2 (ett, sizeof (GstMpegtsAtscETT));
copy->messages = g_ptr_array_ref (ett->messages);
return copy;
}
static void
_gst_mpegts_atsc_ett_free (GstMpegtsAtscETT * ett)
{
if (ett->messages)
g_ptr_array_unref (ett->messages);
g_free (ett);
}
G_DEFINE_BOXED_TYPE (GstMpegtsAtscETT, gst_mpegts_atsc_ett,
(GBoxedCopyFunc) _gst_mpegts_atsc_ett_copy,
(GFreeFunc) _gst_mpegts_atsc_ett_free);
static gpointer
_parse_ett (GstMpegtsSection * section)
{
GstMpegtsAtscETT *ett = NULL;
guint8 *data, *end;
ett = g_new0 (GstMpegtsAtscETT, 1);
data = section->data;
end = data + section->section_length;
ett->ett_table_id_extension = section->subtable_extension;
/* Skip already parsed data */
data += 8;
ett->protocol_version = GST_READ_UINT8 (data);
data += 1;
ett->etm_id = GST_READ_UINT32_BE (data);
data += 4;
ett->messages = _parse_atsc_mult_string (data, end - data - 4);
data += end - data - 4;
if (data != end - 4) {
GST_WARNING ("PID %d invalid ETT parsed %d length %d",
section->pid, (gint) (data - section->data), section->section_length);
goto error;
}
return (gpointer) ett;
error:
_gst_mpegts_atsc_ett_free (ett);
return NULL;
}
/**
* gst_mpegts_section_get_atsc_ett:
* @section: a #GstMpegtsSection of type %GST_MPEGTS_SECTION_ATSC_ETT
*
* Returns the #GstMpegtsAtscETT contained in the @section.
*
* Returns: The #GstMpegtsAtscETT contained in the section, or %NULL if an error
* happened.
*/
const GstMpegtsAtscETT *
gst_mpegts_section_get_atsc_ett (GstMpegtsSection * section)
{
g_return_val_if_fail (section->section_type == GST_MPEGTS_SECTION_ATSC_ETT,
NULL);
g_return_val_if_fail (section->cached_parsed || section->data, NULL);
if (!section->cached_parsed)
section->cached_parsed = __common_section_checks (section, 17, _parse_ett,
(GDestroyNotify) _gst_mpegts_atsc_ett_free);
return (const GstMpegtsAtscETT *) section->cached_parsed;
}
/* STT */
static GstMpegtsAtscSTT *
_gst_mpegts_atsc_stt_copy (GstMpegtsAtscSTT * stt)
{
GstMpegtsAtscSTT *copy;
copy = g_memdup2 (stt, sizeof (GstMpegtsAtscSTT));
copy->descriptors = g_ptr_array_ref (stt->descriptors);
return copy;
}
static void
_gst_mpegts_atsc_stt_free (GstMpegtsAtscSTT * stt)
{
if (stt->descriptors)
g_ptr_array_unref (stt->descriptors);
if (stt->utc_datetime)
gst_date_time_unref (stt->utc_datetime);
g_free (stt);
}
G_DEFINE_BOXED_TYPE (GstMpegtsAtscSTT, gst_mpegts_atsc_stt,
(GBoxedCopyFunc) _gst_mpegts_atsc_stt_copy,
(GFreeFunc) _gst_mpegts_atsc_stt_free);
static gpointer
_parse_atsc_stt (GstMpegtsSection * section)
{
GstMpegtsAtscSTT *stt = NULL;
guint8 *data, *end;
guint16 daylight_saving;
stt = g_new0 (GstMpegtsAtscSTT, 1);
data = section->data;
end = data + section->section_length;
/* Skip already parsed data */
data += 8;
stt->protocol_version = GST_READ_UINT8 (data);
data += 1;
stt->system_time = GST_READ_UINT32_BE (data);
data += 4;
stt->gps_utc_offset = GST_READ_UINT8 (data);
data += 1;
daylight_saving = GST_READ_UINT16_BE (data);
data += 2;
stt->ds_status = daylight_saving >> 15;
stt->ds_dayofmonth = (daylight_saving >> 8) & 0x1F;
stt->ds_hour = daylight_saving & 0xFF;
stt->descriptors = gst_mpegts_parse_descriptors (data, end - data - 4);
if (stt->descriptors == NULL)
goto error;
return (gpointer) stt;
error:
_gst_mpegts_atsc_stt_free (stt);
return NULL;
}
static gboolean
_packetize_stt (GstMpegtsSection * section)
{
const GstMpegtsAtscSTT *stt;
guint8 *data;
gsize length;
guint i;
stt = gst_mpegts_section_get_atsc_stt (section);
if (stt == NULL)
return FALSE;
/* 8 byte common section fields
* 1 byte protocol version
* 4 byte system time
* 1 byte GPS_UTC_offset
* 2 byte daylight saving
* 4 byte CRC
*/
length = 20;
if (stt->descriptors) {
for (i = 0; i < stt->descriptors->len; i++) {
GstMpegtsDescriptor *descriptor = g_ptr_array_index (stt->descriptors, i);
length += descriptor->length + 2;
}
}
_packetize_common_section (section, length);
data = section->data + 8;
/* protocol_version - 8 bit */
GST_WRITE_UINT8 (data, stt->protocol_version);
data += 1;
/* system time - 32 bit uimsbf */
GST_WRITE_UINT32_BE (data, stt->system_time);
data += 4;
/* GPS_UTC_offset - 8 bit */
GST_WRITE_UINT8 (data, stt->gps_utc_offset);
data += 1;
/* daylight_saving - 16 bit uimsbf */
GST_WRITE_UINT8 (data,
(stt->ds_status << 7) | 0x60 | (stt->ds_dayofmonth & 0x1f));
data += 1;
GST_WRITE_UINT8 (data, stt->ds_hour);
data += 1;
_packetize_descriptor_array (stt->descriptors, &data);
return TRUE;
}
/**
* gst_mpegts_section_section_from_atsc_stt:
* @stt: (transfer full): a #GstMpegtsAtscSTT to create the #GstMpegtsSection from
*
* Returns: (transfer full): the #GstMpegtsSection
* Since: 1.18
*/
GstMpegtsSection *
gst_mpegts_section_from_atsc_stt (GstMpegtsAtscSTT * stt)
{
GstMpegtsSection *section;
g_return_val_if_fail (stt != NULL, NULL);
section = _gst_mpegts_section_init (0x1ffb,
GST_MTS_TABLE_ID_ATSC_SYSTEM_TIME);
section->subtable_extension = 0x0000;
section->cached_parsed = (gpointer) stt;
section->packetizer = _packetize_stt;
section->destroy_parsed = (GDestroyNotify) _gst_mpegts_atsc_stt_free;
return section;
}
/**
* gst_mpegts_section_get_atsc_stt:
* @section: a #GstMpegtsSection of type %GST_MPEGTS_SECTION_ATSC_STT
*
* Returns the #GstMpegtsAtscSTT contained in the @section.
*
* Returns: The #GstMpegtsAtscSTT contained in the section, or %NULL if an error
* happened.
*/
const GstMpegtsAtscSTT *
gst_mpegts_section_get_atsc_stt (GstMpegtsSection * section)
{
g_return_val_if_fail (section->section_type == GST_MPEGTS_SECTION_ATSC_STT,
NULL);
g_return_val_if_fail (section->cached_parsed || section->data, NULL);
if (!section->cached_parsed)
section->cached_parsed =
__common_section_checks (section, 20, _parse_atsc_stt,
(GDestroyNotify) _gst_mpegts_atsc_stt_free);
return (const GstMpegtsAtscSTT *) section->cached_parsed;
}
/**
* gst_mpegts_section_atsc_stt_new:
*
* Returns: (transfer full): #GstMpegtsAtscSTT
* Since: 1.18
*/
GstMpegtsAtscSTT *
gst_mpegts_atsc_stt_new (void)
{
GstMpegtsAtscSTT *stt;
stt = g_new0 (GstMpegtsAtscSTT, 1);
stt->descriptors = g_ptr_array_new_with_free_func ((GDestroyNotify)
gst_mpegts_descriptor_free);
return stt;
}
#define GPS_TO_UTC_TICKS G_GINT64_CONSTANT(315964800)
static GstDateTime *
_gst_mpegts_atsc_gps_time_to_datetime (guint32 systemtime, guint8 gps_offset)
{
return gst_date_time_new_from_unix_epoch_utc (systemtime - gps_offset +
GPS_TO_UTC_TICKS);
}
GstDateTime *
gst_mpegts_atsc_stt_get_datetime_utc (GstMpegtsAtscSTT * stt)
{
if (stt->utc_datetime == NULL)
stt->utc_datetime = _gst_mpegts_atsc_gps_time_to_datetime (stt->system_time,
stt->gps_utc_offset);
if (stt->utc_datetime)
return gst_date_time_ref (stt->utc_datetime);
return NULL;
}
/* RRT */
static GstMpegtsAtscRRTDimensionValue *
_gst_mpegts_atsc_rrt_dimension_value_copy (GstMpegtsAtscRRTDimensionValue *
value)
{
GstMpegtsAtscRRTDimensionValue *copy;
copy = g_memdup2 (value, sizeof (GstMpegtsAtscRRTDimensionValue));
copy->abbrev_ratings = g_ptr_array_ref (value->abbrev_ratings);
copy->ratings = g_ptr_array_ref (value->ratings);
return copy;
}
static void
_gst_mpegts_atsc_rrt_dimension_value_free (GstMpegtsAtscRRTDimensionValue *
value)
{
if (value->abbrev_ratings)
g_ptr_array_unref (value->abbrev_ratings);
if (value->ratings)
g_ptr_array_unref (value->ratings);
g_free (value);
}
G_DEFINE_BOXED_TYPE (GstMpegtsAtscRRTDimensionValue,
gst_mpegts_atsc_rrt_dimension_value,
(GBoxedCopyFunc) _gst_mpegts_atsc_rrt_dimension_value_copy,
(GFreeFunc) _gst_mpegts_atsc_rrt_dimension_value_free);
static GstMpegtsAtscRRTDimension *
_gst_mpegts_atsc_rrt_dimension_copy (GstMpegtsAtscRRTDimension * dim)
{
GstMpegtsAtscRRTDimension *copy;
copy = g_memdup2 (dim, sizeof (GstMpegtsAtscRRTDimension));
copy->names = g_ptr_array_ref (dim->names);
copy->values = g_ptr_array_ref (dim->values);
return copy;
}
static void
_gst_mpegts_atsc_rrt_dimension_free (GstMpegtsAtscRRTDimension * dim)
{
if (dim->names)
g_ptr_array_unref (dim->names);
if (dim->values)
g_ptr_array_unref (dim->values);
g_free (dim);
}
G_DEFINE_BOXED_TYPE (GstMpegtsAtscRRTDimension, gst_mpegts_atsc_rrt_dimension,
(GBoxedCopyFunc) _gst_mpegts_atsc_rrt_dimension_copy,
(GFreeFunc) _gst_mpegts_atsc_rrt_dimension_free);
static GstMpegtsAtscRRT *
_gst_mpegts_atsc_rrt_copy (GstMpegtsAtscRRT * rrt)
{
GstMpegtsAtscRRT *copy;
copy = g_memdup2 (rrt, sizeof (GstMpegtsAtscRRT));
copy->names = g_ptr_array_ref (rrt->names);
copy->dimensions = g_ptr_array_ref (rrt->dimensions);
copy->descriptors = g_ptr_array_ref (rrt->descriptors);
return copy;
}
static void
_gst_mpegts_atsc_rrt_free (GstMpegtsAtscRRT * rrt)
{
if (rrt->names)
g_ptr_array_unref (rrt->names);
if (rrt->dimensions)
g_ptr_array_unref (rrt->dimensions);
if (rrt->descriptors)
g_ptr_array_unref (rrt->descriptors);
g_free (rrt);
}
G_DEFINE_BOXED_TYPE (GstMpegtsAtscRRT, gst_mpegts_atsc_rrt,
(GBoxedCopyFunc) _gst_mpegts_atsc_rrt_copy,
(GFreeFunc) _gst_mpegts_atsc_rrt_free);
static gpointer
_parse_rrt (GstMpegtsSection * section)
{
GstMpegtsAtscRRT *rrt = NULL;
guint i = 0;
guint8 *data;
guint16 descriptors_loop_length;
guint8 text_length;
rrt = g_new0 (GstMpegtsAtscRRT, 1);
data = section->data;
/* Skip already parsed data */
data += 8;
rrt->protocol_version = GST_READ_UINT8 (data);
data += 1;
text_length = GST_READ_UINT8 (data);
data += 1;
rrt->names = _parse_atsc_mult_string (data, text_length);
data += text_length;
rrt->dimensions_defined = GST_READ_UINT8 (data);
data += 1;
rrt->dimensions = g_ptr_array_new_full (rrt->dimensions_defined,
(GDestroyNotify) _gst_mpegts_atsc_rrt_dimension_free);
for (i = 0; i < rrt->dimensions_defined; i++) {
GstMpegtsAtscRRTDimension *dim;
guint8 tmp;
guint j = 0;
dim = g_new0 (GstMpegtsAtscRRTDimension, 1);
g_ptr_array_add (rrt->dimensions, dim);
text_length = GST_READ_UINT8 (data);
data += 1;
dim->names = _parse_atsc_mult_string (data, text_length);
data += text_length;
tmp = GST_READ_UINT8 (data);
data += 1;
dim->graduated_scale = tmp & 0x10;
dim->values_defined = tmp & 0x0f;
dim->values = g_ptr_array_new_full (dim->values_defined,
(GDestroyNotify) _gst_mpegts_atsc_rrt_dimension_value_free);
for (j = 0; j < dim->values_defined; j++) {
GstMpegtsAtscRRTDimensionValue *val;
val = g_new0 (GstMpegtsAtscRRTDimensionValue, 1);
g_ptr_array_add (dim->values, val);
text_length = GST_READ_UINT8 (data);
data += 1;
val->abbrev_ratings = _parse_atsc_mult_string (data, text_length);
data += text_length;
text_length = GST_READ_UINT8 (data);
data += 1;
val->ratings = _parse_atsc_mult_string (data, text_length);
data += text_length;
}
}
descriptors_loop_length = GST_READ_UINT16_BE (data) & 0x3FF;
data += 2;
rrt->descriptors =
gst_mpegts_parse_descriptors (data, descriptors_loop_length);
return (gpointer) rrt;
}
static gboolean
_packetize_rrt (GstMpegtsSection * section)
{
const GstMpegtsAtscRRT *rrt;
guint8 *data, *pos;
gsize length;
gsize names_length;
guint i, j;
rrt = gst_mpegts_section_get_atsc_rrt (section);
if (rrt == NULL)
return FALSE;
names_length = _get_atsc_mult_string_packetized_length (rrt->names);
/* 8 byte common section fields
* 1 byte protocol version
* 1 byte rating_region_name_length
* name_length bytes
* 1 byte dimensions_defined
* 2 byte reserved / descriptors_length
* 4 byte CRC
*/
length = names_length + 17;
for (i = 0; i < rrt->dimensions->len; i++) {
GstMpegtsAtscRRTDimension *dim = g_ptr_array_index (rrt->dimensions, i);
/* 1 byte dimension_name_length
* 1 byte reserved / graduated_scale / values_defined
*/
length += 2;
length += _get_atsc_mult_string_packetized_length (dim->names);
for (j = 0; j < dim->values->len; j++) {
GstMpegtsAtscRRTDimensionValue *val = g_ptr_array_index (dim->values, j);
/* 1 byte abbrev_rating_value_length
* 1 byte rating_value_length
*/
length += 2;
length += _get_atsc_mult_string_packetized_length (val->abbrev_ratings);
length += _get_atsc_mult_string_packetized_length (val->ratings);
}
}
if (rrt->descriptors) {
for (i = 0; i < rrt->descriptors->len; i++) {
GstMpegtsDescriptor *descriptor = g_ptr_array_index (rrt->descriptors, i);
length += descriptor->length + 2;
}
}
if (length > 1024) {
GST_WARNING ("RRT size can not exceed 1024");
return FALSE;
}
_packetize_common_section (section, length);
data = section->data + 8;
/* protocol_version - 8 bit */
GST_WRITE_UINT8 (data, rrt->protocol_version);
data += 1;
/* rating_region_name_length - 8 bit */
GST_WRITE_UINT8 (data, names_length);
data += 1;
_packetize_atsc_mult_string (rrt->names, &data);
for (i = 0; i < rrt->dimensions->len; i++) {
GstMpegtsAtscRRTDimension *dim = g_ptr_array_index (rrt->dimensions, i);
/* dimension_name_length - 8 bit */
GST_WRITE_UINT8 (data,
_get_atsc_mult_string_packetized_length (dim->names));
data += 1;
_packetize_atsc_mult_string (rrt->names, &data);
/* 3 bit reserved / 1 bit graduated_scale / 4 bit values_defined */
GST_WRITE_UINT8 (data,
0xe0 | ((dim->graduated_scale ? 1 : 0) << 4) | (dim->
values_defined & 0x0f));
data += 1;
for (j = 0; j < dim->values->len; j++) {
GstMpegtsAtscRRTDimensionValue *val = g_ptr_array_index (dim->values, j);
/* abbrev_rating_value_length - 8 bit */
GST_WRITE_UINT8 (data,
_get_atsc_mult_string_packetized_length (val->abbrev_ratings));
data += 1;
_packetize_atsc_mult_string (val->abbrev_ratings, &data);
/* rating_value_length - 8 bit */
GST_WRITE_UINT8 (data,
_get_atsc_mult_string_packetized_length (val->ratings));
data += 1;
_packetize_atsc_mult_string (val->ratings, &data);
}
}
/* 6 bit reserved, 10 bit descriptor_length uimsbf */
pos = data;
*data++ = 0xFC;
*data++ = 0x00;
_packetize_descriptor_array (rrt->descriptors, &data);
/* Go back and update the descriptor length */
GST_WRITE_UINT16_BE (pos, (data - pos - 2) | 0xFC00);
return TRUE;
}
/**
* gst_mpegts_section_section_from_atsc_rrt:
* @rrt: (transfer full): a #GstMpegtsAtscRRT to create the #GstMpegtsSection from
*
* Returns: (transfer full): the #GstMpegtsSection
* Since: 1.18
*/
GstMpegtsSection *
gst_mpegts_section_from_atsc_rrt (GstMpegtsAtscRRT * rrt)
{
GstMpegtsSection *section;
g_return_val_if_fail (rrt != NULL, NULL);
section = _gst_mpegts_section_init (0x1ffb,
GST_MTS_TABLE_ID_ATSC_RATING_REGION);
/* FIXME random rating_region, what should be the default? */
section->subtable_extension = 0xff01;
section->cached_parsed = (gpointer) rrt;
section->packetizer = _packetize_rrt;
section->destroy_parsed = (GDestroyNotify) _gst_mpegts_atsc_rrt_free;
return section;
}
/**
* gst_mpegts_section_get_atsc_rrt:
* @section: a #GstMpegtsSection of type %GST_MPEGTS_SECTION_ATSC_RRT
*
* Returns the #GstMpegtsAtscRRT contained in the @section.
*
* Returns: The #GstMpegtsAtscRRT contained in the section, or %NULL if an error
* happened.
* Since: 1.18
*/
const GstMpegtsAtscRRT *
gst_mpegts_section_get_atsc_rrt (GstMpegtsSection * section)
{
g_return_val_if_fail (section->section_type == GST_MPEGTS_SECTION_ATSC_RRT,
NULL);
g_return_val_if_fail (section->cached_parsed || section->data, NULL);
if (!section->cached_parsed)
section->cached_parsed =
__common_section_checks (section, 17, _parse_rrt,
(GDestroyNotify) _gst_mpegts_atsc_rrt_free);
return (const GstMpegtsAtscRRT *) section->cached_parsed;
}
/**
* gst_mpegts_section_atsc_rrt_dimension_value_new:
*
* Returns: (transfer full): #GstMpegtsAtscRRTDimensionValue
* Since: 1.18
*/
GstMpegtsAtscRRTDimensionValue *
gst_mpegts_atsc_rrt_dimension_value_new (void)
{
GstMpegtsAtscRRTDimensionValue *val;
val = g_new0 (GstMpegtsAtscRRTDimensionValue, 1);
val->abbrev_ratings = g_ptr_array_new_with_free_func ((GDestroyNotify)
_gst_mpegts_atsc_mult_string_free);
val->ratings = g_ptr_array_new_with_free_func ((GDestroyNotify)
_gst_mpegts_atsc_mult_string_free);
return val;
}
/**
* gst_mpegts_section_atsc_rrt_dimension_new:
*
* Returns: (transfer full): #GstMpegtsAtscRRTDimension
* Since: 1.18
*/
GstMpegtsAtscRRTDimension *
gst_mpegts_atsc_rrt_dimension_new (void)
{
GstMpegtsAtscRRTDimension *dim;
dim = g_new0 (GstMpegtsAtscRRTDimension, 1);
dim->names = g_ptr_array_new_with_free_func ((GDestroyNotify)
_gst_mpegts_atsc_mult_string_free);
dim->values = g_ptr_array_new_with_free_func ((GDestroyNotify)
_gst_mpegts_atsc_rrt_dimension_value_free);
return dim;
}
/**
* gst_mpegts_section_atsc_rrt_new:
*
* Returns: (transfer full): #GstMpegtsAtscRRT
* Since: 1.18
*/
GstMpegtsAtscRRT *
gst_mpegts_atsc_rrt_new (void)
{
GstMpegtsAtscRRT *rrt;
rrt = g_new0 (GstMpegtsAtscRRT, 1);
rrt->names = g_ptr_array_new_with_free_func ((GDestroyNotify)
_gst_mpegts_atsc_mult_string_free);
rrt->dimensions = g_ptr_array_new_with_free_func ((GDestroyNotify)
_gst_mpegts_atsc_rrt_dimension_free);
rrt->descriptors = g_ptr_array_new_with_free_func ((GDestroyNotify)
gst_mpegts_descriptor_free);
return rrt;
}