mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-20 23:36:38 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/subprojects/gst-plugins-bad/gst/dvbsubenc/gstdvbsubenc-util.c

802 lines
24 KiB
C
Raw Blame History

/* GStreamer
* Copyright (C) <2020> Jan Schmidt <jan@centricular.com>
*
* 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.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdlib.h>
//#define HACK_2BIT /* Force 2-bit output by discarding colours */
//#define HACK_4BIT /* Force 4-bit output by discarding colours */
#include "gstdvbsubenc.h"
#include <gst/base/gstbytewriter.h>
#include <gst/base/gstbitwriter.h>
#include "libimagequant/libimagequant.h"
#define DVB_SEGMENT_SYNC_BYTE 0xF
enum DVBSegmentType
{
DVB_SEGMENT_TYPE_PAGE_COMPOSITION = 0x10,
DVB_SEGMENT_TYPE_REGION_COMPOSITION = 0x11,
DVB_SEGMENT_TYPE_CLUT_DEFINITION = 0x12,
DVB_SEGMENT_TYPE_OBJECT_DATA = 0x13,
DVB_SEGMENT_TYPE_DISPLAY_DEFINITION = 0x14,
DVB_SEGMENT_TYPE_END_OF_DISPLAY = 0x80
};
enum DVBPixelDataType
{
DVB_PIXEL_DATA_TYPE_2BIT = 0x10,
DVB_PIXEL_DATA_TYPE_4BIT = 0x11,
DVB_PIXEL_DATA_TYPE_8BIT = 0x12,
DVB_PIXEL_DATA_TYPE_END_OF_LINE = 0xF0
};
struct HistogramEntry
{
guint32 colour;
guint32 count;
guint32 substitution;
};
struct ColourEntry
{
guint32 colour;
guint32 pix_index;
};
typedef struct HistogramEntry HistogramEntry;
typedef struct ColourEntry ColourEntry;
static gint
compare_uint32 (gconstpointer a, gconstpointer b)
{
guint32 v1 = *(guint32 *) (a);
guint32 v2 = *(guint32 *) (b);
if (v1 < v2)
return -1;
if (v1 > v2)
return 1;
return 0;
}
static gint
compare_colour_entry_colour (gconstpointer a, gconstpointer b)
{
const ColourEntry *c1 = (ColourEntry *) (a);
const ColourEntry *c2 = (ColourEntry *) (b);
/* Reverse order, so highest alpha comes first: */
return compare_uint32 (&c2->colour, &c1->colour);
}
static void
image_get_rgba_row_callback (liq_color row_out[], int row_index, int width,
void *user_info)
{
int column_index;
GstVideoFrame *src = (GstVideoFrame *) (user_info);
guint8 *src_pixels = (guint8 *) (src->data[0]);
const guint32 src_stride = GST_VIDEO_INFO_PLANE_STRIDE (&src->info, 0);
guint8 *src_row = src_pixels + (row_index * src_stride);
gint offset = 0;
for (column_index = 0; column_index < width; column_index++) {
liq_color *col = row_out + column_index;
guint8 *p = src_row + offset;
/* FIXME: We pass AYUV into the ARGB colour values,
* which works but probably makes suboptimal choices about
* which colours to preserve. It would be better to convert to RGBA
* and back again, or to modify libimagequant to handle ayuv */
col->a = p[0];
col->r = p[1];
col->g = p[2];
col->b = p[3];
offset += 4;
}
}
/*
* Utility function to unintelligently extract a
* (max) 256 colour image from an AYUV input
* Dumb for now, but could be improved if needed. If there's
* more than 256 colours in the input, it will reduce it 256
* by taking the most common 255 colours + transparent and mapping all
* remaining colours to the nearest neighbour.
*
* FIXME: Integrate a better palette selection algorithm.
*/
gboolean
gst_dvbsubenc_ayuv_to_ayuv8p (GstVideoFrame * src, GstVideoFrame * dest,
int max_colours, guint32 * out_num_colours)
{
/* Allocate a temporary array the size of the input frame, copy in
* the source pixels, sort them by value and then count the first
* up to 256 colours. */
gboolean ret = FALSE;
GArray *colours, *histogram;
gint i, num_pixels, dest_y_index, out_index;
guint num_colours, cur_count;
guint32 last;
guint8 *s;
HistogramEntry *h;
ColourEntry *c;
const guint32 src_stride = GST_VIDEO_INFO_PLANE_STRIDE (&src->info, 0);
const guint32 dest_stride = GST_VIDEO_INFO_PLANE_STRIDE (&dest->info, 0);
if (GST_VIDEO_INFO_FORMAT (&src->info) != GST_VIDEO_FORMAT_AYUV)
return FALSE;
if (GST_VIDEO_INFO_WIDTH (&src->info) != GST_VIDEO_INFO_WIDTH (&dest->info) ||
GST_VIDEO_INFO_HEIGHT (&src->info) != GST_VIDEO_INFO_HEIGHT (&dest->info))
return FALSE;
num_pixels =
GST_VIDEO_INFO_WIDTH (&src->info) * GST_VIDEO_INFO_HEIGHT (&src->info);
s = (guint8 *) (src->data[0]);
colours = g_array_sized_new (FALSE, FALSE, sizeof (ColourEntry), num_pixels);
colours = g_array_set_size (colours, num_pixels);
histogram =
g_array_sized_new (FALSE, TRUE, sizeof (HistogramEntry), num_pixels);
histogram = g_array_set_size (histogram, num_pixels);
/* Copy the pixels to an array we can sort, dropping any stride padding,
* and recording the output index into the destination bitmap in the
* pix_index field */
dest_y_index = 0;
out_index = 0;
for (i = 0; i < GST_VIDEO_INFO_HEIGHT (&src->info); i++) {
guint32 x_index;
gint x;
for (x = 0, x_index = 0; x < GST_VIDEO_INFO_WIDTH (&src->info);
x++, x_index += 4) {
guint8 *pix = s + x_index;
c = &g_array_index (colours, ColourEntry, out_index);
c->colour = GST_READ_UINT32_BE (pix);
c->pix_index = dest_y_index + x;
out_index++;
}
s += src_stride;
dest_y_index += dest_stride;
}
/* Build a histogram of the highest colour counts: */
g_array_sort (colours, compare_colour_entry_colour);
c = &g_array_index (colours, ColourEntry, 0);
last = c->colour;
num_colours = 0;
cur_count = 1;
for (i = 1; i < num_pixels; i++) {
ColourEntry *c = &g_array_index (colours, ColourEntry, i);
guint32 cur = c->colour;
if (cur == last) {
cur_count++;
continue;
}
/* Colour changed - add an entry to the histogram */
h = &g_array_index (histogram, HistogramEntry, num_colours);
h->colour = last;
h->count = cur_count;
num_colours++;
cur_count = 1;
last = cur;
}
h = &g_array_index (histogram, HistogramEntry, num_colours);
h->colour = last;
h->count = cur_count;
num_colours++;
GST_LOG ("image has %u colours", num_colours);
histogram = g_array_set_size (histogram, num_colours);
if (num_colours > max_colours) {
liq_image *image;
liq_result *res;
const liq_palette *pal;
int i;
int height = GST_VIDEO_INFO_HEIGHT (&src->info);
unsigned char **dest_rows = malloc (height * sizeof (void *));
guint8 *dest_palette = (guint8 *) (dest->data[1]);
liq_attr *attr = liq_attr_create ();
gint out_index = 0;
for (i = 0; i < height; i++) {
dest_rows[i] = (guint8 *) (dest->data[0]) + i * dest_stride;
}
liq_set_max_colors (attr, max_colours);
image = liq_image_create_custom (attr, image_get_rgba_row_callback, src,
GST_VIDEO_INFO_WIDTH (&src->info), GST_VIDEO_INFO_HEIGHT (&src->info),
0);
res = liq_quantize_image (attr, image);
liq_write_remapped_image_rows (res, image, dest_rows);
pal = liq_get_palette (res);
num_colours = pal->count;
/* Write out the palette */
for (i = 0; i < num_colours; i++) {
guint8 *c = dest_palette + out_index;
const liq_color *col = pal->entries + i;
c[0] = col->a;
c[1] = col->r;
c[2] = col->g;
c[3] = col->b;
out_index += 4;
}
free (dest_rows);
liq_attr_destroy (attr);
liq_image_destroy (image);
liq_result_destroy (res);
} else {
guint8 *d = (guint8 *) (dest->data[0]);
guint8 *palette = (guint8 *) (dest->data[1]);
gint out_index = 0;
/* Write out the palette */
for (i = 0; i < num_colours; i++) {
h = &g_array_index (histogram, HistogramEntry, i);
GST_WRITE_UINT32_BE (palette + out_index, h->colour);
out_index += 4;
}
/* Write out the palette image. At this point, both the
* colours and histogram arrays are sorted in descending AYUV value,
* so walk them both and write out the current palette index */
out_index = 0;
for (i = 0; i < num_pixels; i++) {
c = &g_array_index (colours, ColourEntry, i);
h = &g_array_index (histogram, HistogramEntry, out_index);
if (c->colour != h->colour) {
out_index++;
h = &g_array_index (histogram, HistogramEntry, out_index);
g_assert (h->colour == c->colour); /* We must be walking colours in the same order in both arrays */
}
d[c->pix_index] = out_index;
}
}
ret = TRUE;
if (out_num_colours)
*out_num_colours = num_colours;
g_array_free (colours, TRUE);
g_array_free (histogram, TRUE);
return ret;
}
typedef void (*EncodeRLEFunc) (GstByteWriter * b, const guint8 * pixels,
const gint stride, const gint w, const gint h);
static void
encode_rle2 (GstByteWriter * b, const guint8 * pixels,
const gint stride, const gint w, const gint h)
{
GstBitWriter bits;
int y;
gst_bit_writer_init (&bits);
for (y = 0; y < h; y++) {
int x = 0;
guint size;
gst_byte_writer_put_uint8 (b, DVB_PIXEL_DATA_TYPE_2BIT);
while (x < w) {
int x_end = x;
int run_length;
guint8 pix;
pix = pixels[x_end++];
while (x_end < w && pixels[x_end] == pix)
x_end++;
#ifdef HACK_2BIT
pix >>= 6; /* HACK to convert 8 bit to 2 bit palette */
#endif
/* 284 is the largest run length we can encode */
run_length = MIN (x_end - x, 284);
if (run_length >= 29) {
/* 000011LLLL = run 29 to 284 pixels */
if (run_length > 284)
run_length = 284;
gst_bit_writer_put_bits_uint8 (&bits, 0x03, 6);
gst_bit_writer_put_bits_uint8 (&bits, run_length - 29, 8);
gst_bit_writer_put_bits_uint8 (&bits, pix, 2);
} else if (run_length >= 12 && run_length <= 27) {
/* 000010LLLL = run 12 to 27 pixels */
gst_bit_writer_put_bits_uint8 (&bits, 0x02, 6);
gst_bit_writer_put_bits_uint8 (&bits, run_length - 12, 4);
gst_bit_writer_put_bits_uint8 (&bits, pix, 2);
} else if (run_length >= 3 && run_length <= 10) {
/* 001LL = run 3 to 10 pixels */
gst_bit_writer_put_bits_uint8 (&bits, 0, 2);
gst_bit_writer_put_bits_uint8 (&bits, 0x8 + run_length - 3, 4);
gst_bit_writer_put_bits_uint8 (&bits, pix, 2);
}
/* Missed cases - 11 pixels, 28 pixels or a short length 1 or 2 pixels
* - write out a single pixel if != 0, or 1 or 2 pixels of black */
else if (pix != 0) {
gst_bit_writer_put_bits_uint8 (&bits, pix, 2);
run_length = 1;
} else if (run_length == 2) {
/* 0000 01 - 2 pixels colour 0 */
gst_bit_writer_put_bits_uint8 (&bits, 0x1, 6);
run_length = 2;
} else {
/* 0001 - single pixel colour 0 */
gst_bit_writer_put_bits_uint8 (&bits, 0x1, 4);
run_length = 1;
}
x += run_length;
GST_LOG ("%u pixels = colour %u", run_length, pix);
}
/* End of line 0x00 */
gst_bit_writer_put_bits_uint8 (&bits, 0x00, 8);
/* pad by 4 bits if needed to byte align, then
* write bit string to output */
gst_bit_writer_align_bytes (&bits, 0);
size = gst_bit_writer_get_size (&bits);
gst_byte_writer_put_data (b, gst_bit_writer_get_data (&bits), size / 8);
gst_bit_writer_reset (&bits);
gst_bit_writer_init (&bits);
GST_LOG ("y %u 2-bit RLE string = %u bits", y, size);
gst_byte_writer_put_uint8 (b, DVB_PIXEL_DATA_TYPE_END_OF_LINE);
pixels += stride;
}
}
static void
encode_rle4 (GstByteWriter * b, const guint8 * pixels,
const gint stride, const gint w, const gint h)
{
GstBitWriter bits;
int y;
gst_bit_writer_init (&bits);
for (y = 0; y < h; y++) {
int x = 0;
guint size;
gst_byte_writer_put_uint8 (b, DVB_PIXEL_DATA_TYPE_4BIT);
while (x < w) {
int x_end = x;
int run_length;
guint8 pix;
pix = pixels[x_end++];
while (x_end < w && pixels[x_end] == pix)
x_end++;
/* 280 is the largest run length we can encode */
run_length = MIN (x_end - x, 280);
GST_LOG ("Encoding run %u pixels = colour %u", run_length, pix);
#ifdef HACK_4BIT
pix >>= 4; /* HACK to convert 8 bit to 4 palette */
#endif
if (pix == 0 && run_length >= 3 && run_length <= 9) {
gst_bit_writer_put_bits_uint8 (&bits, 0, 4);
gst_bit_writer_put_bits_uint8 (&bits, run_length - 2, 4);
} else if (run_length >= 4 && run_length < 25) {
/* 4 to 7 pixels encoding */
if (run_length > 7)
run_length = 7;
gst_bit_writer_put_bits_uint8 (&bits, 0, 4);
gst_bit_writer_put_bits_uint8 (&bits, 0x8 + run_length - 4, 4);
gst_bit_writer_put_bits_uint8 (&bits, pix, 4);
} else if (run_length >= 25) {
/* Run length 25 to 280 pixels */
if (run_length > 280)
run_length = 280;
gst_bit_writer_put_bits_uint8 (&bits, 0x0f, 8);
gst_bit_writer_put_bits_uint8 (&bits, run_length - 25, 8);
gst_bit_writer_put_bits_uint8 (&bits, pix, 4);
}
/* Short length, 1, 2 or 3 pixels - write out a single pixel if != 0,
* or 1 or 2 pixels of black */
else if (pix != 0) {
gst_bit_writer_put_bits_uint8 (&bits, pix, 4);
run_length = 1;
} else if (run_length > 1) {
/* 0000 1101 */
gst_bit_writer_put_bits_uint8 (&bits, 0xd, 8);
run_length = 2;
} else {
/* 0000 1100 */
gst_bit_writer_put_bits_uint8 (&bits, 0xc, 8);
run_length = 1;
}
x += run_length;
GST_LOG ("Put %u pixels = colour %u", run_length, pix);
}
/* End of line 0x00 */
gst_bit_writer_put_bits_uint8 (&bits, 0x00, 8);
/* pad by 4 bits if needed to byte align, then
* write bit string to output */
gst_bit_writer_align_bytes (&bits, 0);
size = gst_bit_writer_get_size (&bits);
gst_byte_writer_put_data (b, gst_bit_writer_get_data (&bits), size / 8);
gst_bit_writer_reset (&bits);
gst_bit_writer_init (&bits);
GST_LOG ("y %u 4-bit RLE string = %u bits", y, size);
gst_byte_writer_put_uint8 (b, DVB_PIXEL_DATA_TYPE_END_OF_LINE);
pixels += stride;
}
}
static void
encode_rle8 (GstByteWriter * b, const guint8 * pixels,
const gint stride, const gint w, const gint h)
{
int y;
for (y = 0; y < h; y++) {
int x = 0;
gst_byte_writer_put_uint8 (b, DVB_PIXEL_DATA_TYPE_8BIT);
while (x < w) {
int x_end = x;
int run_length;
guint8 pix;
pix = pixels[x_end++];
while (x_end < w && pixels[x_end] == pix)
x_end++;
/* 127 is the largest run length we can encode */
run_length = MIN (x_end - x, 127);
if (run_length == 1 && pix != 0) {
/* a single non-zero pixel - encode directly */
gst_byte_writer_put_uint8 (b, pix);
} else if (pix == 0) {
/* Encode up to 1-127 pixels of colour 0 */
gst_byte_writer_put_uint8 (b, 0);
gst_byte_writer_put_uint8 (b, run_length);
} else if (run_length > 2) {
/* Encode 3-127 pixels of colour 'pix' directly */
gst_byte_writer_put_uint8 (b, 0);
gst_byte_writer_put_uint8 (b, 0x80 | run_length);
gst_byte_writer_put_uint8 (b, pix);
} else {
/* Short 1-2 pixel run, encode it directly */
if (run_length == 2)
gst_byte_writer_put_uint8 (b, pix);
gst_byte_writer_put_uint8 (b, pix);
g_assert (run_length == 1 || run_length == 2);
}
x += run_length;
}
/* End of line bytes */
gst_byte_writer_put_uint8 (b, 0x00);
// This 2nd 0x00 byte is correct from the spec, but ffmpeg
// as of 2020-04-24 does not like it
gst_byte_writer_put_uint8 (b, 0x00);
gst_byte_writer_put_uint8 (b, DVB_PIXEL_DATA_TYPE_END_OF_LINE);
pixels += stride;
}
}
static gboolean
dvbenc_write_object_data (GstByteWriter * b, int object_version, int page_id,
int object_id, SubpictureRect * s)
{
guint seg_size_pos, end_pos;
guint pixel_fields_size_pos, top_start_pos, bottom_start_pos;
EncodeRLEFunc encode_rle_func;
const gint stride = GST_VIDEO_INFO_PLANE_STRIDE (&s->frame->info, 0);
const gint w = GST_VIDEO_INFO_WIDTH (&s->frame->info);
const gint h = GST_VIDEO_INFO_HEIGHT (&s->frame->info);
const guint8 *pixels = (guint8 *) (s->frame->data[0]);
if (s->nb_colours <= 4)
encode_rle_func = encode_rle2;
else if (s->nb_colours <= 16)
encode_rle_func = encode_rle4;
else
encode_rle_func = encode_rle8;
gst_byte_writer_put_uint8 (b, DVB_SEGMENT_SYNC_BYTE);
gst_byte_writer_put_uint8 (b, DVB_SEGMENT_TYPE_OBJECT_DATA);
gst_byte_writer_put_uint16_be (b, page_id);
seg_size_pos = gst_byte_writer_get_pos (b);
gst_byte_writer_put_uint16_be (b, 0);
gst_byte_writer_put_uint16_be (b, object_id);
/* version number, coding_method (0), non-modifying-flag (0), reserved bit */
gst_byte_writer_put_uint8 (b, (object_version << 4) | 0x01);
pixel_fields_size_pos = gst_byte_writer_get_pos (b);
gst_byte_writer_put_uint16_be (b, 0);
gst_byte_writer_put_uint16_be (b, 0);
/* Write the top field (even) lines (round up lines / 2) */
top_start_pos = gst_byte_writer_get_pos (b);
encode_rle_func (b, pixels, stride * 2, w, (h + 1) / 2);
/* Write the bottom field (odd) lines (round down lines / 2) */
bottom_start_pos = gst_byte_writer_get_pos (b);
if (h > 1)
encode_rle_func (b, pixels + stride, stride * 2, w, h >> 1);
end_pos = gst_byte_writer_get_pos (b);
/* If the encoded size of the top+bottom field data blocks is even,
* add a stuffing byte */
if (((end_pos - top_start_pos) & 1) == 0) {
gst_byte_writer_put_uint8 (b, 0);
end_pos = gst_byte_writer_get_pos (b);
}
/* Re-write the size fields */
gst_byte_writer_set_pos (b, seg_size_pos);
if (end_pos - (seg_size_pos + 2) > G_MAXUINT16)
return FALSE; /* Data too big */
gst_byte_writer_put_uint16_be (b, end_pos - (seg_size_pos + 2));
if (bottom_start_pos - top_start_pos > G_MAXUINT16)
return FALSE; /* Data too big */
if (end_pos - bottom_start_pos > G_MAXUINT16)
return FALSE; /* Data too big */
gst_byte_writer_set_pos (b, pixel_fields_size_pos);
gst_byte_writer_put_uint16_be (b, bottom_start_pos - top_start_pos);
gst_byte_writer_put_uint16_be (b, end_pos - bottom_start_pos);
gst_byte_writer_set_pos (b, end_pos);
GST_LOG ("Object seg size %u top_size %u bottom_size %u",
end_pos - (seg_size_pos + 2), bottom_start_pos - top_start_pos,
end_pos - bottom_start_pos);
return TRUE;
}
static void
dvbenc_write_clut (GstByteWriter * b, int object_version, int page_id,
int clut_id, SubpictureRect * s)
{
guint8 *palette;
int clut_entry_flag;
guint seg_size_pos, pos;
int i;
if (s->nb_colours <= 4)
clut_entry_flag = 4;
else if (s->nb_colours <= 16)
clut_entry_flag = 2;
else
clut_entry_flag = 1;
gst_byte_writer_put_uint8 (b, DVB_SEGMENT_SYNC_BYTE);
gst_byte_writer_put_uint8 (b, DVB_SEGMENT_TYPE_CLUT_DEFINITION);
gst_byte_writer_put_uint16_be (b, page_id);
seg_size_pos = gst_byte_writer_get_pos (b);
gst_byte_writer_put_uint16_be (b, 0);
gst_byte_writer_put_uint8 (b, clut_id);
/* version number, reserved bits */
gst_byte_writer_put_uint8 (b, (object_version << 4) | 0x0F);
palette = (guint8 *) (s->frame->data[1]);
for (i = 0; i < s->nb_colours; i++) {
gst_byte_writer_put_uint8 (b, i);
/* clut_entry_flag | 4-bits reserved | full_range_flag = 1 */
gst_byte_writer_put_uint8 (b, clut_entry_flag << 5 | 0x1F);
/* Write YVUT value, where T (transparency) = 255 - A, Palette is AYUV */
gst_byte_writer_put_uint8 (b, palette[1]); /* Y */
gst_byte_writer_put_uint8 (b, palette[3]); /* V */
gst_byte_writer_put_uint8 (b, palette[2]); /* U */
gst_byte_writer_put_uint8 (b, 255 - palette[0]); /* A */
#if defined (HACK_2BIT)
palette += 4 * 64; /* HACK to generate 4-colour palette */
#elif defined (HACK_4BIT)
palette += 4 * 16; /* HACK to generate 16-colour palette */
#else
palette += 4;
#endif
}
/* Re-write the size field */
pos = gst_byte_writer_get_pos (b);
gst_byte_writer_set_pos (b, seg_size_pos);
gst_byte_writer_put_uint16_be (b, pos - (seg_size_pos + 2));
gst_byte_writer_set_pos (b, pos);
}
static void
dvbenc_write_region_segment (GstByteWriter * b, int object_version, int page_id,
int region_id, SubpictureRect * s)
{
int region_depth;
guint seg_size_pos, pos;
gint w = GST_VIDEO_INFO_WIDTH (&s->frame->info);
gint h = GST_VIDEO_INFO_HEIGHT (&s->frame->info);
if (s->nb_colours <= 4)
region_depth = 1;
else if (s->nb_colours <= 16)
region_depth = 2;
else
region_depth = 3;
gst_byte_writer_put_uint8 (b, DVB_SEGMENT_SYNC_BYTE);
gst_byte_writer_put_uint8 (b, DVB_SEGMENT_TYPE_REGION_COMPOSITION);
gst_byte_writer_put_uint16_be (b, page_id);
/* Size placeholder */
seg_size_pos = gst_byte_writer_get_pos (b);
gst_byte_writer_put_uint16_be (b, 0);
gst_byte_writer_put_uint8 (b, region_id);
/* version number, fill flag, reserved bits */
gst_byte_writer_put_uint8 (b, (object_version << 4) | (0 << 3) | 0x07);
gst_byte_writer_put_uint16_be (b, w);
gst_byte_writer_put_uint16_be (b, h);
/* level_of_compatibility and depth */
gst_byte_writer_put_uint8 (b, region_depth << 5 | region_depth << 2 | 0x03);
/* CLUT id */
gst_byte_writer_put_uint8 (b, region_id);
/* Dummy flags for the fill colours */
gst_byte_writer_put_uint16_be (b, 0x0003);
/* Object ID = region_id = CLUT id */
gst_byte_writer_put_uint16_be (b, region_id);
/* object type = 0, x,y corner = 0 */
gst_byte_writer_put_uint16_be (b, 0x0000);
gst_byte_writer_put_uint16_be (b, 0xf000);
/* Re-write the size field */
pos = gst_byte_writer_get_pos (b);
gst_byte_writer_set_pos (b, seg_size_pos);
gst_byte_writer_put_uint16_be (b, pos - (seg_size_pos + 2));
gst_byte_writer_set_pos (b, pos);
}
GstBuffer *
gst_dvbenc_encode (int object_version, int page_id, SubpictureRect * s,
guint num_subpictures)
{
GstByteWriter b;
guint seg_size_pos, pos;
guint i;
#ifdef HACK_2BIT
/* HACK: Only output 4 colours (results may be garbage, but tests
* the encoding */
s->nb_colours = 4;
#elif defined (HACK_4BIT)
/* HACK: Only output 16 colours */
s->nb_colours = 16;
#endif
gst_byte_writer_init (&b);
/* GStreamer passes DVB subpictures as private PES packets with
* 0x20 0x00 prefixed */
gst_byte_writer_put_uint16_be (&b, 0x2000);
/* Page Composition Segment */
gst_byte_writer_put_uint8 (&b, DVB_SEGMENT_SYNC_BYTE);
gst_byte_writer_put_uint8 (&b, DVB_SEGMENT_TYPE_PAGE_COMPOSITION);
gst_byte_writer_put_uint16_be (&b, page_id);
seg_size_pos = gst_byte_writer_get_pos (&b);
gst_byte_writer_put_uint16_be (&b, 0);
gst_byte_writer_put_uint8 (&b, 30);
/* We always write complete overlay subregions, so use page_state = 2 (mode change) */
gst_byte_writer_put_uint8 (&b, (object_version << 4) | (2 << 2) | 0x3);
for (i = 0; i < num_subpictures; i++) {
gst_byte_writer_put_uint8 (&b, i);
gst_byte_writer_put_uint8 (&b, 0xFF);
gst_byte_writer_put_uint16_be (&b, s[i].x);
gst_byte_writer_put_uint16_be (&b, s[i].y);
}
/* Rewrite the size field */
pos = gst_byte_writer_get_pos (&b);
gst_byte_writer_set_pos (&b, seg_size_pos);
gst_byte_writer_put_uint16_be (&b, pos - (seg_size_pos + 2));
gst_byte_writer_set_pos (&b, pos);
/* Region Composition */
for (i = 0; i < num_subpictures; i++) {
dvbenc_write_region_segment (&b, object_version, page_id, i, s + i);
}
/* CLUT definitions */
for (i = 0; i < num_subpictures; i++) {
dvbenc_write_clut (&b, object_version, page_id, i, s + i);
}
/* object data */
for (i = 0; i < num_subpictures; i++) {
/* FIXME: Any object data could potentially overflow the 64K field
* size, in which case we should split it */
if (!dvbenc_write_object_data (&b, object_version, page_id, i, s + i)) {
GST_WARNING ("Object data was too big to encode");
goto fail;
}
}
/* End of Display Set segment */
gst_byte_writer_put_uint8 (&b, DVB_SEGMENT_SYNC_BYTE);
gst_byte_writer_put_uint8 (&b, DVB_SEGMENT_TYPE_END_OF_DISPLAY);
gst_byte_writer_put_uint16_be (&b, page_id);
gst_byte_writer_put_uint16_be (&b, 0);
/* End of PES data marker */
gst_byte_writer_put_uint8 (&b, 0xFF);
return gst_byte_writer_reset_and_get_buffer (&b);
fail:
gst_byte_writer_reset (&b);
return NULL;
}
Reference in a new issue View git blame Copy permalink