mirror of
https://github.com/vdr-projects/vdr.git
synced 2025-03-01 10:50:46 +00:00
797dc7d1a1
VDR developer version 2.1.5 is now available at
ftp://ftp.tvdr.de/vdr/Developer/vdr-2.1.5.tar.bz2
A 'diff' against the previous version is available at
ftp://ftp.tvdr.de/vdr/Developer/vdr-2.1.4-2.1.5.diff
MD5 checksums:
ce561eef64c13e24e4817f70a6d9d5b0 vdr-2.1.5.tar.bz2
f433e78d90bc414bd9d858ca6e58e539 vdr-2.1.4-2.1.5.diff
WARNING:
========
This is a *developer* version. Even though *I* use it in my productive
environment, I strongly recommend that you only use it under controlled
conditions and for testing and debugging.
From the HISTORY file:
- Now checking whether the primary device actually has a decoder before retuning the
current channel after a change in its parameters. This fixes broken recordings on
the primary device on "headless" systems.
- Increased MIN_TS_PACKETS_FOR_FRAME_DETECTOR to 100 and introduced counting the number
of actual video TS packets in cTsPayload in order to be able to record channels that
sometimes need even more than 10 TS packets for detecting frame borders (reported by
Oliver Endriss).
- Fixed sorting recordings by time in the Recordings menu if "Setup/OSD/Recording
directories" is set to "no".
- Fixed clearing non-editable members in the channel editor (thanks to Rolf Ahrenberg).
- Updated the Estonian OSD texts (thanks to Arthur Konovalov).
- Further clarified the semantics of cCamSlot::Decrypt().
- Fixed flickering if subtitles are active while the OSD demo is running.
- Fixed numbering frames. Previously they were numbered starting from 1, while it
is apparently standard to number them from 0. Any existing recordings with editing
marks (which will now be off by one) can still be cut with all VDR versions from
1.7.32, because these will automatically adjust editing marks to I-frames.
Users of stable releases shouldn't notice any problems.
- Fixed a possible crash in the OSD demo (reported by Christopher Reimer).
- Fixed some compiler warnings with Clang 3.4.1 (reported by Paul Menzel).
- Added LinkageTypePremiere to libsi/si.h and eit.c to avoid a compiler warning with
Clang 3.4.1 (suggested by Tony Houghten).
- Replaced the NULL pointer assignment in ~cReceiver() to force a segfault with
a call to abort() (suggested by Tony Houghten).
- Fixed learning keyboard remote control codes (thanks to Lars Hanisch).
- Improved PAT/PMT scanning to speed up initial tuning to encrypted channels on
transponders with many PAT entries (reported by Mariusz Bialonczyk).
- Fixed the replay progress display for very long recordings.
- Fixed detecting broken video data streams when recording.
- Fixed handling frame detection buffer length (reported by Eike Sauer).
1523 lines
51 KiB
C
1523 lines
51 KiB
C
/*
|
|
* dvbsubtitle.c: DVB subtitles
|
|
*
|
|
* See the main source file 'vdr.c' for copyright information and
|
|
* how to reach the author.
|
|
*
|
|
* Original author: Marco Schluessler <marco@lordzodiac.de>
|
|
* With some input from the "subtitles plugin" by Pekka Virtanen <pekka.virtanen@sci.fi>
|
|
*
|
|
* $Id: dvbsubtitle.c 3.5 2014/02/08 12:29:13 kls Exp $
|
|
*/
|
|
|
|
#include "dvbsubtitle.h"
|
|
#define __STDC_FORMAT_MACROS // Required for format specifiers
|
|
#include <inttypes.h>
|
|
#include "device.h"
|
|
#include "libsi/si.h"
|
|
|
|
#define PAGE_COMPOSITION_SEGMENT 0x10
|
|
#define REGION_COMPOSITION_SEGMENT 0x11
|
|
#define CLUT_DEFINITION_SEGMENT 0x12
|
|
#define OBJECT_DATA_SEGMENT 0x13
|
|
#define DISPLAY_DEFINITION_SEGMENT 0x14
|
|
#define DISPARITY_SIGNALING_SEGMENT 0x15 // DVB BlueBook A156
|
|
#define END_OF_DISPLAY_SET_SEGMENT 0x80
|
|
#define STUFFING_SEGMENT 0xFF
|
|
|
|
// Set these to 'true' for debug output, which is written into the file dbg-log.htm
|
|
// in the current working directory. The HTML file shows the actual bitmaps (dbg-nnn.jpg)
|
|
// used to display the subtitles.
|
|
static bool DebugNormal = false; // shows pages, regions and objects
|
|
static bool DebugVerbose = false; // shows everything
|
|
static bool DebugDisplay = DebugVerbose || DebugNormal;
|
|
static bool DebugPages = DebugVerbose || DebugNormal;
|
|
static bool DebugRegions = DebugVerbose || DebugNormal;
|
|
static bool DebugObjects = DebugVerbose || DebugNormal;
|
|
static bool DebugConverter = DebugVerbose;
|
|
static bool DebugSegments = DebugVerbose;
|
|
static bool DebugPixel = DebugVerbose;
|
|
static bool DebugCluts = DebugVerbose;
|
|
static bool DebugOutput = DebugVerbose;
|
|
|
|
#define dbgdisplay(a...) if (DebugDisplay) SD.WriteHtml(a)
|
|
#define dbgpages(a...) if (DebugPages) SD.WriteHtml(a)
|
|
#define dbgregions(a...) if (DebugRegions) SD.WriteHtml(a)
|
|
#define dbgobjects(a...) if (DebugObjects) SD.WriteHtml(a)
|
|
#define dbgconverter(a...) if (DebugConverter) SD.WriteHtml(a)
|
|
#define dbgsegments(a...) if (DebugSegments) SD.WriteHtml(a)
|
|
#define dbgpixel(a...) if (DebugPixel) SD.WriteHtml(a)
|
|
#define dbgcluts(a...) if (DebugCluts) SD.WriteHtml(a)
|
|
#define dbgoutput(a...) if (DebugOutput) SD.WriteHtml(a)
|
|
|
|
#define DBGMAXBITMAPS 100 // debug output will be stopped after this many bitmaps
|
|
#define DBGBITMAPWIDTH 400
|
|
|
|
// --- cSubtitleDebug --------------------------------------------------------
|
|
|
|
class cSubtitleDebug {
|
|
private:
|
|
cMutex mutex;
|
|
int imgCnt;
|
|
int64_t firstPts;
|
|
bool newFile;
|
|
double factor;
|
|
public:
|
|
cSubtitleDebug(void) { Reset(); }
|
|
void Reset(void);
|
|
bool Active(void) { return imgCnt < DBGMAXBITMAPS; }
|
|
int64_t FirstPts(void) { return firstPts; }
|
|
void SetFirstPts(int64_t FirstPts) { if (firstPts < 0) firstPts = FirstPts; }
|
|
void SetFactor(double Factor) { factor = Factor; }
|
|
cString WriteJpeg(const cBitmap *Bitmap, int MaxX = 0, int MaxY = 0);
|
|
void WriteHtml(const char *Format, ...);
|
|
};
|
|
|
|
void cSubtitleDebug::Reset(void)
|
|
{
|
|
imgCnt = 0;
|
|
firstPts = -1;
|
|
newFile = true;
|
|
factor = 1.0;
|
|
}
|
|
|
|
cString cSubtitleDebug::WriteJpeg(const cBitmap *Bitmap, int MaxX, int MaxY)
|
|
{
|
|
if (!Active())
|
|
return NULL;
|
|
cMutexLock MutexLock(&mutex);
|
|
cBitmap *Scaled = Bitmap->Scaled(factor, factor, true);
|
|
int w = MaxX ? int(round(MaxX * factor)) : Scaled->Width();
|
|
int h = MaxY ? int(round(MaxY * factor)) : Scaled->Height();
|
|
uchar mem[w * h * 3];
|
|
for (int x = 0; x < w; x++) {
|
|
for (int y = 0; y < h; y++) {
|
|
tColor c = Scaled->GetColor(x, y);
|
|
int o = (y * w + x) * 3;
|
|
mem[o++] = (c & 0x00FF0000) >> 16;
|
|
mem[o++] = (c & 0x0000FF00) >> 8;
|
|
mem[o] = (c & 0x000000FF);
|
|
}
|
|
}
|
|
delete Scaled;
|
|
int Size = 0;
|
|
uchar *Jpeg = RgbToJpeg(mem, w, h, Size);
|
|
cString ImgName = cString::sprintf("dbg-%03d.jpg", imgCnt++);
|
|
int f = open(ImgName, O_WRONLY | O_CREAT, DEFFILEMODE);
|
|
if (f >= 0) {
|
|
if (write(f, Jpeg, Size) < 0)
|
|
LOG_ERROR_STR(*ImgName);
|
|
close(f);
|
|
}
|
|
free(Jpeg);
|
|
return ImgName;
|
|
}
|
|
|
|
void cSubtitleDebug::WriteHtml(const char *Format, ...)
|
|
{
|
|
if (!Active())
|
|
return;
|
|
cMutexLock MutexLock(&mutex);
|
|
if (FILE *f = fopen("dbg-log.htm", newFile ? "w" : "a")) {
|
|
va_list ap;
|
|
va_start(ap, Format);
|
|
vfprintf(f, Format, ap);
|
|
va_end(ap);
|
|
fclose(f);
|
|
newFile = false;
|
|
}
|
|
}
|
|
|
|
static cSubtitleDebug SD;
|
|
|
|
// --- cSubtitleClut ---------------------------------------------------------
|
|
|
|
class cSubtitleClut : public cListObject {
|
|
private:
|
|
int clutId;
|
|
int clutVersionNumber;
|
|
cPalette palette2;
|
|
cPalette palette4;
|
|
cPalette palette8;
|
|
tColor yuv2rgb(int Y, int Cb, int Cr);
|
|
void SetColor(int Bpp, int Index, tColor Color);
|
|
public:
|
|
cSubtitleClut(int ClutId);
|
|
void Parse(cBitStream &bs);
|
|
int ClutId(void) { return clutId; }
|
|
int ClutVersionNumber(void) { return clutVersionNumber; }
|
|
const cPalette *GetPalette(int Bpp);
|
|
};
|
|
|
|
cSubtitleClut::cSubtitleClut(int ClutId)
|
|
:palette2(2)
|
|
,palette4(4)
|
|
,palette8(8)
|
|
{
|
|
int a = 0, r = 0, g = 0, b = 0;
|
|
clutId = ClutId;
|
|
clutVersionNumber = -1;
|
|
// ETSI EN 300 743 10.3: 4-entry CLUT default contents
|
|
palette2.SetColor(0, ArgbToColor( 0, 0, 0, 0));
|
|
palette2.SetColor(1, ArgbToColor(255, 255, 255, 255));
|
|
palette2.SetColor(2, ArgbToColor(255, 0, 0, 0));
|
|
palette2.SetColor(3, ArgbToColor(255, 127, 127, 127));
|
|
// ETSI EN 300 743 10.2: 16-entry CLUT default contents
|
|
palette4.SetColor(0, ArgbToColor(0, 0, 0, 0));
|
|
for (int i = 1; i < 16; ++i) {
|
|
if (i < 8) {
|
|
r = (i & 1) ? 255 : 0;
|
|
g = (i & 2) ? 255 : 0;
|
|
b = (i & 4) ? 255 : 0;
|
|
}
|
|
else {
|
|
r = (i & 1) ? 127 : 0;
|
|
g = (i & 2) ? 127 : 0;
|
|
b = (i & 4) ? 127 : 0;
|
|
}
|
|
palette4.SetColor(i, ArgbToColor(255, r, g, b));
|
|
}
|
|
// ETSI EN 300 743 10.1: 256-entry CLUT default contents
|
|
palette8.SetColor(0, ArgbToColor(0, 0, 0, 0));
|
|
for (int i = 1; i < 256; ++i) {
|
|
if (i < 8) {
|
|
r = (i & 1) ? 255 : 0;
|
|
g = (i & 2) ? 255 : 0;
|
|
b = (i & 4) ? 255 : 0;
|
|
a = 63;
|
|
}
|
|
else {
|
|
switch (i & 0x88) {
|
|
case 0x00:
|
|
r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
|
|
g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
|
|
b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
|
|
a = 255;
|
|
break;
|
|
case 0x08:
|
|
r = ((i & 1) ? 85 : 0) + ((i & 0x10) ? 170 : 0);
|
|
g = ((i & 2) ? 85 : 0) + ((i & 0x20) ? 170 : 0);
|
|
b = ((i & 4) ? 85 : 0) + ((i & 0x40) ? 170 : 0);
|
|
a = 127;
|
|
break;
|
|
case 0x80:
|
|
r = 127 + ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
|
|
g = 127 + ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
|
|
b = 127 + ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
|
|
a = 255;
|
|
break;
|
|
case 0x88:
|
|
r = ((i & 1) ? 43 : 0) + ((i & 0x10) ? 85 : 0);
|
|
g = ((i & 2) ? 43 : 0) + ((i & 0x20) ? 85 : 0);
|
|
b = ((i & 4) ? 43 : 0) + ((i & 0x40) ? 85 : 0);
|
|
a = 255;
|
|
break;
|
|
}
|
|
}
|
|
palette8.SetColor(i, ArgbToColor(a, r, g, b));
|
|
}
|
|
}
|
|
|
|
void cSubtitleClut::Parse(cBitStream &bs)
|
|
{
|
|
int Version = bs.GetBits(4);
|
|
if (clutVersionNumber == Version)
|
|
return; // no update
|
|
clutVersionNumber = Version;
|
|
bs.SkipBits(4); // reserved
|
|
dbgcluts("<b>clut</b> id %d version %d<br>\n", clutId, clutVersionNumber);
|
|
while (!bs.IsEOF()) {
|
|
uchar clutEntryId = bs.GetBits(8);
|
|
bool entryClut2Flag = bs.GetBit();
|
|
bool entryClut4Flag = bs.GetBit();
|
|
bool entryClut8Flag = bs.GetBit();
|
|
bs.SkipBits(4); // reserved
|
|
uchar yval;
|
|
uchar crval;
|
|
uchar cbval;
|
|
uchar tval;
|
|
if (bs.GetBit()) { // full_range_flag
|
|
yval = bs.GetBits(8);
|
|
crval = bs.GetBits(8);
|
|
cbval = bs.GetBits(8);
|
|
tval = bs.GetBits(8);
|
|
}
|
|
else {
|
|
yval = bs.GetBits(6) << 2;
|
|
crval = bs.GetBits(4) << 4;
|
|
cbval = bs.GetBits(4) << 4;
|
|
tval = bs.GetBits(2) << 6;
|
|
}
|
|
tColor value = 0;
|
|
if (yval) {
|
|
value = yuv2rgb(yval, cbval, crval);
|
|
value |= ((10 - (clutEntryId ? Setup.SubtitleFgTransparency : Setup.SubtitleBgTransparency)) * (255 - tval) / 10) << 24;
|
|
}
|
|
dbgcluts("%2d %d %d %d %08X<br>\n", clutEntryId, entryClut2Flag ? 2 : 0, entryClut4Flag ? 4 : 0, entryClut8Flag ? 8 : 0, value);
|
|
if (entryClut2Flag)
|
|
SetColor(2, clutEntryId, value);
|
|
if (entryClut4Flag)
|
|
SetColor(4, clutEntryId, value);
|
|
if (entryClut8Flag)
|
|
SetColor(8, clutEntryId, value);
|
|
}
|
|
}
|
|
|
|
tColor cSubtitleClut::yuv2rgb(int Y, int Cb, int Cr)
|
|
{
|
|
int Ey, Epb, Epr;
|
|
int Eg, Eb, Er;
|
|
|
|
Ey = (Y - 16);
|
|
Epb = (Cb - 128);
|
|
Epr = (Cr - 128);
|
|
/* ITU-R 709 */
|
|
Er = constrain((298 * Ey + 460 * Epr) / 256, 0, 255);
|
|
Eg = constrain((298 * Ey - 55 * Epb - 137 * Epr) / 256, 0, 255);
|
|
Eb = constrain((298 * Ey + 543 * Epb ) / 256, 0, 255);
|
|
|
|
return (Er << 16) | (Eg << 8) | Eb;
|
|
}
|
|
|
|
void cSubtitleClut::SetColor(int Bpp, int Index, tColor Color)
|
|
{
|
|
switch (Bpp) {
|
|
case 2: palette2.SetColor(Index, Color); break;
|
|
case 4: palette4.SetColor(Index, Color); break;
|
|
case 8: palette8.SetColor(Index, Color); break;
|
|
default: esyslog("ERROR: wrong Bpp in cSubtitleClut::SetColor(%d, %d, %08X)", Bpp, Index, Color);
|
|
}
|
|
}
|
|
|
|
const cPalette *cSubtitleClut::GetPalette(int Bpp)
|
|
{
|
|
switch (Bpp) {
|
|
case 2: return &palette2;
|
|
case 4: return &palette4;
|
|
case 8: return &palette8;
|
|
default: esyslog("ERROR: wrong Bpp in cSubtitleClut::GetPalette(%d)", Bpp);
|
|
}
|
|
return &palette8;
|
|
}
|
|
|
|
// --- cSubtitleObject -------------------------------------------------------
|
|
|
|
class cSubtitleObject : public cListObject {
|
|
private:
|
|
int objectId;
|
|
int objectVersionNumber;
|
|
int objectCodingMethod;
|
|
bool nonModifyingColorFlag;
|
|
int topLength;
|
|
int botLength;
|
|
uchar *topData;
|
|
uchar *botData;
|
|
char *txtData;
|
|
int lineHeight;
|
|
void DrawLine(cBitmap *Bitmap, int x, int y, tIndex Index, int Length);
|
|
bool Decode2BppCodeString(cBitmap *Bitmap, int px, int py, cBitStream *bs, int&x, int y, const uint8_t *MapTable);
|
|
bool Decode4BppCodeString(cBitmap *Bitmap, int px, int py, cBitStream *bs, int&x, int y, const uint8_t *MapTable);
|
|
bool Decode8BppCodeString(cBitmap *Bitmap, int px, int py, cBitStream *bs, int&x, int y);
|
|
void DecodeSubBlock(cBitmap *Bitmap, int px, int py, const uchar *Data, int Length, bool Even);
|
|
void DecodeCharacterString(const uchar *Data, int NumberOfCodes);
|
|
public:
|
|
cSubtitleObject(int ObjectId);
|
|
~cSubtitleObject();
|
|
void Parse(cBitStream &bs);
|
|
int ObjectId(void) { return objectId; }
|
|
int ObjectVersionNumber(void) { return objectVersionNumber; }
|
|
int ObjectCodingMethod(void) { return objectCodingMethod; }
|
|
bool NonModifyingColorFlag(void) { return nonModifyingColorFlag; }
|
|
void Render(cBitmap *Bitmap, int px, int py, tIndex IndexFg, tIndex IndexBg);
|
|
};
|
|
|
|
cSubtitleObject::cSubtitleObject(int ObjectId)
|
|
{
|
|
objectId = ObjectId;
|
|
objectVersionNumber = -1;
|
|
objectCodingMethod = -1;
|
|
nonModifyingColorFlag = false;
|
|
topLength = 0;
|
|
botLength = 0;
|
|
topData = NULL;
|
|
botData = NULL;
|
|
txtData = NULL;
|
|
lineHeight = 26; // configurable subtitling font size?
|
|
}
|
|
|
|
cSubtitleObject::~cSubtitleObject()
|
|
{
|
|
free(topData);
|
|
free(botData);
|
|
free(txtData);
|
|
}
|
|
|
|
void cSubtitleObject::Parse(cBitStream &bs)
|
|
{
|
|
int Version = bs.GetBits(4);
|
|
if (objectVersionNumber == Version)
|
|
return; // no update
|
|
objectVersionNumber = Version;
|
|
objectCodingMethod = bs.GetBits(2);
|
|
nonModifyingColorFlag = bs.GetBit();
|
|
bs.SkipBit(); // reserved
|
|
dbgobjects("<b>object</b> id %d version %d method %d modify %d", objectId, objectVersionNumber, objectCodingMethod, nonModifyingColorFlag); // no "<br>\n" here, DecodeCharacterString() may add data
|
|
if (objectCodingMethod == 0) { // coding of pixels
|
|
topLength = bs.GetBits(16);
|
|
botLength = bs.GetBits(16);
|
|
free(topData);
|
|
if ((topData = MALLOC(uchar, topLength)) != NULL)
|
|
memcpy(topData, bs.GetData(), topLength);
|
|
else
|
|
topLength = 0;
|
|
free(botData);
|
|
if ((botData = MALLOC(uchar, botLength)) != NULL)
|
|
memcpy(botData, bs.GetData() + topLength, botLength);
|
|
else
|
|
botLength = 0;
|
|
bs.WordAlign();
|
|
}
|
|
else if (objectCodingMethod == 1) { // coded as a string of characters
|
|
int numberOfCodes = bs.GetBits(8);
|
|
DecodeCharacterString(bs.GetData(), numberOfCodes);
|
|
}
|
|
dbgobjects("<br>\n");
|
|
if (DebugObjects) {
|
|
// We can't get the actual clut here, so we use a default one. This may lead to
|
|
// funny colors, but we just want to get a rough idea of what's in the object, anyway.
|
|
cSubtitleClut Clut(0);
|
|
cBitmap b(1920, 1080, 8);
|
|
b.Replace(*Clut.GetPalette(b.Bpp()));
|
|
b.Clean();
|
|
Render(&b, 0, 0, 0, 1);
|
|
int x1, y1, x2, y2;
|
|
if (b.Dirty(x1, y1, x2, y2)) {
|
|
cString ImgName = SD.WriteJpeg(&b, x2, y2);
|
|
dbgobjects("<img src=\"%s\"><br>\n", *ImgName);
|
|
}
|
|
}
|
|
}
|
|
|
|
void cSubtitleObject::DecodeCharacterString(const uchar *Data, int NumberOfCodes)
|
|
{
|
|
// "ETSI EN 300 743 V1.3.1 (2006-11)", chapter 7.2.5 "Object data segment" specifies
|
|
// character_code to be a 16-bit index number into the character table identified
|
|
// in the subtitle_descriptor. However, the "subtitling_descriptor" <sic> according to
|
|
// "ETSI EN 300 468 V1.13.1 (2012-04)" doesn't contain a "character table identifier".
|
|
// It only contains a three letter language code, without any specification as to how
|
|
// this is related to a specific character table.
|
|
// Apparently the first "code" in textual subtitles contains the character table
|
|
// identifier, and all codes are 8-bit only. So let's first make Data a string of
|
|
// 8-bit characters:
|
|
if (NumberOfCodes > 0) {
|
|
char txt[NumberOfCodes + 1];
|
|
for (int i = 0; i < NumberOfCodes; i++)
|
|
txt[i] = Data[i * 2 + 1];
|
|
txt[NumberOfCodes] = 0;
|
|
bool singleByte;
|
|
const uchar *from = (uchar *)txt;
|
|
int len = NumberOfCodes;
|
|
const char *CharacterTable = SI::getCharacterTable(from, len, &singleByte);
|
|
dbgobjects(" table %s single %d raw '%s'", CharacterTable, singleByte, from);
|
|
cCharSetConv conv(CharacterTable, cCharSetConv::SystemCharacterTable());
|
|
const char *s = conv.Convert((const char *)from);
|
|
dbgobjects(" conv '%s'", s);
|
|
free(txtData);
|
|
txtData = strdup(s);
|
|
}
|
|
}
|
|
|
|
void cSubtitleObject::DecodeSubBlock(cBitmap *Bitmap, int px, int py, const uchar *Data, int Length, bool Even)
|
|
{
|
|
int x = 0;
|
|
int y = Even ? 0 : 1;
|
|
uint8_t map2to4[ 4] = { 0x00, 0x07, 0x08, 0x0F };
|
|
uint8_t map2to8[ 4] = { 0x00, 0x77, 0x88, 0xFF };
|
|
uint8_t map4to8[16] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
|
|
const uint8_t *mapTable = NULL;
|
|
cBitStream bs(Data, Length * 8);
|
|
while (!bs.IsEOF()) {
|
|
switch (bs.GetBits(8)) {
|
|
case 0x10:
|
|
dbgpixel("2-bit / pixel code string<br>\n");
|
|
switch (Bitmap->Bpp()) {
|
|
case 8: mapTable = map2to8; break;
|
|
case 4: mapTable = map2to4; break;
|
|
default: mapTable = NULL; break;
|
|
}
|
|
while (Decode2BppCodeString(Bitmap, px, py, &bs, x, y, mapTable) && !bs.IsEOF())
|
|
;
|
|
bs.ByteAlign();
|
|
break;
|
|
case 0x11:
|
|
dbgpixel("4-bit / pixel code string<br>\n");
|
|
switch (Bitmap->Bpp()) {
|
|
case 8: mapTable = map4to8; break;
|
|
default: mapTable = NULL; break;
|
|
}
|
|
while (Decode4BppCodeString(Bitmap, px, py, &bs, x, y, mapTable) && !bs.IsEOF())
|
|
;
|
|
bs.ByteAlign();
|
|
break;
|
|
case 0x12:
|
|
dbgpixel("8-bit / pixel code string<br>\n");
|
|
while (Decode8BppCodeString(Bitmap, px, py, &bs, x, y) && !bs.IsEOF())
|
|
;
|
|
break;
|
|
case 0x20:
|
|
dbgpixel("sub block 2 to 4 map<br>\n");
|
|
for (int i = 0; i < 4; ++i)
|
|
map2to4[i] = bs.GetBits(4);
|
|
break;
|
|
case 0x21:
|
|
dbgpixel("sub block 2 to 8 map<br>\n");
|
|
for (int i = 0; i < 4; ++i)
|
|
map2to8[i] = bs.GetBits(8);
|
|
break;
|
|
case 0x22:
|
|
dbgpixel("sub block 4 to 8 map<br>\n");
|
|
for (int i = 0; i < 16; ++i)
|
|
map4to8[i] = bs.GetBits(8);
|
|
break;
|
|
case 0xF0:
|
|
dbgpixel("end of object line<br>\n");
|
|
x = 0;
|
|
y += 2;
|
|
break;
|
|
default: dbgpixel("unknown sub block %s %d<br>\n", __FUNCTION__, __LINE__);
|
|
}
|
|
}
|
|
}
|
|
|
|
void cSubtitleObject::DrawLine(cBitmap *Bitmap, int x, int y, tIndex Index, int Length)
|
|
{
|
|
if (nonModifyingColorFlag && Index == 1)
|
|
return;
|
|
for (int pos = x; pos < x + Length; pos++)
|
|
Bitmap->SetIndex(pos, y, Index);
|
|
}
|
|
|
|
bool cSubtitleObject::Decode2BppCodeString(cBitmap *Bitmap, int px, int py, cBitStream *bs, int &x, int y, const uint8_t *MapTable)
|
|
{
|
|
int rl = 0;
|
|
int color = 0;
|
|
uchar code = bs->GetBits(2);
|
|
if (code) {
|
|
color = code;
|
|
rl = 1;
|
|
}
|
|
else if (bs->GetBit()) { // switch_1
|
|
rl = bs->GetBits(3) + 3;
|
|
color = bs->GetBits(2);
|
|
}
|
|
else if (bs->GetBit()) // switch_2
|
|
rl = 1; //color 0
|
|
else {
|
|
switch (bs->GetBits(2)) { // switch_3
|
|
case 0:
|
|
return false;
|
|
case 1:
|
|
rl = 2; //color 0
|
|
break;
|
|
case 2:
|
|
rl = bs->GetBits(4) + 12;
|
|
color = bs->GetBits(2);
|
|
break;
|
|
case 3:
|
|
rl = bs->GetBits(8) + 29;
|
|
color = bs->GetBits(2);
|
|
break;
|
|
default: ;
|
|
}
|
|
}
|
|
if (MapTable)
|
|
color = MapTable[color];
|
|
DrawLine(Bitmap, px + x, py + y, color, rl);
|
|
x += rl;
|
|
return true;
|
|
}
|
|
|
|
bool cSubtitleObject::Decode4BppCodeString(cBitmap *Bitmap, int px, int py, cBitStream *bs, int &x, int y, const uint8_t *MapTable)
|
|
{
|
|
int rl = 0;
|
|
int color = 0;
|
|
uchar code = bs->GetBits(4);
|
|
if (code) {
|
|
color = code;
|
|
rl = 1;
|
|
}
|
|
else if (bs->GetBit() == 0) { // switch_1
|
|
code = bs->GetBits(3);
|
|
if (code)
|
|
rl = code + 2; //color 0
|
|
else
|
|
return false;
|
|
}
|
|
else if (bs->GetBit() == 0) { // switch_2
|
|
rl = bs->GetBits(2) + 4;
|
|
color = bs->GetBits(4);
|
|
}
|
|
else {
|
|
switch (bs->GetBits(2)) { // switch_3
|
|
case 0: // color 0
|
|
rl = 1;
|
|
break;
|
|
case 1: // color 0
|
|
rl = 2;
|
|
break;
|
|
case 2:
|
|
rl = bs->GetBits(4) + 9;
|
|
color = bs->GetBits(4);
|
|
break;
|
|
case 3:
|
|
rl = bs->GetBits(8) + 25;
|
|
color = bs->GetBits(4);
|
|
break;
|
|
}
|
|
}
|
|
if (MapTable)
|
|
color = MapTable[color];
|
|
DrawLine(Bitmap, px + x, py + y, color, rl);
|
|
x += rl;
|
|
return true;
|
|
}
|
|
|
|
bool cSubtitleObject::Decode8BppCodeString(cBitmap *Bitmap, int px, int py, cBitStream *bs, int &x, int y)
|
|
{
|
|
int rl = 0;
|
|
int color = 0;
|
|
uchar code = bs->GetBits(8);
|
|
if (code) {
|
|
color = code;
|
|
rl = 1;
|
|
}
|
|
else if (bs->GetBit()) {
|
|
rl = bs->GetBits(7);
|
|
color = bs->GetBits(8);
|
|
}
|
|
else {
|
|
code = bs->GetBits(7);
|
|
if (code)
|
|
rl = code; // color 0
|
|
else
|
|
return false;
|
|
}
|
|
DrawLine(Bitmap, px + x, py + y, color, rl);
|
|
x += rl;
|
|
return true;
|
|
}
|
|
|
|
void cSubtitleObject::Render(cBitmap *Bitmap, int px, int py, tIndex IndexFg, tIndex IndexBg)
|
|
{
|
|
if (objectCodingMethod == 0) { // coding of pixels
|
|
DecodeSubBlock(Bitmap, px, py, topData, topLength, true);
|
|
if (botLength)
|
|
DecodeSubBlock(Bitmap, px, py, botData, botLength, false);
|
|
else
|
|
DecodeSubBlock(Bitmap, px, py, topData, topLength, false);
|
|
}
|
|
else if (objectCodingMethod == 1) { // coded as a string of characters
|
|
if (txtData) {
|
|
//TODO couldn't we draw the text directly into Bitmap?
|
|
cFont *font = cFont::CreateFont(Setup.FontOsd, Setup.FontOsdSize);
|
|
cBitmap tmp(font->Width(txtData), font->Height(), Bitmap->Bpp());
|
|
double factor = (double)lineHeight / font->Height();
|
|
tmp.DrawText(0, 0, txtData, Bitmap->Color(IndexFg), Bitmap->Color(IndexBg), font);
|
|
cBitmap *scaled = tmp.Scaled(factor, factor, true);
|
|
Bitmap->DrawBitmap(px, py, *scaled);
|
|
delete scaled;
|
|
delete font;
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- cSubtitleObjects ------------------------------------------------------
|
|
|
|
class cSubtitleObjects : public cList<cSubtitleObject> {
|
|
public:
|
|
cSubtitleObject *GetObjectById(int ObjectId, bool New = false);
|
|
};
|
|
|
|
cSubtitleObject *cSubtitleObjects::GetObjectById(int ObjectId, bool New)
|
|
{
|
|
for (cSubtitleObject *so = First(); so; so = Next(so)) {
|
|
if (so->ObjectId() == ObjectId)
|
|
return so;
|
|
}
|
|
if (!New)
|
|
return NULL;
|
|
cSubtitleObject *Object = new cSubtitleObject(ObjectId);
|
|
Add(Object);
|
|
return Object;
|
|
}
|
|
|
|
// --- cSubtitleObjectRef ----------------------------------------------------
|
|
|
|
class cSubtitleObjectRef : public cListObject {
|
|
private:
|
|
int objectId;
|
|
int objectType;
|
|
int objectProviderFlag;
|
|
int objectHorizontalPosition;
|
|
int objectVerticalPosition;
|
|
int foregroundPixelCode;
|
|
int backgroundPixelCode;
|
|
public:
|
|
cSubtitleObjectRef(cBitStream &bs);
|
|
int ObjectId(void) { return objectId; }
|
|
int ObjectType(void) { return objectType; }
|
|
int ObjectProviderFlag(void) { return objectProviderFlag; }
|
|
int ObjectHorizontalPosition(void) { return objectHorizontalPosition; }
|
|
int ObjectVerticalPosition(void) { return objectVerticalPosition; }
|
|
int ForegroundPixelCode(void) { return foregroundPixelCode; }
|
|
int BackgroundPixelCode(void) { return backgroundPixelCode; }
|
|
};
|
|
|
|
cSubtitleObjectRef::cSubtitleObjectRef(cBitStream &bs)
|
|
{
|
|
objectId = bs.GetBits(16);
|
|
objectType = bs.GetBits(2);
|
|
objectProviderFlag = bs.GetBits(2);
|
|
objectHorizontalPosition = bs.GetBits(12);
|
|
bs.SkipBits(4); // reserved
|
|
objectVerticalPosition = bs.GetBits(12);
|
|
if (objectType == 0x01 || objectType == 0x02) {
|
|
foregroundPixelCode = bs.GetBits(8);
|
|
backgroundPixelCode = bs.GetBits(8);
|
|
}
|
|
else {
|
|
foregroundPixelCode = 0;
|
|
backgroundPixelCode = 0;
|
|
}
|
|
dbgregions("<b>objectref</b> id %d type %d flag %d x %d y %d fg %d bg %d<br>\n", objectId, objectType, objectProviderFlag, objectHorizontalPosition, objectVerticalPosition, foregroundPixelCode, backgroundPixelCode);
|
|
}
|
|
|
|
// --- cSubtitleRegion -------------------------------------------------------
|
|
|
|
class cSubtitleRegion : public cListObject {
|
|
private:
|
|
int regionId;
|
|
int regionVersionNumber;
|
|
bool regionFillFlag;
|
|
int regionWidth;
|
|
int regionHeight;
|
|
int regionLevelOfCompatibility;
|
|
int regionDepth;
|
|
int clutId;
|
|
int region8bitPixelCode;
|
|
int region4bitPixelCode;
|
|
int region2bitPixelCode;
|
|
cList<cSubtitleObjectRef> objectRefs;
|
|
public:
|
|
cSubtitleRegion(int RegionId);
|
|
void Parse(cBitStream &bs);
|
|
int RegionId(void) { return regionId; }
|
|
int RegionVersionNumber(void) { return regionVersionNumber; }
|
|
bool RegionFillFlag(void) { return regionFillFlag; }
|
|
int RegionWidth(void) { return regionWidth; }
|
|
int RegionHeight(void) { return regionHeight; }
|
|
int RegionLevelOfCompatibility(void) { return regionLevelOfCompatibility; }
|
|
int RegionDepth(void) { return regionDepth; }
|
|
int ClutId(void) { return clutId; }
|
|
void Render(cBitmap *Bitmap, cSubtitleObjects *Objects);
|
|
};
|
|
|
|
cSubtitleRegion::cSubtitleRegion(int RegionId)
|
|
{
|
|
regionId = RegionId;
|
|
regionVersionNumber = -1;
|
|
regionFillFlag = false;
|
|
regionWidth = 0;
|
|
regionHeight = 0;
|
|
regionLevelOfCompatibility = 0;
|
|
regionDepth = 0;
|
|
clutId = -1;
|
|
region8bitPixelCode = 0;
|
|
region4bitPixelCode = 0;
|
|
region2bitPixelCode = 0;
|
|
}
|
|
|
|
void cSubtitleRegion::Parse(cBitStream &bs)
|
|
{
|
|
int Version = bs.GetBits(4);
|
|
if (regionVersionNumber == Version)
|
|
return; // no update
|
|
regionVersionNumber = Version;
|
|
regionFillFlag = bs.GetBit();
|
|
bs.SkipBits(3); // reserved
|
|
regionWidth = bs.GetBits(16);
|
|
regionHeight = bs.GetBits(16);
|
|
regionLevelOfCompatibility = 1 << bs.GetBits(3); // stored as "number of bits per pixel"
|
|
regionDepth = 1 << bs.GetBits(3); // stored as "number of bits per pixel"
|
|
bs.SkipBits(2); // reserved
|
|
clutId = bs.GetBits(8);
|
|
region8bitPixelCode = bs.GetBits(8);
|
|
region4bitPixelCode = bs.GetBits(4);
|
|
region2bitPixelCode = bs.GetBits(2);
|
|
bs.SkipBits(2); // reserved
|
|
dbgregions("<b>region</b> id %d version %d fill %d width %d height %d level %d depth %d clutId %d<br>\n", regionId, regionVersionNumber, regionFillFlag, regionWidth, regionHeight, regionLevelOfCompatibility, regionDepth, clutId);
|
|
// no objectRefs.Clear() here!
|
|
while (!bs.IsEOF())
|
|
objectRefs.Add(new cSubtitleObjectRef(bs));
|
|
}
|
|
|
|
void cSubtitleRegion::Render(cBitmap *Bitmap, cSubtitleObjects *Objects)
|
|
{
|
|
if (regionFillFlag) {
|
|
switch (Bitmap->Bpp()) {
|
|
case 2: Bitmap->Fill(region2bitPixelCode); break;
|
|
case 4: Bitmap->Fill(region4bitPixelCode); break;
|
|
case 8: Bitmap->Fill(region8bitPixelCode); break;
|
|
default: dbgregions("unknown bpp %d (%s %d)<br>\n", Bitmap->Bpp(), __FUNCTION__, __LINE__);
|
|
}
|
|
}
|
|
for (cSubtitleObjectRef *sor = objectRefs.First(); sor; sor = objectRefs.Next(sor)) {
|
|
if (cSubtitleObject *so = Objects->GetObjectById(sor->ObjectId())) {
|
|
so->Render(Bitmap, sor->ObjectHorizontalPosition(), sor->ObjectVerticalPosition(), sor->ForegroundPixelCode(), sor->BackgroundPixelCode());
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- cSubtitleRegionRef ----------------------------------------------------
|
|
|
|
class cSubtitleRegionRef : public cListObject {
|
|
private:
|
|
int regionId;
|
|
int regionHorizontalAddress;
|
|
int regionVerticalAddress;
|
|
public:
|
|
cSubtitleRegionRef(cBitStream &bs);
|
|
int RegionId(void) { return regionId; }
|
|
int RegionHorizontalAddress(void) { return regionHorizontalAddress; }
|
|
int RegionVerticalAddress(void) { return regionVerticalAddress; }
|
|
};
|
|
|
|
cSubtitleRegionRef::cSubtitleRegionRef(cBitStream &bs)
|
|
{
|
|
regionId = bs.GetBits(8);
|
|
bs.SkipBits(8); // reserved
|
|
regionHorizontalAddress = bs.GetBits(16);
|
|
regionVerticalAddress = bs.GetBits(16);
|
|
dbgpages("<b>regionref</b> id %d tx %d y %d<br>\n", regionId, regionHorizontalAddress, regionVerticalAddress);
|
|
}
|
|
|
|
// --- cDvbSubtitlePage ------------------------------------------------------
|
|
|
|
class cDvbSubtitlePage : public cListObject {
|
|
private:
|
|
int pageId;
|
|
int pageTimeout;
|
|
int pageVersionNumber;
|
|
int pageState;
|
|
int64_t pts;
|
|
bool pending;
|
|
cSubtitleObjects objects;
|
|
cList<cSubtitleClut> cluts;
|
|
cList<cSubtitleRegion> regions;
|
|
cList<cSubtitleRegionRef> regionRefs;
|
|
public:
|
|
cDvbSubtitlePage(int PageId);
|
|
void Parse(int64_t Pts, cBitStream &bs);
|
|
int PageId(void) { return pageId; }
|
|
int PageTimeout(void) { return pageTimeout; }
|
|
int PageVersionNumber(void) { return pageVersionNumber; }
|
|
int PageState(void) { return pageState; }
|
|
int64_t Pts(void) const { return pts; }
|
|
bool Pending(void) { return pending; }
|
|
cSubtitleObjects *Objects(void) { return &objects; }
|
|
tArea *GetAreas(int &NumAreas, double FactorX, double FactorY);
|
|
cSubtitleObject *GetObjectById(int ObjectId, bool New = false);
|
|
cSubtitleClut *GetClutById(int ClutId, bool New = false);
|
|
cSubtitleRegion *GetRegionById(int RegionId, bool New = false);
|
|
cSubtitleRegionRef *GetRegionRefByIndex(int RegionRefIndex) { return regionRefs.Get(RegionRefIndex); }
|
|
void SetPending(bool Pending) { pending = Pending; }
|
|
};
|
|
|
|
cDvbSubtitlePage::cDvbSubtitlePage(int PageId)
|
|
{
|
|
pageId = PageId;
|
|
pageTimeout = 0;
|
|
pageVersionNumber = -1;
|
|
pageState = -1;
|
|
pts = -1;
|
|
pending = false;
|
|
}
|
|
|
|
void cDvbSubtitlePage::Parse(int64_t Pts, cBitStream &bs)
|
|
{
|
|
if (Pts >= 0)
|
|
pts = Pts;
|
|
pageTimeout = bs.GetBits(8);
|
|
int Version = bs.GetBits(4);
|
|
if (pageVersionNumber == Version)
|
|
return; // no update
|
|
pageVersionNumber = Version;
|
|
pageState = bs.GetBits(2);
|
|
switch (pageState) {
|
|
case 0: // normal case - page update
|
|
break;
|
|
case 1: // acquisition point - page refresh
|
|
regions.Clear();
|
|
objects.Clear();
|
|
break;
|
|
case 2: // mode change - new page
|
|
regions.Clear();
|
|
cluts.Clear();
|
|
objects.Clear();
|
|
break;
|
|
case 3: // reserved
|
|
break;
|
|
default: dbgpages("unknown page state: %d<br>\n", pageState);
|
|
}
|
|
bs.SkipBits(2); // reserved
|
|
dbgpages("<hr>\n<b>page</b> id %d version %d pts %"PRId64" timeout %d state %d<br>\n", pageId, pageVersionNumber, pts, pageTimeout, pageState);
|
|
regionRefs.Clear();
|
|
while (!bs.IsEOF())
|
|
regionRefs.Add(new cSubtitleRegionRef(bs));
|
|
pending = true;
|
|
}
|
|
|
|
tArea *cDvbSubtitlePage::GetAreas(int &NumAreas, double FactorX, double FactorY)
|
|
{
|
|
if (regions.Count() > 0) {
|
|
NumAreas = regionRefs.Count();
|
|
tArea *Areas = new tArea[NumAreas];
|
|
tArea *a = Areas;
|
|
for (cSubtitleRegionRef *srr = regionRefs.First(); srr; srr = regionRefs.Next(srr)) {
|
|
if (cSubtitleRegion *sr = GetRegionById(srr->RegionId())) {
|
|
a->x1 = int(round(FactorX * srr->RegionHorizontalAddress()));
|
|
a->y1 = int(round(FactorY * srr->RegionVerticalAddress()));
|
|
a->x2 = int(round(FactorX * (srr->RegionHorizontalAddress() + sr->RegionWidth() - 1)));
|
|
a->y2 = int(round(FactorY * (srr->RegionVerticalAddress() + sr->RegionHeight() - 1)));
|
|
a->bpp = sr->RegionDepth();
|
|
while ((a->Width() & 3) != 0)
|
|
a->x2++; // aligns width to a multiple of 4, so 2, 4 and 8 bpp will work
|
|
}
|
|
else
|
|
a->x1 = a->y1 = a->x2 = a->y2 = a->bpp = 0;
|
|
a++;
|
|
}
|
|
return Areas;
|
|
}
|
|
NumAreas = 0;
|
|
return NULL;
|
|
}
|
|
|
|
cSubtitleClut *cDvbSubtitlePage::GetClutById(int ClutId, bool New)
|
|
{
|
|
for (cSubtitleClut *sc = cluts.First(); sc; sc = cluts.Next(sc)) {
|
|
if (sc->ClutId() == ClutId)
|
|
return sc;
|
|
}
|
|
if (!New)
|
|
return NULL;
|
|
cSubtitleClut *Clut = new cSubtitleClut(ClutId);
|
|
cluts.Add(Clut);
|
|
return Clut;
|
|
}
|
|
|
|
cSubtitleRegion *cDvbSubtitlePage::GetRegionById(int RegionId, bool New)
|
|
{
|
|
for (cSubtitleRegion *sr = regions.First(); sr; sr = regions.Next(sr)) {
|
|
if (sr->RegionId() == RegionId)
|
|
return sr;
|
|
}
|
|
if (!New)
|
|
return NULL;
|
|
cSubtitleRegion *Region = new cSubtitleRegion(RegionId);
|
|
regions.Add(Region);
|
|
return Region;
|
|
}
|
|
|
|
cSubtitleObject *cDvbSubtitlePage::GetObjectById(int ObjectId, bool New)
|
|
{
|
|
return objects.GetObjectById(ObjectId, New);
|
|
}
|
|
|
|
// --- cDvbSubtitleAssembler -------------------------------------------------
|
|
|
|
class cDvbSubtitleAssembler {
|
|
private:
|
|
uchar *data;
|
|
int length;
|
|
int pos;
|
|
int size;
|
|
bool Realloc(int Size);
|
|
public:
|
|
cDvbSubtitleAssembler(void);
|
|
virtual ~cDvbSubtitleAssembler();
|
|
void Reset(void);
|
|
unsigned char *Get(int &Length);
|
|
void Put(const uchar *Data, int Length);
|
|
};
|
|
|
|
cDvbSubtitleAssembler::cDvbSubtitleAssembler(void)
|
|
{
|
|
data = NULL;
|
|
size = 0;
|
|
Reset();
|
|
}
|
|
|
|
cDvbSubtitleAssembler::~cDvbSubtitleAssembler()
|
|
{
|
|
free(data);
|
|
}
|
|
|
|
void cDvbSubtitleAssembler::Reset(void)
|
|
{
|
|
length = 0;
|
|
pos = 0;
|
|
}
|
|
|
|
bool cDvbSubtitleAssembler::Realloc(int Size)
|
|
{
|
|
if (Size > size) {
|
|
Size = max(Size, 2048);
|
|
if (uchar *NewBuffer = (uchar *)realloc(data, Size)) {
|
|
size = Size;
|
|
data = NewBuffer;
|
|
}
|
|
else {
|
|
esyslog("ERROR: can't allocate memory for subtitle assembler");
|
|
length = 0;
|
|
size = 0;
|
|
free(data);
|
|
data = NULL;
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
unsigned char *cDvbSubtitleAssembler::Get(int &Length)
|
|
{
|
|
if (length > pos + 5) {
|
|
Length = (data[pos + 4] << 8) + data[pos + 5] + 6;
|
|
if (length >= pos + Length) {
|
|
unsigned char *result = data + pos;
|
|
pos += Length;
|
|
return result;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
void cDvbSubtitleAssembler::Put(const uchar *Data, int Length)
|
|
{
|
|
if (Length && Realloc(length + Length)) {
|
|
memcpy(data + length, Data, Length);
|
|
length += Length;
|
|
}
|
|
}
|
|
|
|
// --- cDvbSubtitleBitmaps ---------------------------------------------------
|
|
|
|
class cDvbSubtitleBitmaps : public cListObject {
|
|
private:
|
|
int state;
|
|
int64_t pts;
|
|
int timeout;
|
|
tArea *areas;
|
|
int numAreas;
|
|
double osdFactorX;
|
|
double osdFactorY;
|
|
cVector<cBitmap *> bitmaps;
|
|
public:
|
|
cDvbSubtitleBitmaps(int State, int64_t Pts, int Timeout, tArea *Areas, int NumAreas, double OsdFactorX, double OsdFactorY);
|
|
~cDvbSubtitleBitmaps();
|
|
int State(void) { return state; }
|
|
int64_t Pts(void) { return pts; }
|
|
int Timeout(void) { return timeout; }
|
|
void AddBitmap(cBitmap *Bitmap);
|
|
bool HasBitmaps(void) { return bitmaps.Size(); }
|
|
void Draw(cOsd *Osd);
|
|
void DbgDump(int WindowWidth, int WindowHeight);
|
|
};
|
|
|
|
cDvbSubtitleBitmaps::cDvbSubtitleBitmaps(int State, int64_t Pts, int Timeout, tArea *Areas, int NumAreas, double OsdFactorX, double OsdFactorY)
|
|
{
|
|
state = State;
|
|
pts = Pts;
|
|
timeout = Timeout;
|
|
areas = Areas;
|
|
numAreas = NumAreas;
|
|
osdFactorX = OsdFactorX;
|
|
osdFactorY = OsdFactorY;
|
|
}
|
|
|
|
cDvbSubtitleBitmaps::~cDvbSubtitleBitmaps()
|
|
{
|
|
delete[] areas;
|
|
for (int i = 0; i < bitmaps.Size(); i++)
|
|
delete bitmaps[i];
|
|
}
|
|
|
|
void cDvbSubtitleBitmaps::AddBitmap(cBitmap *Bitmap)
|
|
{
|
|
bitmaps.Append(Bitmap);
|
|
}
|
|
|
|
void cDvbSubtitleBitmaps::Draw(cOsd *Osd)
|
|
{
|
|
bool Scale = !(DoubleEqual(osdFactorX, 1.0) && DoubleEqual(osdFactorY, 1.0));
|
|
bool AntiAlias = true;
|
|
if (Scale && osdFactorX > 1.0 || osdFactorY > 1.0) {
|
|
// Upscaling requires 8bpp:
|
|
int Bpp[MAXOSDAREAS];
|
|
for (int i = 0; i < numAreas; i++) {
|
|
Bpp[i] = areas[i].bpp;
|
|
areas[i].bpp = 8;
|
|
}
|
|
if (Osd->CanHandleAreas(areas, numAreas) != oeOk) {
|
|
for (int i = 0; i < numAreas; i++)
|
|
areas[i].bpp = Bpp[i];
|
|
AntiAlias = false;
|
|
}
|
|
}
|
|
if (State() == 0 || Osd->SetAreas(areas, numAreas) == oeOk) {
|
|
for (int i = 0; i < bitmaps.Size(); i++) {
|
|
cBitmap *b = bitmaps[i];
|
|
if (Scale)
|
|
b = b->Scaled(osdFactorX, osdFactorY, AntiAlias);
|
|
Osd->DrawBitmap(int(round(b->X0() * osdFactorX)), int(round(b->Y0() * osdFactorY)), *b);
|
|
if (b != bitmaps[i])
|
|
delete b;
|
|
}
|
|
Osd->Flush();
|
|
}
|
|
}
|
|
|
|
void cDvbSubtitleBitmaps::DbgDump(int WindowWidth, int WindowHeight)
|
|
{
|
|
if (!SD.Active())
|
|
return;
|
|
SD.SetFirstPts(Pts());
|
|
double STC = double(cDevice::PrimaryDevice()->GetSTC() - SD.FirstPts()) / 90000;
|
|
double Start = double(Pts() - SD.FirstPts()) / 90000;
|
|
double Duration = Timeout();
|
|
double End = Start + Duration;
|
|
cBitmap Bitmap(WindowWidth, WindowHeight, 8);
|
|
#define DBGBACKGROUND 0xA0A0A0
|
|
Bitmap.DrawRectangle(0, 0, WindowWidth - 1, WindowHeight - 1, DBGBACKGROUND);
|
|
for (int i = 0; i < bitmaps.Size(); i++) {
|
|
cBitmap *b = bitmaps[i];
|
|
Bitmap.DrawBitmap(b->X0(), b->Y0(), *b);
|
|
}
|
|
cString ImgName = SD.WriteJpeg(&Bitmap);
|
|
#define BORDER //" border=1"
|
|
SD.WriteHtml("<p>%s<br>", State() == 0 ? "page update" : State() == 1 ? "page refresh" : State() == 2 ? "new page" : "???");
|
|
SD.WriteHtml("<table" BORDER "><tr><td>");
|
|
SD.WriteHtml("%.2f", STC);
|
|
SD.WriteHtml("</td><td>");
|
|
SD.WriteHtml("<img src=\"%s\">", *ImgName);
|
|
SD.WriteHtml("</td><td style=\"height:100%%\"><table" BORDER " style=\"height:100%%\">");
|
|
SD.WriteHtml("<tr><td valign=top><b>%.2f</b></td></tr>", Start);
|
|
SD.WriteHtml("<tr><td valign=middle>%.2f</td></tr>", Duration);
|
|
SD.WriteHtml("<tr><td valign=bottom>%.2f</td></tr>", End);
|
|
SD.WriteHtml("</table></td>");
|
|
SD.WriteHtml("</tr></table>\n");
|
|
}
|
|
|
|
// --- cDvbSubtitleConverter -------------------------------------------------
|
|
|
|
int cDvbSubtitleConverter::setupLevel = 0;
|
|
|
|
cDvbSubtitleConverter::cDvbSubtitleConverter(void)
|
|
:cThread("subtitleConverter")
|
|
{
|
|
dvbSubtitleAssembler = new cDvbSubtitleAssembler;
|
|
osd = NULL;
|
|
frozen = false;
|
|
ddsVersionNumber = -1;
|
|
displayWidth = windowWidth = 720;
|
|
displayHeight = windowHeight = 576;
|
|
windowHorizontalOffset = 0;
|
|
windowVerticalOffset = 0;
|
|
pages = new cList<cDvbSubtitlePage>;
|
|
bitmaps = new cList<cDvbSubtitleBitmaps>;
|
|
SD.Reset();
|
|
Start();
|
|
}
|
|
|
|
cDvbSubtitleConverter::~cDvbSubtitleConverter()
|
|
{
|
|
Cancel(3);
|
|
delete dvbSubtitleAssembler;
|
|
delete osd;
|
|
delete bitmaps;
|
|
delete pages;
|
|
}
|
|
|
|
void cDvbSubtitleConverter::SetupChanged(void)
|
|
{
|
|
setupLevel++;
|
|
}
|
|
|
|
void cDvbSubtitleConverter::Reset(void)
|
|
{
|
|
dbgconverter("converter reset -----------------------<br>\n");
|
|
dvbSubtitleAssembler->Reset();
|
|
Lock();
|
|
pages->Clear();
|
|
bitmaps->Clear();
|
|
DELETENULL(osd);
|
|
frozen = false;
|
|
ddsVersionNumber = -1;
|
|
displayWidth = windowWidth = 720;
|
|
displayHeight = windowHeight = 576;
|
|
windowHorizontalOffset = 0;
|
|
windowVerticalOffset = 0;
|
|
Unlock();
|
|
}
|
|
|
|
int cDvbSubtitleConverter::ConvertFragments(const uchar *Data, int Length)
|
|
{
|
|
if (Data && Length > 8) {
|
|
int PayloadOffset = PesPayloadOffset(Data);
|
|
int SubstreamHeaderLength = 4;
|
|
bool ResetSubtitleAssembler = Data[PayloadOffset + 3] == 0x00;
|
|
|
|
// Compatibility mode for old subtitles plugin:
|
|
if ((Data[7] & 0x01) && (Data[PayloadOffset - 3] & 0x81) == 0x01 && Data[PayloadOffset - 2] == 0x81) {
|
|
PayloadOffset--;
|
|
SubstreamHeaderLength = 1;
|
|
ResetSubtitleAssembler = Data[8] >= 5;
|
|
}
|
|
|
|
if (Length > PayloadOffset + SubstreamHeaderLength) {
|
|
int64_t pts = PesHasPts(Data) ? PesGetPts(Data) : -1;
|
|
if (pts >= 0)
|
|
dbgconverter("converter PTS: %"PRId64"<br>\n", pts);
|
|
const uchar *data = Data + PayloadOffset + SubstreamHeaderLength; // skip substream header
|
|
int length = Length - PayloadOffset - SubstreamHeaderLength; // skip substream header
|
|
if (ResetSubtitleAssembler)
|
|
dvbSubtitleAssembler->Reset();
|
|
|
|
if (length > 3) {
|
|
if (data[0] == 0x20 && data[1] == 0x00 && data[2] == 0x0F)
|
|
dvbSubtitleAssembler->Put(data + 2, length - 2);
|
|
else
|
|
dvbSubtitleAssembler->Put(data, length);
|
|
|
|
int Count;
|
|
while (true) {
|
|
unsigned char *b = dvbSubtitleAssembler->Get(Count);
|
|
if (b && b[0] == 0x0F) {
|
|
if (ExtractSegment(b, Count, pts) == -1)
|
|
break;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return Length;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int cDvbSubtitleConverter::Convert(const uchar *Data, int Length)
|
|
{
|
|
if (Data && Length > 8) {
|
|
int PayloadOffset = PesPayloadOffset(Data);
|
|
if (Length > PayloadOffset) {
|
|
int64_t pts = PesHasPts(Data) ? PesGetPts(Data) : -1;
|
|
if (pts >= 0)
|
|
dbgconverter("converter PTS: %"PRId64"<br>\n", pts);
|
|
const uchar *data = Data + PayloadOffset;
|
|
int length = Length - PayloadOffset;
|
|
if (length > 3) {
|
|
if (data[0] == 0x20 && data[1] == 0x00 && data[2] == 0x0F) {
|
|
data += 2;
|
|
length -= 2;
|
|
}
|
|
const uchar *b = data;
|
|
while (length > 0) {
|
|
if (b[0] == 0x0F) {
|
|
int n = ExtractSegment(b, length, pts);
|
|
if (n < 0)
|
|
break;
|
|
b += n;
|
|
length -= n;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return Length;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#define LimitTo32Bit(n) ((n) & 0x00000000FFFFFFFFL)
|
|
|
|
void cDvbSubtitleConverter::Action(void)
|
|
{
|
|
int LastSetupLevel = setupLevel;
|
|
cTimeMs Timeout;
|
|
while (Running()) {
|
|
int WaitMs = 100;
|
|
if (!frozen) {
|
|
LOCK_THREAD;
|
|
if (osd) {
|
|
int NewSetupLevel = setupLevel;
|
|
if (Timeout.TimedOut() || LastSetupLevel != NewSetupLevel) {
|
|
dbgoutput("closing osd<br>\n");
|
|
DELETENULL(osd);
|
|
}
|
|
LastSetupLevel = NewSetupLevel;
|
|
}
|
|
for (cDvbSubtitleBitmaps *sb = bitmaps->First(); sb; sb = bitmaps->Next(sb)) {
|
|
// Calculate the Delta between the STC (the current timestamp of the video)
|
|
// and the bitmap's PTS (the timestamp when the bitmap shall be presented).
|
|
// A negative Delta means that the bitmap will be presented in the future:
|
|
int64_t STC = cDevice::PrimaryDevice()->GetSTC();
|
|
int64_t Delta = LimitTo32Bit(STC) - LimitTo32Bit(sb->Pts()); // some devices only deliver 32 bits
|
|
if (Delta > (int64_t(1) << 31))
|
|
Delta -= (int64_t(1) << 32);
|
|
else if (Delta < -((int64_t(1) << 31) - 1))
|
|
Delta += (int64_t(1) << 32);
|
|
Delta /= 90; // STC and PTS are in 1/90000s
|
|
if (Delta >= 0) { // found a bitmap that shall be displayed...
|
|
if (Delta < sb->Timeout() * 1000) { // ...and has not timed out yet
|
|
if (!sb->HasBitmaps()) {
|
|
Timeout.Set();
|
|
WaitMs = 0;
|
|
}
|
|
else if (AssertOsd()) {
|
|
dbgoutput("showing bitmap #%d of %d<br>\n", sb->Index() + 1, bitmaps->Count());
|
|
sb->Draw(osd);
|
|
Timeout.Set(sb->Timeout() * 1000);
|
|
dbgconverter("PTS: %"PRId64" STC: %"PRId64" (%"PRId64") timeout: %d<br>\n", sb->Pts(), STC, Delta, sb->Timeout());
|
|
}
|
|
}
|
|
else
|
|
WaitMs = 0; // bitmap already timed out, so try next one immediately
|
|
dbgoutput("deleting bitmap #%d of %d<br>\n", sb->Index() + 1, bitmaps->Count());
|
|
bitmaps->Del(sb);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
cCondWait::SleepMs(WaitMs);
|
|
}
|
|
}
|
|
|
|
void cDvbSubtitleConverter::SetOsdData(void)
|
|
{
|
|
int OsdWidth, OsdHeight;
|
|
double OsdAspect;
|
|
int VideoWidth, VideoHeight;
|
|
double VideoAspect;
|
|
cDevice::PrimaryDevice()->GetOsdSize(OsdWidth, OsdHeight, OsdAspect);
|
|
cDevice::PrimaryDevice()->GetVideoSize(VideoWidth, VideoHeight, VideoAspect);
|
|
if (OsdWidth == displayWidth && OsdHeight == displayHeight) {
|
|
osdFactorX = osdFactorY = 1.0;
|
|
osdDeltaX = osdDeltaY = 0;
|
|
}
|
|
else {
|
|
osdFactorX = VideoAspect * OsdHeight / displayWidth;
|
|
osdFactorY = double(OsdHeight) / displayHeight;
|
|
osdDeltaX = (OsdWidth - displayWidth * osdFactorX) / 2;
|
|
osdDeltaY = (OsdHeight - displayHeight * osdFactorY) / 2;
|
|
}
|
|
}
|
|
|
|
bool cDvbSubtitleConverter::AssertOsd(void)
|
|
{
|
|
LOCK_THREAD;
|
|
if (!osd) {
|
|
SetOsdData();
|
|
osd = cOsdProvider::NewOsd(int(round(osdFactorX * windowHorizontalOffset + osdDeltaX)), int(round(osdFactorY * windowVerticalOffset + osdDeltaY)) + Setup.SubtitleOffset, OSD_LEVEL_SUBTITLES);
|
|
}
|
|
return osd != NULL;
|
|
}
|
|
|
|
cDvbSubtitlePage *cDvbSubtitleConverter::GetPageById(int PageId, bool New)
|
|
{
|
|
for (cDvbSubtitlePage *sp = pages->First(); sp; sp = pages->Next(sp)) {
|
|
if (sp->PageId() == PageId)
|
|
return sp;
|
|
}
|
|
if (!New)
|
|
return NULL;
|
|
cDvbSubtitlePage *Page = new cDvbSubtitlePage(PageId);
|
|
pages->Add(Page);
|
|
return Page;
|
|
}
|
|
|
|
int cDvbSubtitleConverter::ExtractSegment(const uchar *Data, int Length, int64_t Pts)
|
|
{
|
|
cBitStream bs(Data, Length * 8);
|
|
if (Length > 5 && bs.GetBits(8) == 0x0F) { // sync byte
|
|
int segmentType = bs.GetBits(8);
|
|
if (segmentType == STUFFING_SEGMENT)
|
|
return -1;
|
|
LOCK_THREAD;
|
|
cDvbSubtitlePage *page = GetPageById(bs.GetBits(16), true);
|
|
int segmentLength = bs.GetBits(16);
|
|
if (!bs.SetLength(bs.Index() + segmentLength * 8))
|
|
return -1;
|
|
switch (segmentType) {
|
|
case PAGE_COMPOSITION_SEGMENT: {
|
|
if (page->Pending()) {
|
|
dbgsegments("END_OF_DISPLAY_SET_SEGMENT (simulated)<br>\n");
|
|
FinishPage(page);
|
|
}
|
|
dbgsegments("PAGE_COMPOSITION_SEGMENT<br>\n");
|
|
page->Parse(Pts, bs);
|
|
SD.SetFactor(double(DBGBITMAPWIDTH) / windowWidth);
|
|
break;
|
|
}
|
|
case REGION_COMPOSITION_SEGMENT: {
|
|
dbgsegments("REGION_COMPOSITION_SEGMENT<br>\n");
|
|
cSubtitleRegion *region = page->GetRegionById(bs.GetBits(8), true);
|
|
region->Parse(bs);
|
|
break;
|
|
}
|
|
case CLUT_DEFINITION_SEGMENT: {
|
|
dbgsegments("CLUT_DEFINITION_SEGMENT<br>\n");
|
|
cSubtitleClut *clut = page->GetClutById(bs.GetBits(8), true);
|
|
clut->Parse(bs);
|
|
break;
|
|
}
|
|
case OBJECT_DATA_SEGMENT: {
|
|
dbgsegments("OBJECT_DATA_SEGMENT<br>\n");
|
|
cSubtitleObject *object = page->GetObjectById(bs.GetBits(16), true);
|
|
object->Parse(bs);
|
|
break;
|
|
}
|
|
case DISPLAY_DEFINITION_SEGMENT: {
|
|
dbgsegments("DISPLAY_DEFINITION_SEGMENT<br>\n");
|
|
int version = bs.GetBits(4);
|
|
if (version != ddsVersionNumber) {
|
|
bool displayWindowFlag = bs.GetBit();
|
|
windowHorizontalOffset = 0;
|
|
windowVerticalOffset = 0;
|
|
bs.SkipBits(3); // reserved
|
|
displayWidth = windowWidth = bs.GetBits(16) + 1;
|
|
displayHeight = windowHeight = bs.GetBits(16) + 1;
|
|
if (displayWindowFlag) {
|
|
windowHorizontalOffset = bs.GetBits(16); // displayWindowHorizontalPositionMinimum
|
|
windowWidth = bs.GetBits(16) - windowHorizontalOffset + 1; // displayWindowHorizontalPositionMaximum
|
|
windowVerticalOffset = bs.GetBits(16); // displayWindowVerticalPositionMinimum
|
|
windowHeight = bs.GetBits(16) - windowVerticalOffset + 1; // displayWindowVerticalPositionMaximum
|
|
}
|
|
SetOsdData();
|
|
ddsVersionNumber = version;
|
|
dbgdisplay("<b>display</b> version %d flag %d width %d height %d ofshor %d ofsver %d<br>\n", ddsVersionNumber, displayWindowFlag, windowWidth, windowHeight, windowHorizontalOffset, windowVerticalOffset);
|
|
}
|
|
break;
|
|
}
|
|
case DISPARITY_SIGNALING_SEGMENT: {
|
|
dbgsegments("DISPARITY_SIGNALING_SEGMENT<br>\n");
|
|
bs.SkipBits(4); // dss_version_number
|
|
bool disparity_shift_update_sequence_page_flag = bs.GetBit();
|
|
bs.SkipBits(3); // reserved
|
|
bs.SkipBits(8); // page_default_disparity_shift
|
|
if (disparity_shift_update_sequence_page_flag) {
|
|
bs.SkipBits(8); // disparity_shift_update_sequence_length
|
|
bs.SkipBits(24); // interval_duration[23..0]
|
|
int division_period_count = bs.GetBits(8);
|
|
for (int i = 0; i < division_period_count; ++i) {
|
|
bs.SkipBits(8); // interval_count
|
|
bs.SkipBits(8); // disparity_shift_update_integer_part
|
|
}
|
|
}
|
|
while (!bs.IsEOF()) {
|
|
bs.SkipBits(8); // region_id
|
|
bool disparity_shift_update_sequence_region_flag = bs.GetBit();
|
|
bs.SkipBits(5); // reserved
|
|
int number_of_subregions_minus_1 = bs.GetBits(2);
|
|
for (int i = 0; i <= number_of_subregions_minus_1; ++i) {
|
|
if (number_of_subregions_minus_1 > 0) {
|
|
bs.SkipBits(16); // subregion_horizontal_position
|
|
bs.SkipBits(16); // subregion_width
|
|
}
|
|
bs.SkipBits(8); // subregion_disparity_shift_integer_part
|
|
bs.SkipBits(4); // subregion_disparity_shift_fractional_part
|
|
bs.SkipBits(4); // reserved
|
|
if (disparity_shift_update_sequence_region_flag) {
|
|
bs.SkipBits(8); // disparity_shift_update_sequence_length
|
|
bs.SkipBits(24); // interval_duration[23..0]
|
|
int division_period_count = bs.GetBits(8);
|
|
for (int i = 0; i < division_period_count; ++i) {
|
|
bs.SkipBits(8); // interval_count
|
|
bs.SkipBits(8); // disparity_shift_update_integer_part
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case END_OF_DISPLAY_SET_SEGMENT: {
|
|
dbgsegments("END_OF_DISPLAY_SET_SEGMENT<br>\n");
|
|
FinishPage(page);
|
|
page->SetPending(false);
|
|
break;
|
|
}
|
|
default:
|
|
dbgsegments("*** unknown segment type: %02X<br>\n", segmentType);
|
|
}
|
|
return bs.Length() / 8;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void cDvbSubtitleConverter::FinishPage(cDvbSubtitlePage *Page)
|
|
{
|
|
if (!AssertOsd())
|
|
return;
|
|
int NumAreas;
|
|
tArea *Areas = Page->GetAreas(NumAreas, osdFactorX, osdFactorY);
|
|
int Bpp = 8;
|
|
bool Reduced = false;
|
|
while (osd && osd->CanHandleAreas(Areas, NumAreas) != oeOk) {
|
|
dbgoutput("CanHandleAreas: %d<br>\n", osd->CanHandleAreas(Areas, NumAreas));
|
|
int HalfBpp = Bpp / 2;
|
|
if (HalfBpp >= 2) {
|
|
for (int i = 0; i < NumAreas; i++) {
|
|
if (Areas[i].bpp >= Bpp) {
|
|
Areas[i].bpp = HalfBpp;
|
|
Reduced = true;
|
|
}
|
|
}
|
|
Bpp = HalfBpp;
|
|
}
|
|
else
|
|
return; // unable to draw bitmaps
|
|
}
|
|
cDvbSubtitleBitmaps *Bitmaps = new cDvbSubtitleBitmaps(Page->PageState(), Page->Pts(), Page->PageTimeout(), Areas, NumAreas, osdFactorX, osdFactorY);
|
|
bitmaps->Add(Bitmaps);
|
|
for (int i = 0; i < NumAreas; i++) {
|
|
if (cSubtitleRegionRef *srr = Page->GetRegionRefByIndex(i)) {
|
|
if (cSubtitleRegion *sr = Page->GetRegionById(srr->RegionId())) {
|
|
if (cSubtitleClut *clut = Page->GetClutById(sr->ClutId())) {
|
|
cBitmap *bm = new cBitmap(sr->RegionWidth(), sr->RegionHeight(), sr->RegionDepth());
|
|
bm->Replace(*clut->GetPalette(sr->RegionDepth()));
|
|
sr->Render(bm, Page->Objects());
|
|
if (Reduced) {
|
|
if (sr->RegionDepth() != Areas[i].bpp) {
|
|
if (sr->RegionLevelOfCompatibility() <= Areas[i].bpp) {
|
|
//TODO this is untested - didn't have any such subtitle stream
|
|
cSubtitleClut *Clut = Page->GetClutById(sr->ClutId());
|
|
dbgregions("reduce region %d bpp %d level %d area bpp %d<br>\n", sr->RegionId(), sr->RegionDepth(), sr->RegionLevelOfCompatibility(), Areas[i].bpp);
|
|
bm->ReduceBpp(*Clut->GetPalette(sr->RegionDepth()));
|
|
}
|
|
else {
|
|
dbgregions("condense region %d bpp %d level %d area bpp %d<br>\n", sr->RegionId(), sr->RegionDepth(), sr->RegionLevelOfCompatibility(), Areas[i].bpp);
|
|
bm->ShrinkBpp(Areas[i].bpp);
|
|
}
|
|
}
|
|
}
|
|
bm->SetOffset(srr->RegionHorizontalAddress(), srr->RegionVerticalAddress());
|
|
Bitmaps->AddBitmap(bm);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (DebugPages)
|
|
Bitmaps->DbgDump(windowWidth, windowHeight);
|
|
}
|