mirror of
https://github.com/tuxbox-neutrino/libstb-hal.git
synced 2025-08-26 15:02:58 +02:00
844 lines
21 KiB
C
844 lines
21 KiB
C
/*
|
||
* Subtitle output to one registered client.
|
||
*
|
||
*
|
||
* This program is free software; you can redistribute it and/or modify
|
||
* it under the terms of the GNU General Public License as published by
|
||
* the Free Software Foundation; either version 2 of the License, or
|
||
* (at your option) any later version.
|
||
*
|
||
* This program 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 General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU General Public License
|
||
* along with this program; if not, write to the Free Software
|
||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||
*
|
||
*/
|
||
|
||
/* ***************************** */
|
||
/* Includes */
|
||
/* ***************************** */
|
||
|
||
#include <stdio.h>
|
||
#include <string.h>
|
||
#include <stdlib.h>
|
||
#include <unistd.h>
|
||
#include <fcntl.h>
|
||
#include <sys/types.h>
|
||
#include <sys/stat.h>
|
||
#include <memory.h>
|
||
#include <asm/types.h>
|
||
#include <pthread.h>
|
||
#include <errno.h>
|
||
|
||
#include "common.h"
|
||
#include "output.h"
|
||
#include "subtitle.h"
|
||
|
||
/* ***************************** */
|
||
/* Makros/Constants */
|
||
/* ***************************** */
|
||
|
||
#define SUBTITLE_DEBUG
|
||
|
||
#ifdef SUBTITLE_DEBUG
|
||
|
||
static short debug_level = 0;
|
||
|
||
#define subtitle_printf(level, fmt, x...) do { \
|
||
if (debug_level >= level) printf("[%s:%s] " fmt, __FILE__, __FUNCTION__, ## x); } while (0)
|
||
#else
|
||
#define subtitle_printf(level, fmt, x...)
|
||
#endif
|
||
|
||
#ifndef SUBTITLE_SILENT
|
||
#define subtitle_err(fmt, x...) do { printf("[%s:%s] " fmt, __FILE__, __FUNCTION__, ## x); } while (0)
|
||
#else
|
||
#define subtitle_err(fmt, x...)
|
||
#endif
|
||
|
||
/* Error Constants */
|
||
#define cERR_SUBTITLE_NO_ERROR 0
|
||
#define cERR_SUBTITLE_ERROR -1
|
||
|
||
static const char FILENAME[] = "subtitle.c";
|
||
|
||
/*
|
||
Number, Style, Name,, MarginL, MarginR, MarginV, Effect,, Text
|
||
|
||
1038,0,tdk,,0000,0000,0000,,That's not good.
|
||
1037,0,tdk,,0000,0000,0000,,{\i1}Rack them up, rack them up,{\i0}\N{\i1}rack them up.{\i0} [90]
|
||
1036,0,tdk,,0000,0000,0000,,Okay, rack them up.
|
||
*/
|
||
|
||
#define PUFFERSIZE 20
|
||
|
||
/* ***************************** */
|
||
/* Types */
|
||
/* ***************************** */
|
||
|
||
struct sub_t {
|
||
char * text;
|
||
unsigned long long int pts;
|
||
unsigned long int milliDuration;
|
||
};
|
||
|
||
|
||
/* ***************************** */
|
||
/* Varaibles */
|
||
/* ***************************** */
|
||
|
||
static pthread_mutex_t mutex;
|
||
|
||
static pthread_t thread_sub;
|
||
|
||
void* clientData = NULL;
|
||
void (*clientFunction) (long int, size_t, char *, void *);
|
||
|
||
static struct sub_t subPuffer[PUFFERSIZE];
|
||
static int readPointer = 0;
|
||
static int writePointer = 0;
|
||
static int hasThreadStarted = 0;
|
||
static int isSubtitleOpened = 0;
|
||
|
||
static int screen_width = 0;
|
||
static int screen_height = 0;
|
||
static int destStride = 0;
|
||
static int shareFramebuffer = 0;
|
||
static int framebufferFD = -1;
|
||
static unsigned char* destination = NULL;
|
||
|
||
/* ***************************** */
|
||
/* Prototypes */
|
||
/* ***************************** */
|
||
|
||
/* ***************************** */
|
||
/* MISC Functions */
|
||
/* ***************************** */
|
||
static void getMutex(int line) {
|
||
subtitle_printf(100, "%d requesting mutex\n", line);
|
||
|
||
pthread_mutex_lock(&mutex);
|
||
|
||
subtitle_printf(100, "%d received mutex\n", line);
|
||
}
|
||
|
||
static void releaseMutex(int line) {
|
||
pthread_mutex_unlock(&mutex);
|
||
|
||
subtitle_printf(100, "%d released mutex\n", line);
|
||
}
|
||
|
||
void replace_all(char ** string, char * search, char * replace) {
|
||
int len = 0;
|
||
char * ptr = NULL;
|
||
char tempString[512];
|
||
char newString[512];
|
||
|
||
newString[0] = '\0';
|
||
|
||
if ((string == NULL) || (*string == NULL) || (search == NULL) || (replace == NULL))
|
||
{
|
||
subtitle_err("null pointer passed\n");
|
||
return;
|
||
}
|
||
|
||
strncpy(tempString, *string, 511);
|
||
tempString[511] = '\0';
|
||
|
||
free(*string);
|
||
|
||
while ((ptr = strstr(tempString, search)) != NULL) {
|
||
len = ptr - tempString;
|
||
strncpy(newString, tempString, len);
|
||
newString[len] = '\0';
|
||
strcat(newString, replace);
|
||
|
||
len += strlen(search);
|
||
strcat(newString, tempString+len);
|
||
|
||
strcpy(tempString, newString);
|
||
}
|
||
|
||
subtitle_printf(20, "strdup in line %d\n", __LINE__);
|
||
|
||
if(newString[0] != '\0')
|
||
*string = strdup(newString);
|
||
else
|
||
*string = strdup(tempString);
|
||
|
||
}
|
||
|
||
int subtitle_ParseASS (char **Line) {
|
||
char* Text;
|
||
int i;
|
||
char* ptr1;
|
||
|
||
if ((Line == NULL) || (*Line == NULL))
|
||
{
|
||
subtitle_err("null pointer passed\n");
|
||
return cERR_SUBTITLE_ERROR;
|
||
}
|
||
|
||
Text = strdup(*Line);
|
||
|
||
subtitle_printf(10, "-> Text = %s\n", *Line);
|
||
|
||
ptr1 = Text;
|
||
|
||
for (i=0; i < 9 && *ptr1 != '\0'; ptr1++) {
|
||
|
||
subtitle_printf(20, "%s",ptr1);
|
||
|
||
if (*ptr1 == ',')
|
||
i++;
|
||
}
|
||
|
||
free(*Line);
|
||
|
||
*Line = strdup(ptr1);
|
||
free(Text);
|
||
|
||
replace_all(Line, "\\N", "\n");
|
||
|
||
replace_all(Line, "{\\i1}", "<i>");
|
||
replace_all(Line, "{\\i0}", "</i>");
|
||
|
||
subtitle_printf(10, "<- Text=%s\n", *Line);
|
||
|
||
return cERR_SUBTITLE_NO_ERROR;
|
||
}
|
||
|
||
int subtitle_ParseSRT (char **Line) {
|
||
|
||
if ((Line == NULL) || (*Line == NULL))
|
||
{
|
||
subtitle_err("null pointer passed\n");
|
||
return cERR_SUBTITLE_ERROR;
|
||
}
|
||
|
||
subtitle_printf(20, "-> Text=%s\n", *Line);
|
||
|
||
replace_all(Line, "\x0d", "");
|
||
replace_all(Line, "\n\n", "\\N");
|
||
replace_all(Line, "\n", "");
|
||
replace_all(Line, "\\N", "\n");
|
||
replace_all(Line, "<EFBFBD>", "oe");
|
||
replace_all(Line, "<EFBFBD>", "ae");
|
||
replace_all(Line, "<EFBFBD>", "ue");
|
||
replace_all(Line, "<EFBFBD>", "Oe");
|
||
replace_all(Line, "<EFBFBD>", "Ae");
|
||
replace_all(Line, "<EFBFBD>", "Ue");
|
||
replace_all(Line, "<EFBFBD>", "ss");
|
||
|
||
subtitle_printf(10, "<- Text=%s\n", *Line);
|
||
|
||
return cERR_SUBTITLE_NO_ERROR;
|
||
}
|
||
|
||
int subtitle_ParseSSA (char **Line) {
|
||
|
||
if ((Line == NULL) || (*Line == NULL))
|
||
{
|
||
subtitle_err("null pointer passed\n");
|
||
return cERR_SUBTITLE_ERROR;
|
||
}
|
||
|
||
subtitle_printf(20, "-> Text=%s\n", *Line);
|
||
|
||
replace_all(Line, "\x0d", "");
|
||
replace_all(Line, "\n\n", "\\N");
|
||
replace_all(Line, "\n", "");
|
||
replace_all(Line, "\\N", "\n");
|
||
replace_all(Line, "<EFBFBD>", "oe");
|
||
replace_all(Line, "<EFBFBD>", "ae");
|
||
replace_all(Line, "<EFBFBD>", "ue");
|
||
replace_all(Line, "<EFBFBD>", "Oe");
|
||
replace_all(Line, "<EFBFBD>", "Ae");
|
||
replace_all(Line, "<EFBFBD>", "Ue");
|
||
replace_all(Line, "<EFBFBD>", "ss");
|
||
|
||
subtitle_printf(10, "<- Text=%s\n", *Line);
|
||
|
||
return cERR_SUBTITLE_NO_ERROR;
|
||
}
|
||
|
||
void addSub(Context_t *context, char * text, unsigned long long int pts, unsigned long int milliDuration) {
|
||
int count = 20;
|
||
|
||
subtitle_printf(50, "index %d\n", writePointer);
|
||
|
||
if(context && context->playback && !context->playback->isPlaying)
|
||
{
|
||
subtitle_err("1. aborting ->no playback\n");
|
||
return;
|
||
}
|
||
|
||
if (text == NULL)
|
||
{
|
||
subtitle_err("null pointer passed\n");
|
||
return;
|
||
}
|
||
|
||
if (pts == 0)
|
||
{
|
||
subtitle_err("pts 0\n");
|
||
return;
|
||
}
|
||
|
||
if (milliDuration == 0)
|
||
{
|
||
subtitle_err("duration 0\n");
|
||
return;
|
||
}
|
||
|
||
while (subPuffer[writePointer].text != NULL) {
|
||
//List is full, wait till we got some free space
|
||
|
||
if(context && context->playback && !context->playback->isPlaying)
|
||
{
|
||
subtitle_err("2. aborting ->no playback\n");
|
||
return;
|
||
}
|
||
|
||
/* konfetti: we dont want to block forever here. if no buffer
|
||
* is available we start ring from the beginning and loose some stuff
|
||
* which is acceptable!
|
||
*/
|
||
subtitle_printf(10, "waiting on free buffer %d - %d (%d) ...\n", writePointer, readPointer, count);
|
||
usleep(10000);
|
||
count--;
|
||
|
||
if (count == 0)
|
||
{
|
||
subtitle_err("abort waiting on buffer...\n");
|
||
break;
|
||
}
|
||
}
|
||
|
||
subtitle_printf(20, "from mkv: %s pts:%lld milliDuration:%lud\n",text,pts,milliDuration);
|
||
|
||
getMutex(__LINE__);
|
||
|
||
if (count == 0)
|
||
{
|
||
int i;
|
||
subtitle_err("freeing not delivered data\n");
|
||
|
||
//Reset all
|
||
readPointer = 0;
|
||
writePointer = 0;
|
||
|
||
for (i = 0; i < PUFFERSIZE; i++) {
|
||
if (subPuffer[i].text != NULL)
|
||
free(subPuffer[i].text);
|
||
subPuffer[i].text = NULL;
|
||
subPuffer[i].pts = 0;
|
||
subPuffer[i].milliDuration = 0;
|
||
}
|
||
}
|
||
|
||
subPuffer[writePointer].text = strdup(text);
|
||
subPuffer[writePointer].pts = pts;
|
||
subPuffer[writePointer].milliDuration = milliDuration;
|
||
|
||
writePointer++;
|
||
|
||
if (writePointer == PUFFERSIZE)
|
||
writePointer = 0;
|
||
|
||
if (writePointer == readPointer)
|
||
{
|
||
/* this should not happen, and means that there is nor reader or
|
||
* the reader has performance probs ;)
|
||
* the recovery is done at startup of this function - but next time
|
||
*/
|
||
subtitle_err("ups something went wrong. no more readers? \n");
|
||
}
|
||
|
||
releaseMutex(__LINE__);
|
||
|
||
subtitle_printf(10, "<\n");
|
||
}
|
||
|
||
int getNextSub(char ** text, unsigned long long int * pts, long int * milliDuration) {
|
||
|
||
subtitle_printf(50, "index %d\n", readPointer);
|
||
|
||
if (text == NULL)
|
||
{
|
||
subtitle_err("null pointer passed\n");
|
||
return cERR_SUBTITLE_ERROR;
|
||
}
|
||
|
||
getMutex(__LINE__);
|
||
|
||
if (subPuffer[readPointer].text == NULL)
|
||
{
|
||
/* this is acutally not an error, because it may happen
|
||
* that there is no subtitle for a while
|
||
*/
|
||
subtitle_printf(200, "null in subPuffer\n");
|
||
releaseMutex(__LINE__);
|
||
return cERR_SUBTITLE_ERROR;
|
||
}
|
||
|
||
*text = strdup(subPuffer[readPointer].text);
|
||
free(subPuffer[readPointer].text);
|
||
subPuffer[readPointer].text = NULL;
|
||
|
||
*pts = subPuffer[readPointer].pts;
|
||
subPuffer[readPointer].pts = 0;
|
||
|
||
*milliDuration = subPuffer[readPointer].milliDuration;
|
||
subPuffer[readPointer].milliDuration = 0;
|
||
|
||
readPointer++;
|
||
|
||
if (readPointer == PUFFERSIZE)
|
||
readPointer = 0;
|
||
|
||
if (writePointer == readPointer)
|
||
{
|
||
/* this may happen, in normal case the reader is ones ahead the
|
||
* writer. So this is the normal case that we eat the data
|
||
* and have the reader reached.
|
||
*/
|
||
subtitle_printf(20, "ups something went wrong. no more writers? \n");
|
||
}
|
||
|
||
releaseMutex(__LINE__);
|
||
|
||
subtitle_printf(20, "readPointer %d\n",readPointer);
|
||
subtitle_printf(10, "<\n");
|
||
|
||
return cERR_SUBTITLE_NO_ERROR;
|
||
}
|
||
|
||
/* **************************** */
|
||
/* Worker Thread */
|
||
/* **************************** */
|
||
|
||
static void* SubtitleThread(void* data) {
|
||
Context_t *context = (Context_t*) data;
|
||
char * subText = NULL;
|
||
long int subMilliDuration = 0;
|
||
unsigned long long int subPts = 0;
|
||
unsigned long long int Pts = 0;
|
||
|
||
subtitle_printf(10, "\n");
|
||
|
||
while ( context->playback->isCreationPhase ) {
|
||
subtitle_err("Thread waiting for end of init phase...\n");
|
||
usleep(1000);
|
||
}
|
||
|
||
subtitle_printf(10, "done\n");
|
||
|
||
while ( context &&
|
||
context->playback &&
|
||
context->playback->isPlaying) {
|
||
|
||
int curtrackid = -1;
|
||
|
||
if (context && context->manager && context->manager->subtitle)
|
||
context->manager->subtitle->Command(context, MANAGER_GET, &curtrackid);
|
||
|
||
subtitle_printf(50, "curtrackid %d\n", curtrackid);
|
||
|
||
if (curtrackid >= 0) {
|
||
if (getNextSub(&subText, &subPts, &subMilliDuration) != 0) {
|
||
usleep(500000);
|
||
continue;
|
||
}
|
||
|
||
if (context && context->playback)
|
||
context->playback->Command(context, PLAYBACK_PTS, &Pts);
|
||
else return NULL;
|
||
|
||
if(Pts > subPts) {
|
||
subtitle_printf(10,"subtitle is to late, ignoring\n");
|
||
if(subText != NULL)
|
||
free(subText);
|
||
continue;
|
||
}
|
||
|
||
subtitle_printf(20, "Pts:%llu < subPts%llu duration %ld\n", Pts, subPts,subMilliDuration);
|
||
|
||
while ( context &&
|
||
context->playback &&
|
||
context->playback->isPlaying &&
|
||
Pts < subPts) {
|
||
|
||
unsigned long int diff = subPts - Pts;
|
||
diff = (diff*1000)/90.0;
|
||
|
||
subtitle_printf(50, "DIFF: %lud\n", diff);
|
||
|
||
if(diff > 100)
|
||
usleep(diff);
|
||
|
||
if (context && context->playback)
|
||
context->playback->Command(context, PLAYBACK_PTS, &Pts);
|
||
else
|
||
{
|
||
subtitle_err("no playback ? terminated?\n");
|
||
break;
|
||
}
|
||
subtitle_printf(20, "cur: %llu wanted: %llu\n", Pts, subPts);
|
||
}
|
||
|
||
if ( context &&
|
||
context->playback &&
|
||
context->playback->isPlaying &&
|
||
subText != NULL ) {
|
||
|
||
if(clientFunction != NULL)
|
||
clientFunction(subMilliDuration, strlen(subText), subText, clientData);
|
||
else
|
||
subtitle_printf(10, "writing Sub failed (%ld) (%d) \"%s\"\n", subMilliDuration, strlen(subText), subText);
|
||
|
||
free(subText);
|
||
}
|
||
|
||
} /* trackID >= 0 */
|
||
else //Wait
|
||
usleep(500000);
|
||
|
||
} /* outer while */
|
||
|
||
subtitle_printf(0, "has ended\n");
|
||
|
||
hasThreadStarted = 0;
|
||
|
||
return NULL;
|
||
}
|
||
|
||
/* ***************************** */
|
||
/* Functions */
|
||
/* ***************************** */
|
||
|
||
static int Write(void* _context, void *data) {
|
||
Context_t * context = (Context_t *) _context;
|
||
char * Encoding = NULL;
|
||
char * Text;
|
||
SubtitleOut_t * out;
|
||
int DataLength;
|
||
unsigned long long int Pts;
|
||
float Duration;
|
||
|
||
subtitle_printf(10, "\n");
|
||
|
||
if (data == NULL)
|
||
{
|
||
subtitle_err("null pointer passed\n");
|
||
return cERR_SUBTITLE_ERROR;
|
||
}
|
||
|
||
out = (SubtitleOut_t*) data;
|
||
|
||
if (out->type == eSub_Txt)
|
||
{
|
||
Text = strdup((const char*) out->u.text.data);
|
||
} else
|
||
{
|
||
/* fixme handle gfx subs from container_ass and send it to
|
||
* the callback. this must be implemented also in e2/neutrino
|
||
* then.
|
||
*/
|
||
subtitle_err("subtitle gfx currently not handled\n");
|
||
return cERR_SUBTITLE_ERROR;
|
||
}
|
||
|
||
DataLength = out->u.text.len;
|
||
Pts = out->pts;
|
||
Duration = out->duration;
|
||
|
||
context->manager->subtitle->Command(context, MANAGER_GETENCODING, &Encoding);
|
||
|
||
if (Encoding == NULL)
|
||
{
|
||
subtitle_err("encoding unknown\n");
|
||
free(Text);
|
||
return cERR_SUBTITLE_ERROR;
|
||
}
|
||
|
||
subtitle_printf(20, "Encoding:%s Text:%s Len:%d\n", Encoding,Text, DataLength);
|
||
|
||
if ( !strncmp("S_TEXT/SSA", Encoding, 10) ||
|
||
!strncmp("S_SSA", Encoding, 5))
|
||
subtitle_ParseSSA(&Text);
|
||
|
||
else if(!strncmp("S_TEXT/ASS", Encoding, 10) ||
|
||
!strncmp("S_AAS", Encoding, 5))
|
||
subtitle_ParseASS(&Text);
|
||
|
||
else if(!strncmp("S_TEXT/SRT", Encoding, 10) ||
|
||
!strncmp("S_SRT", Encoding, 5))
|
||
subtitle_ParseSRT(&Text);
|
||
else
|
||
{
|
||
subtitle_err("unknown encoding %s\n", Encoding);
|
||
return cERR_SUBTITLE_ERROR;
|
||
}
|
||
|
||
subtitle_printf(10, "Text:%s Duration:%f\n", Text,Duration);
|
||
|
||
addSub(context, Text, Pts, Duration * 1000);
|
||
|
||
free(Text);
|
||
free(Encoding);
|
||
|
||
subtitle_printf(10, "<\n");
|
||
|
||
return cERR_SUBTITLE_NO_ERROR;
|
||
}
|
||
|
||
static int subtitle_Open(Context_t* context __attribute__((unused))) {
|
||
int i;
|
||
|
||
subtitle_printf(10, "\n");
|
||
|
||
if (isSubtitleOpened == 1)
|
||
{
|
||
subtitle_err("already opened! ignoring\n");
|
||
return cERR_SUBTITLE_ERROR;
|
||
}
|
||
|
||
getMutex(__LINE__);
|
||
|
||
//Reset all
|
||
readPointer = 0;
|
||
writePointer = 0;
|
||
|
||
for (i = 0; i < PUFFERSIZE; i++) {
|
||
subPuffer[i].text = NULL;
|
||
subPuffer[i].pts = 0;
|
||
subPuffer[i].milliDuration = 0;
|
||
}
|
||
|
||
isSubtitleOpened = 1;
|
||
|
||
releaseMutex(__LINE__);
|
||
|
||
subtitle_printf(10, "<\n");
|
||
|
||
return cERR_SUBTITLE_NO_ERROR;
|
||
}
|
||
|
||
static int subtitle_Close(Context_t* context __attribute__((unused))) {
|
||
int i;
|
||
|
||
subtitle_printf(10, "\n");
|
||
|
||
getMutex(__LINE__);
|
||
|
||
//Reset all
|
||
readPointer = 0;
|
||
writePointer = 0;
|
||
|
||
for (i = 0; i < PUFFERSIZE; i++) {
|
||
if (subPuffer[i].text != NULL)
|
||
free(subPuffer[i].text);
|
||
|
||
subPuffer[i].text = NULL;
|
||
subPuffer[i].pts = 0;
|
||
subPuffer[i].milliDuration = 0;
|
||
}
|
||
|
||
isSubtitleOpened = 0;
|
||
|
||
releaseMutex(__LINE__);
|
||
|
||
subtitle_printf(10, "<\n");
|
||
|
||
return cERR_SUBTITLE_NO_ERROR;
|
||
}
|
||
|
||
static int subtitle_Play(Context_t* context) {
|
||
subtitle_printf(10, "\n");
|
||
|
||
if (hasThreadStarted == 0)
|
||
{
|
||
pthread_attr_t attr;
|
||
|
||
pthread_attr_init(&attr);
|
||
|
||
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
|
||
|
||
if (pthread_create (&thread_sub, &attr, &SubtitleThread, (void*) context) != 0)
|
||
{
|
||
subtitle_err("Error creating thread\n");
|
||
hasThreadStarted = 0;
|
||
} else
|
||
{
|
||
subtitle_printf(10, "Created thread\n");
|
||
hasThreadStarted = 1;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
subtitle_err("thread already created.\n");
|
||
return cERR_SUBTITLE_ERROR;
|
||
}
|
||
|
||
subtitle_printf(10, "<\n");
|
||
|
||
return cERR_SUBTITLE_NO_ERROR;
|
||
}
|
||
|
||
static int subtitle_Stop(Context_t* context __attribute__((unused))) {
|
||
int wait_time = 20;
|
||
int i;
|
||
|
||
subtitle_printf(10, "\n");
|
||
|
||
while ( (hasThreadStarted != 0) && (--wait_time) > 0 ) {
|
||
subtitle_printf(10, "Waiting for subtitle thread to terminate itself, will try another %d times\n", wait_time);
|
||
usleep(100000);
|
||
}
|
||
|
||
if (wait_time == 0) {
|
||
subtitle_err("Timeout waiting for thread!\n");
|
||
|
||
return cERR_SUBTITLE_ERROR;
|
||
}
|
||
|
||
hasThreadStarted = 0;
|
||
|
||
/* konfetti: thread has ended, so nobody will eat the date...
|
||
* free the data...
|
||
*/
|
||
|
||
getMutex(__LINE__);
|
||
|
||
//Reset all
|
||
readPointer = 0;
|
||
writePointer = 0;
|
||
|
||
for (i = 0; i < PUFFERSIZE; i++) {
|
||
if (subPuffer[i].text != NULL)
|
||
free(subPuffer[i].text);
|
||
|
||
subPuffer[i].text = NULL;
|
||
subPuffer[i].pts = 0;
|
||
subPuffer[i].milliDuration = 0;
|
||
}
|
||
|
||
releaseMutex(__LINE__);
|
||
|
||
subtitle_printf(10, "<\n");
|
||
|
||
return cERR_SUBTITLE_NO_ERROR;
|
||
}
|
||
|
||
void subtitle_SignalConnect(void (*fkt) (long int, size_t, char *, void *))
|
||
{
|
||
subtitle_printf(10, "%p\n", fkt);
|
||
|
||
clientFunction = fkt;
|
||
}
|
||
|
||
void subtitle_SignalConnectBuffer(void* data)
|
||
{
|
||
subtitle_printf(10, "%p\n", data);
|
||
|
||
clientData = data;
|
||
}
|
||
|
||
static int Command(void *_context, OutputCmd_t command, void * argument) {
|
||
Context_t *context = (Context_t*) _context;
|
||
int ret = cERR_SUBTITLE_NO_ERROR;
|
||
|
||
subtitle_printf(50, "%d\n", command);
|
||
|
||
switch(command) {
|
||
case OUTPUT_OPEN: {
|
||
ret = subtitle_Open(context);
|
||
break;
|
||
}
|
||
case OUTPUT_CLOSE: {
|
||
ret = subtitle_Close(context);
|
||
break;
|
||
}
|
||
case OUTPUT_PLAY: {
|
||
ret = subtitle_Play(context);
|
||
break;
|
||
}
|
||
case OUTPUT_STOP: {
|
||
ret = subtitle_Stop(context);
|
||
break;
|
||
}
|
||
case OUTPUT_SWITCH: {
|
||
subtitle_err("Subtitle Switch not implemented\n");
|
||
ret = cERR_SUBTITLE_ERROR;
|
||
break;
|
||
}
|
||
case OUTPUT_GET_SUBTITLE_OUTPUT: {
|
||
SubtitleOutputDef_t* out = (SubtitleOutputDef_t*)argument;
|
||
out->screen_width = screen_width;
|
||
out->screen_height = screen_height;
|
||
out->shareFramebuffer = shareFramebuffer;
|
||
out->framebufferFD = framebufferFD;
|
||
out->destination = destination;
|
||
out->destStride = destStride;
|
||
break;
|
||
}
|
||
case OUTPUT_SET_SUBTITLE_OUTPUT: {
|
||
SubtitleOutputDef_t* out = (SubtitleOutputDef_t*)argument;
|
||
screen_width = out->screen_width;
|
||
screen_height = out->screen_height;
|
||
shareFramebuffer = out->shareFramebuffer;
|
||
framebufferFD = out->framebufferFD;
|
||
destination = out->destination;
|
||
destStride = out->destStride;
|
||
break;
|
||
}
|
||
case OUTPUT_SUBTITLE_REGISTER_FUNCTION: {
|
||
subtitle_SignalConnect(argument);
|
||
break;
|
||
}
|
||
case OUTPUT_SUBTITLE_REGISTER_BUFFER: {
|
||
subtitle_SignalConnectBuffer(argument);
|
||
break;
|
||
}
|
||
case OUTPUT_FLUSH: {
|
||
subtitle_err("Subtitle Flush not implemented\n");
|
||
ret = cERR_SUBTITLE_ERROR;
|
||
break;
|
||
}
|
||
case OUTPUT_PAUSE: {
|
||
subtitle_err("Subtitle Pause not implemented\n");
|
||
ret = cERR_SUBTITLE_ERROR;
|
||
break;
|
||
}
|
||
case OUTPUT_CONTINUE: {
|
||
subtitle_err("Subtitle Continue not implemented\n");
|
||
ret = cERR_SUBTITLE_ERROR;
|
||
break;
|
||
}
|
||
|
||
default:
|
||
subtitle_err("OutputCmd %d not supported!\n", command);
|
||
ret = cERR_SUBTITLE_ERROR;
|
||
break;
|
||
}
|
||
|
||
subtitle_printf(50, "exiting with value %d\n", ret);
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
static char *SubtitleCapabilitis[] = { "subtitle", NULL };
|
||
|
||
struct Output_s SubtitleOutput = {
|
||
"Subtitle",
|
||
&Command,
|
||
&Write,
|
||
SubtitleCapabilitis
|
||
};
|