bool Manager::initTrackUpdate()
{
ScopedLock m_lock(mutex);
for (std::map<int,Track*>::iterator it = audioTracks.begin(); it != audioTracks.end(); ++it)
it->second->inactive = !it->second->is_static;
for (std::map<int, Track*>::iterator it = videoTracks.begin(); it != videoTracks.end(); ++it)
it->second->inactive = !it->second->is_static;
for (std::map<int,Track*>::iterator it = subtitleTracks.begin(); it != subtitleTracks.end(); ++it)
it->second->inactive = !it->second->is_static;
for (std::map<int,Track*>::iterator it = teletextTracks.begin(); it != teletextTracks.end(); ++it)
it->second->inactive = !it->second->is_static;
return true;
}
int syncread_open(struct inode *inode, struct file *filp) {
int rc= 0;
m_lock(&mutex);
if (filp->f_mode & FMODE_WRITE) {
int rc;
printk("<1>open request for write\n");
/* Se debe esperar hasta que no hayan otros lectores o escritores */
pend_open_write++;
while (writing || readers>0) {
if (c_wait(&cond, &mutex)) {
pend_open_write--;
c_broadcast(&cond);
rc= -EINTR;
goto epilog;
}
}
writing= TRUE;
pend_open_write--;
curr_size= 0;
c_broadcast(&cond);
printk("<1>open for write successful\n");
}
else if (filp->f_mode & FMODE_READ) {
/* Para evitar la hambruna de los escritores, si nadie esta escribiendo
* pero hay escritores pendientes (esperan porque readers>0), los
* nuevos lectores deben esperar hasta que todos los lectores cierren
* el dispositivo e ingrese un nuevo escritor.
*/
while (!writing && pend_open_write>0) {
if (c_wait(&cond, &mutex)) {
rc= -EINTR;
goto epilog;
}
}
readers++;
printk("<1>open for read\n");
}
epilog:
m_unlock(&mutex);
return rc;
}
// Propagate the setting to the condition manager and to the setup
void DiscriSettingsWindow::propagate() {
std::lock_guard<std::mutex> m_lock(m_interface.m_conditions->getDiscriLock());
// Majority
m_interface.m_conditions->setChannelsMajority(m_box_majority->value());
for (int dc_id = 0; dc_id < m_interface.m_conditions->getNDiscriChannels(); dc_id++) {
// Include channel or not
m_interface.m_conditions->setDiscriChannelState(dc_id, m_discriChannels.at(dc_id).included->isChecked());
// Width
m_interface.m_conditions->setDiscriChannelWidth(dc_id, m_discriChannels.at(dc_id).width->value());
// Threshold
m_interface.m_conditions->setDiscriChannelThreshold(dc_id, m_discriChannels.at(dc_id).threshold->value());
}
// ask condition manager to propagate the settings to the setup
m_interface.m_conditions->propagateDiscriSettings();
}
bool CFEManager::Init()
{
CFrontend * fe;
unsigned short fekey;
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(mutex);
have_sat = have_cable = have_terr = false;
for(int i = 0; i < MAX_ADAPTERS; i++) {
for(int j = 0; j < MAX_FE; j++) {
fe = new CFrontend(j, i);
if(fe->Open()) {
fekey = MAKE_FE_KEY(i, j);
femap.insert(std::pair <unsigned short, CFrontend*> (fekey, fe));
INFO("add fe %d", fe->fenumber);
if(livefe == NULL)
livefe = fe;
if (fe->hasSat())
have_sat = true;
if (fe->hasCable())
have_cable = true;
if (fe->hasTerr())
have_terr = true;
} else
delete fe;
}
}
for (unsigned i = 0; i < MAX_DMX_UNITS; i++)
dmap.push_back(CFeDmx(i));
INFO("found %d frontends, %d demuxes\n", (int)femap.size(), (int)dmap.size());
/* for testing without a frontend, export SIMULATE_FE=1 */
if (femap.empty() && getenv("SIMULATE_FE")) {
INFO("SIMULATE_FE is set, adding dummy frontend for testing");
fe = new CFrontend(0,0);
fekey = MAKE_FE_KEY(0, 0);
femap.insert(std::pair <unsigned short, CFrontend*> (fekey, fe));
livefe = fe;
}
if (femap.empty())
return false;
return true;
}
int dvbsub_start(int pid)
#endif
{
#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE
isEplayer = _isEplayer;
if (isEplayer && !dvbsub_paused)
return 0;
#endif
if(!dvbsub_paused && !pid)
return 0;
if(pid && (pid != dvbsub_pid)) {
dvbsub_pause();
if(dvbSubtitleConverter)
dvbSubtitleConverter->Reset();
dvbsub_pid = pid;
pid_change_req = 1;
}
printf("[dvb-sub] start, stopped %d pid %x\n", dvbsub_stopped, dvbsub_pid);
if(dvbsub_pid) {
#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE
if (isEplayer) {
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(ass_mutex);
std::map<int,ASS_Track*>::iterator it = ass_map.find(dvbsub_pid);
if (it != ass_map.end())
ass_track = it->second;
else
ass_track = NULL; //FIXME
}
#endif
dvbsub_stopped = 0;
dvbsub_paused = false;
if(dvbSubtitleConverter)
dvbSubtitleConverter->Pause(false);
pthread_mutex_lock(&readerMutex);
pthread_cond_broadcast(&readerCond);
pthread_mutex_unlock(&readerMutex);
printf("[dvb-sub] started with pid 0x%x\n", dvbsub_pid);
}
return 1;
}
int *
__isAlarm()
{
int *al;
m_lock(&kLock);
if(!alarmKeyOnce) {
t_keycreate(&isAlarmKey, NULL);
++alarmKeyOnce;
}
m_unlock(&kLock);
t_getspecific(isAlarmKey, &al);
if( al == NULL ) {
al = calloc(1, sizeof(int));
t_setspecific(isAlarmKey, (void *)al);
}
return al;
}
int *
__isIOFailed()
{
int *io;
m_lock(&kLock);
if(!ioKeyOnce) {
t_keycreate(&ioFailedKey, NULL);
++ioKeyOnce;
}
m_unlock(&kLock);
t_getspecific(ioFailedKey, &io);
if( io == NULL ) {
io = calloc(1, sizeof(int));
t_setspecific(ioFailedKey, (void *)io);
}
return io;
}
struct sigaction *
__old_sa_alarm()
{
struct sigaction *sa;
m_lock(&kLock);
if(!saKeyOnce) {
t_keycreate(&sa_alarmKey, NULL);
++saKeyOnce;
}
m_unlock(&kLock);
t_getspecific(sa_alarmKey, &sa);
if( sa == NULL ) {
sa = calloc(1, sizeof(struct sigaction));
t_setspecific(sa_alarmKey, (void *)sa);
}
return sa;
}
void Manager::clearTracks()
{
ScopedLock m_lock(mutex);
for (std::map<int,Track*>::iterator it = audioTracks.begin(); it != audioTracks.end(); ++it)
delete it->second;
audioTracks.clear();
for (std::map<int, Track*>::iterator it = videoTracks.begin(); it != videoTracks.end(); ++it)
delete it->second;
videoTracks.clear();
for (std::map<int,Track*>::iterator it = subtitleTracks.begin(); it != subtitleTracks.end(); ++it)
delete it->second;
subtitleTracks.clear();
for (std::map<int,Track*>::iterator it = teletextTracks.begin(); it != teletextTracks.end(); ++it)
delete it->second;
teletextTracks.clear();
Programs.clear();
}
bool cYTCache::useCachedCopy(MI_MOVIE_INFO *mi)
{
std::string file = getName(mi);
if (access(file, R_OK))
return false;
std::string xml = getName(mi, "xml");
if (!access(xml, R_OK)) {
mi->file.Url = file;
return true;
}
{
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(mutex);
if (pending.empty())
return false;
MI_MOVIE_INFO m = pending.front();
if (compareMovieInfo(&m, mi)) {
mi->file.Url = file;
return true;
}
}
return false;
}
int bano_release(struct inode *inode, struct file *filp) {
m_lock(&mutex);
if (filp->f_mode & FMODE_WRITE) {
int dv = iminor(filp->f_inode);
if (dv == 0) {
// Esta saliendo una dama
printk("<1>close for write successful dama\n");
damas--;
} else {
// Esta saliendo un varon
printk("<1>close for write successful varon\n");
varones--;
}
c_broadcast(&cond);
}
else if (filp->f_mode & FMODE_READ) {
printk("<1>close for read \n");
}
m_unlock(&mutex);
return 0;
}
CFrontend * CFEManager::allocateFE(CZapitChannel * channel, bool forrecord)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(mutex);
if (forrecord)
fedebug = 1;
CFrontend * frontend = getFrontend(channel);
if (frontend) {
#ifdef DYNAMIC_DEMUX
int dnum = getDemux(channel->getTransponderId());
INFO("record demux: %d", dnum);
channel->setRecordDemux(dnum);
if (forrecord && !dnum) {
frontend = NULL;
} else {
cDemux::SetSource(dnum, frontend->fenumber);
}
#else
channel->setRecordDemux(frontend->fenumber+1);
channel->setPipDemux(frontend->fenumber+1);
#if HAVE_COOL_HARDWARE
/* I don't know if this check is necessary on cs, but it hurts on other hardware */
if(femap.size() > 1)
#endif
cDemux::SetSource(frontend->fenumber+1, frontend->fenumber);
#ifdef ENABLE_PIP
/* FIXME until proper demux management */
if (unused_demux)
channel->setPipDemux(unused_demux);
INFO("pip demux: %d", channel->getPipDemux());
#endif
#endif
}
return frontend;
}
ssize_t syncread_read(struct file *filp, char *buf,
size_t count, loff_t *f_pos) {
ssize_t rc;
m_lock(&mutex);
while (curr_size <= *f_pos && writing) {
/* si el lector esta en el final del archivo pero hay un proceso
* escribiendo todavia en el archivo, el lector espera.
*/
if (c_wait(&cond, &mutex)) {
printk("<1>read interrupted\n");
rc= -EINTR;
goto epilog;
}
}
if (count > curr_size-*f_pos) {
count= curr_size-*f_pos;
}
printk("<1>read %d bytes at %d\n", (int)count, (int)*f_pos);
/* Transfiriendo datos hacia el espacio del usuario */
if (copy_to_user(buf, syncread_buffer+*f_pos, count)!=0) {
/* el valor de buf es una direccion invalida */
rc= -EFAULT;
goto epilog;
}
*f_pos+= count;
rc= count;
epilog:
m_unlock(&mutex);
return rc;
}
bool CFEManager::unlockFrontend(CFrontend * frontend, bool unlock_demux)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(mutex);
have_locked = false;
frontend->Unlock();
if (unlock_demux) {
#ifdef DYNAMIC_DEMUX
for (unsigned int i = 1; i < dmap.size(); i++) {
if(dmap[i].tpid == frontend->getTsidOnid()) {
dmap[i].Unlock();
break;
}
}
#endif
}
for(fe_map_iterator_t it = femap.begin(); it != femap.end(); it++) {
CFrontend * fe = it->second;
if(fe->Locked()) {
have_locked = true;
break;
}
}
return true;
}
std::vector<MI_MOVIE_INFO> cYTCache::getPending(MI_MOVIE_INFO::miSource source, double *p_dltotal, double *p_dlnow, time_t *p_start)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(mutex);
std::vector<MI_MOVIE_INFO> res;
for (std::vector<MI_MOVIE_INFO>::iterator it = pending.begin(); it != pending.end(); ++it)
if ((*it).source == source)
res.push_back(*it);
if (!res.empty() && pending.front().source == source) {
if (p_dltotal)
*p_dltotal = dltotal;
if (p_dlnow)
*p_dlnow = dlnow;
if (p_start)
*p_start = dlstart;
} else {
if (p_dltotal)
*p_dltotal = 0;
if (p_dlnow)
*p_dlnow = 0;
if (p_start)
*p_start = 0;
}
return res;
}
void CFbAccel::blit()
{
#ifdef PARTIAL_BLIT
if (to_blit.xs == INT_MAX)
return;
int srcXa = to_blit.xs;
int srcYa = to_blit.ys;
int srcXb = to_blit.xe;
int srcYb = to_blit.ye;
#else
const int srcXa = 0;
const int srcYa = 0;
int srcXb = fb->xRes;
int srcYb = fb->yRes;
#endif
STMFBIO_BLT_DATA bltData;
memset(&bltData, 0, sizeof(STMFBIO_BLT_DATA));
bltData.operation = BLT_OP_COPY;
//bltData.ulFlags = BLT_OP_FLAGS_BLEND_SRC_ALPHA | BLT_OP_FLAGS_BLEND_DST_MEMORY; // we need alpha blending
// src
bltData.srcOffset = lbb_off;
bltData.srcPitch = fb->stride;
bltData.src_left = srcXa;
bltData.src_top = srcYa;
bltData.src_right = srcXb;
bltData.src_bottom = srcYb;
bltData.srcFormat = SURF_BGRA8888;
bltData.srcMemBase = STMFBGP_FRAMEBUFFER;
/* calculate dst/blit factor */
fb_var_screeninfo s;
if (ioctl(fb->fd, FBIOGET_VSCREENINFO, &s) == -1)
perror("CFbAccel <FBIOGET_VSCREENINFO>");
#ifdef PARTIAL_BLIT
if (s.xres != last_xres) /* fb resolution has changed -> clear artifacts */
{
last_xres = s.xres;
bltData.src_left = 0;
bltData.src_top = 0;
bltData.src_right = xRes;
bltData.src_bottom = yRes;
}
double xFactor = (double)s.xres/(double)xRes;
double yFactor = (double)s.yres/(double)yRes;
int desXa = xFactor * bltData.src_left;
int desYa = yFactor * bltData.src_top;
int desXb = xFactor * bltData.src_right;
int desYb = yFactor * bltData.src_bottom;
#else
const int desXa = 0;
const int desYa = 0;
int desXb = s.xres;
int desYb = s.yres;
#endif
/* dst */
bltData.dstOffset = 0;
bltData.dstPitch = s.xres * 4;
bltData.dst_left = desXa;
bltData.dst_top = desYa;
bltData.dst_right = desXb;
bltData.dst_bottom = desYb;
bltData.dstFormat = SURF_BGRA8888;
bltData.dstMemBase = STMFBGP_FRAMEBUFFER;
//printf("CFbAccel::blit: sx:%d sy:%d sxe:%d sye: %d dx:%d dy:%d dxe:%d dye:%d\n", srcXa, srcYa, srcXb, srcYb, desXa, desYa, desXb, desYb);
if ((bltData.dst_right > s.xres) || (bltData.dst_bottom > s.yres))
printf("CFbAccel::blit: values out of range desXb:%d desYb:%d\n",
bltData.dst_right, bltData.dst_bottom);
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(mutex);
if(ioctl(fb->fd, STMFBIO_SYNC_BLITTER) < 0)
perror("CFbAccel::blit ioctl STMFBIO_SYNC_BLITTER 1");
msync(lbb, fb->xRes * 4 * fb->yRes, MS_SYNC);
if (ioctl(fb->fd, STMFBIO_BLT, &bltData ) < 0)
perror("STMFBIO_BLT");
if(ioctl(fb->fd, STMFBIO_SYNC_BLITTER) < 0)
perror("CFbAccel::blit ioctl STMFBIO_SYNC_BLITTER 2");
#ifdef PARTIAL_BLIT
to_blit.xs = to_blit.ys = INT_MAX;
to_blit.xe = to_blit.ye = 0;
#endif
}
void CFbAccel::blit()
{
#ifdef ENABLE_GRAPHLCD
nGLCD::Blit();
#endif
msync(lbb, DEFAULT_XRES * 4 * DEFAULT_YRES, MS_SYNC);
if (borderColor != borderColorOld || (borderColor != 0x00000000 && borderColor != 0xFF000000)) {
borderColorOld = borderColor;
switch(fb->mode3D) {
case CFrameBuffer::Mode3D_off:
default:
blitBoxFB(0, 0, s.xres, sY, borderColor); // top
blitBoxFB(0, 0, sX, s.yres, borderColor); // left
blitBoxFB(eX, 0, s.xres, s.yres, borderColor); // right
blitBoxFB(0, eY, s.xres, s.yres, borderColor); // bottom
break;
case CFrameBuffer::Mode3D_SideBySide:
blitBoxFB(0, 0, s.xres, sY, borderColor); // top
blitBoxFB(0, 0, sX/2, s.yres, borderColor); // left
blitBoxFB(eX/2 + 1, 0, s.xres/2 + sX/2, s.yres, borderColor); // middle
blitBoxFB(s.xres/2 + eX/2 + 1, 0, s.xres, s.yres, borderColor); // right
blitBoxFB(0, eY, s.xres, s.yres, borderColor); // bottom
break;
case CFrameBuffer::Mode3D_TopAndBottom:
blitBoxFB(0, 0, s.xres, sY/2, borderColor); // top
blitBoxFB(0, eY/2 + 1, s.xres, s.yres/2 + sY/2, borderColor); // middle
blitBoxFB(0, s.yres/2 + eY/2 + 1, s.xres, s.yres, borderColor); // bottom
blitBoxFB(0, 0, sX, s.yres, borderColor); // left
blitBoxFB(eX, 0, s.xres, s.yres, borderColor); // right
break;
case CFrameBuffer::Mode3D_Tile:
blitBoxFB(0, 0, (s.xres * 2)/3, (sY * 2)/3, borderColor); // top
blitBoxFB(0, 0, (sX * 2)/3, (s.yres * 2)/3, borderColor); // left
blitBoxFB((eX * 2)/3, 0, (s.xres * 2)/3, (s.yres * 2)/3, borderColor); // right
blitBoxFB(0, (eY * 2)/3, (s.xres * 2)/3, (s.yres * 2)/3, borderColor); // bottom
break;
}
}
switch(fb->mode3D) {
case CFrameBuffer::Mode3D_off:
default:
blitBB2FB(0, 0, DEFAULT_XRES, DEFAULT_YRES, sX, sY, eX, eY);
break;
case CFrameBuffer::Mode3D_SideBySide:
blitBB2FB(0, 0, DEFAULT_XRES, DEFAULT_YRES, sX/2, sY, eX/2, eY);
blitBB2FB(0, 0, DEFAULT_XRES, DEFAULT_YRES, s.xres/2 + sX/2, sY, s.xres/2 + eX/2, eY);
break;
case CFrameBuffer::Mode3D_TopAndBottom:
blitBB2FB(0, 0, DEFAULT_XRES, DEFAULT_YRES, sX, sY/2, eX, eY/2);
blitBB2FB(0, 0, DEFAULT_XRES, DEFAULT_YRES, sX, s.yres/2 + sY/2, eX, s.yres/2 + eY/2);
break;
case CFrameBuffer::Mode3D_Tile:
blitBB2FB(0, 0, DEFAULT_XRES, DEFAULT_YRES, (sX * 2)/3, (sY * 2)/3, (eX * 2)/3, (eY * 2)/3);
blitFB2FB(0, 0, s.xres/3, (s.yres * 2)/3, (s.xres * 2)/3, 0, s.xres, (s.yres * 2)/3);
blitFB2FB(s.xres/3, 0, (s.xres * 2)/3, s.yres/3, 0, (s.yres * 2)/3, s.xres/3, s.yres);
blitFB2FB(s.xres/3, s.yres/3, (s.xres * 2)/3, (s.yres * 2)/3, s.xres/3, (s.yres * 2)/3, (s.xres * 2)/3, s.yres);
break;
}
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(mutex);
if(ioctl(fb->fd, STMFBIO_SYNC_BLITTER) < 0)
perror("CFrameBuffer::blit ioctl STMFBIO_SYNC_BLITTER 2");
}
void CFbAccel::blit2FB(void *fbbuff, uint32_t width, uint32_t height, uint32_t xoff, uint32_t yoff, uint32_t xp, uint32_t yp, bool transp)
{
#if !HAVE_SPARK_HARDWARE && !HAVE_DUCKBOX_HARDWARE
int xc, yc;
xc = (width > fb->xRes) ? fb->xRes : width;
yc = (height > fb->yRes) ? fb->yRes : height;
#endif
#ifdef USE_NEVIS_GXA
(void)transp;
u32 cmd;
void *uKva;
uKva = cs_phys_addr(fbbuff);
//printf("CFbAccel::blit2FB: data %x Kva %x\n", (int) fbbuff, (int) uKva);
if (uKva != NULL) {
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(mutex);
cmd = GXA_CMD_BLT | GXA_CMD_NOT_TEXT | GXA_SRC_BMP_SEL(1) | GXA_DST_BMP_SEL(2) | GXA_PARAM_COUNT(3);
_write_gxa(gxa_base, GXA_BMP1_TYPE_REG, (3 << 16) | width);
_write_gxa(gxa_base, GXA_BMP1_ADDR_REG, (unsigned int)uKva);
_write_gxa(gxa_base, cmd, GXA_POINT(xoff, yoff)); /* destination pos */
_write_gxa(gxa_base, cmd, GXA_POINT(xc, yc)); /* source width, FIXME real or adjusted xc, yc ? */
_write_gxa(gxa_base, cmd, GXA_POINT(xp, yp)); /* source pos */
return;
}
#elif HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE
int x, y, dw, dh;
x = xoff;
y = yoff;
dw = width - xp;
dh = height - yp;
size_t mem_sz = width * height * sizeof(fb_pixel_t);
unsigned long ulFlags = 0;
if (!transp) /* transp == false (default): use transparency from source alphachannel */
ulFlags = BLT_OP_FLAGS_BLEND_SRC_ALPHA|BLT_OP_FLAGS_BLEND_DST_MEMORY; // we need alpha blending
STMFBIO_BLT_EXTERN_DATA blt_data;
memset(&blt_data, 0, sizeof(STMFBIO_BLT_EXTERN_DATA));
blt_data.operation = BLT_OP_COPY;
blt_data.ulFlags = ulFlags;
blt_data.srcOffset = 0;
blt_data.srcPitch = width * 4;
blt_data.dstOffset = lbb_off;
blt_data.dstPitch = fb->stride;
blt_data.src_left = xp;
blt_data.src_top = yp;
blt_data.src_right = width;
blt_data.src_bottom = height;
blt_data.dst_left = x;
blt_data.dst_top = y;
blt_data.dst_right = x + dw;
blt_data.dst_bottom = y + dh;
blt_data.srcFormat = SURF_ARGB8888;
blt_data.dstFormat = SURF_ARGB8888;
blt_data.srcMemBase = (char *)backbuffer;
blt_data.dstMemBase = (char *)fb->lfb;
blt_data.srcMemSize = mem_sz;
blt_data.dstMemSize = fb->stride * fb->yRes + lbb_off;
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(mutex);
#if 0
ioctl(fb->fd, STMFBIO_SYNC_BLITTER);
#endif
if (fbbuff != backbuffer)
memmove(backbuffer, fbbuff, mem_sz);
// icons are so small that they will still be in cache
msync(backbuffer, backbuf_sz, MS_SYNC);
if (ioctl(fb->fd, STMFBIO_BLT_EXTERN, &blt_data) < 0)
perror("CFbAccel blit2FB STMFBIO_BLT_EXTERN");
return;
#else
fb_pixel_t *data = (fb_pixel_t *) fbbuff;
uint8_t *d = (uint8_t *)lbb + xoff * sizeof(fb_pixel_t) + fb->stride * yoff;
fb_pixel_t * d2;
for (int count = 0; count < yc; count++ ) {
fb_pixel_t *pixpos = &data[(count + yp) * width];
d2 = (fb_pixel_t *) d;
for (int count2 = 0; count2 < xc; count2++ ) {
fb_pixel_t pix = *(pixpos + xp);
if (transp || (pix & 0xff000000) == 0xff000000)
*d2 = pix;
else {
uint8_t *in = (uint8_t *)(pixpos + xp);
uint8_t *out = (uint8_t *)d2;
int a = in[3]; /* TODO: big/little endian */
*out = (*out + ((*in - *out) * a) / 256);
in++; out++;
*out = (*out + ((*in - *out) * a) / 256);
in++; out++;
*out = (*out + ((*in - *out) * a) / 256);
}
d2++;
pixpos++;
}
d += fb->stride;
}
#endif
}
void CFbAccel::paintLine(int xa, int ya, int xb, int yb, const fb_pixel_t col)
{
#if HAVE_TRIPLEDRAGON
setColor(col);
dfbdest->DrawLine(dfbdest, xa, ya, xb, yb);
#elif defined(USE_NEVIS_GXA)
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(mutex);
/* draw a single vertical line from point xa/ya to xb/yb */
unsigned int cmd = GXA_CMD_NOT_TEXT | GXA_SRC_BMP_SEL(2) | GXA_DST_BMP_SEL(2) | GXA_PARAM_COUNT(2) | GXA_CMD_NOT_ALPHA;
setColor(col);
_write_gxa(gxa_base, GXA_LINE_CONTROL_REG, 0x00000404); /* X is major axis, skip last pixel */
_write_gxa(gxa_base, cmd, GXA_POINT(xb, yb)); /* end point */
_write_gxa(gxa_base, cmd, GXA_POINT(xa, ya)); /* start point */
#else
int dx = abs (xa - xb);
int dy = abs (ya - yb);
if (dy == 0) /* horizontal line */
{
/* paintRect actually is 1 pixel short to the right,
* but that's bug-compatibility with the GXA code */
paintRect(xa, ya, xb - xa, 1, col);
return;
}
if (dx == 0) /* vertical line */
{
paintRect(xa, ya, 1, yb - ya, col);
return;
}
int x;
int y;
int End;
int step;
if (dx > dy)
{
int p = 2 * dy - dx;
int twoDy = 2 * dy;
int twoDyDx = 2 * (dy-dx);
if (xa > xb)
{
x = xb;
y = yb;
End = xa;
step = ya < yb ? -1 : 1;
}
else
{
x = xa;
y = ya;
End = xb;
step = yb < ya ? -1 : 1;
}
paintPixel(x, y, col);
while (x < End)
{
x++;
if (p < 0)
p += twoDy;
else
{
y += step;
p += twoDyDx;
}
paintPixel(x, y, col);
}
}
else
{
int p = 2 * dx - dy;
int twoDx = 2 * dx;
int twoDxDy = 2 * (dx-dy);
if (ya > yb)
{
x = xb;
y = yb;
End = ya;
step = xa < xb ? -1 : 1;
}
else
{
x = xa;
y = ya;
End = yb;
step = xb < xa ? -1 : 1;
}
paintPixel(x, y, col);
while (y < End)
{
y++;
if (p < 0)
p += twoDx;
else
{
x += step;
p += twoDxDy;
}
paintPixel(x, y, col);
}
}
#endif
}
void CFbAccel::paintRect(const int x, const int y, const int dx, const int dy, const fb_pixel_t col)
{
#if HAVE_TRIPLEDRAGON
setColor(col);
dfbdest->FillRectangle(dfbdest, x, y, dx, dy);
#elif defined(USE_NEVIS_GXA)
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(mutex);
unsigned int cmd = GXA_CMD_BLT | GXA_CMD_NOT_TEXT | GXA_CMD_NOT_ALPHA |
GXA_SRC_BMP_SEL(6) | GXA_DST_BMP_SEL(2) | GXA_PARAM_COUNT(2);
_write_gxa(gxa_base, GXA_BG_COLOR_REG, (unsigned int)col); /* setup the drawing color */
_write_gxa(gxa_base, GXA_BMP6_TYPE_REG, (3 << 16) | (1 << 27)); /* 3 == 32bpp, 1<<27 == fill */
_write_gxa(gxa_base, cmd, GXA_POINT(x, y)); /* destination pos */
_write_gxa(gxa_base, cmd, GXA_POINT(dx, dy)); /* destination size */
_write_gxa(gxa_base, GXA_BG_COLOR_REG, (unsigned int)fb->backgroundColor);
/* the GXA seems to do asynchronous rendering, so we add a sync marker
to which the fontrenderer code can synchronize */
add_gxa_sync_marker();
#elif HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE
if (dx <= 0 || dy <= 0)
return;
// The STM blitter introduces considerable overhead probably worth for small areas. --martii
if (dx * dy < DEFAULT_XRES * 4) {
waitForIdle();
fb_pixel_t *fbs = fb->getFrameBufferPointer() + (DEFAULT_XRES * y) + x;
fb_pixel_t *fbe = fbs + DEFAULT_XRES * (dy - 1) + dx;
int off = DEFAULT_XRES - dx;
while (fbs < fbe) {
fb_pixel_t *ex = fbs + dx;
while (fbs < ex)
*fbs++ = col;
fbs += off;
}
return;
}
/* function has const parameters, so copy them here... */
int width = dx;
int height = dy;
int xx = x;
int yy = y;
/* maybe we should just return instead of fixing this up... */
if (x < 0) {
fprintf(stderr, "[neutrino] fb::%s: x < 0 (%d)\n", __func__, x);
width += x;
if (width <= 0)
return;
xx = 0;
}
if (y < 0) {
fprintf(stderr, "[neutrino] fb::%s: y < 0 (%d)\n", __func__, y);
height += y;
if (height <= 0)
return;
yy = 0;
}
int right = xx + width;
int bottom = yy + height;
if (right > (int)fb->xRes) {
if (xx >= (int)fb->xRes) {
fprintf(stderr, "[neutrino] fb::%s: x >= xRes (%d > %d)\n", __func__, xx, fb->xRes);
return;
}
fprintf(stderr, "[neutrino] fb::%s: x+w > xRes! (%d+%d > %d)\n", __func__, xx, width, fb->xRes);
right = fb->xRes;
}
if (bottom > (int)fb->yRes) {
if (yy >= (int)fb->yRes) {
fprintf(stderr, "[neutrino] fb::%s: y >= yRes (%d > %d)\n", __func__, yy, fb->yRes);
return;
}
fprintf(stderr, "[neutrino] fb::%s: y+h > yRes! (%d+%d > %d)\n", __func__, yy, height, fb->yRes);
bottom = fb->yRes;
}
STMFBIO_BLT_DATA bltData;
memset(&bltData, 0, sizeof(STMFBIO_BLT_DATA));
bltData.operation = BLT_OP_FILL;
bltData.dstOffset = lbb_off;
bltData.dstPitch = fb->stride;
bltData.dst_left = xx;
bltData.dst_top = yy;
bltData.dst_right = right;
bltData.dst_bottom = bottom;
bltData.dstFormat = SURF_ARGB8888;
bltData.srcFormat = SURF_ARGB8888;
bltData.dstMemBase = STMFBGP_FRAMEBUFFER;
bltData.srcMemBase = STMFBGP_FRAMEBUFFER;
bltData.colour = col;
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(mutex);
if (ioctl(fb->fd, STMFBIO_BLT, &bltData ) < 0)
fprintf(stderr, "blitRect FBIO_BLIT: %m x:%d y:%d w:%d h:%d s:%d\n", xx,yy,width,height,fb->stride);
#else
int line = 0;
int swidth = fb->stride / sizeof(fb_pixel_t);
fb_pixel_t *fbp = fb->getFrameBufferPointer() + (swidth * y);
int pos;
while (line < dy)
{
for (pos = x; pos < x + dx; pos++)
*(fbp + pos) = col;
fbp += swidth;
line++;
}
#endif
}
void CFbAccel::waitForIdle(void)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(mutex);
ioctl(fb->fd, STMFBIO_SYNC_BLITTER);
}
static void* dvbsub_thread(void* /*arg*/)
{
struct timespec restartWait;
struct timeval now;
set_threadname("dvbsub:main");
sub_debug.print(Debug::VERBOSE, "%s started\n", __FUNCTION__);
if (!dvbSubtitleConverter)
dvbSubtitleConverter = new cDvbSubtitleConverter;
int timeout = 1000000;
#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE
CFrameBuffer *fb = CFrameBuffer::getInstance();
int xres = fb->getScreenWidth(true);
int yres = fb->getScreenHeight(true);
int clr_x0 = xres, clr_y0 = yres, clr_x1 = 0, clr_y1 = 0;
uint32_t colortable[256];
memset(colortable, 0, sizeof(colortable));
uint32_t last_color = 0;
#endif
while(dvbsub_running) {
#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE
if (ass_track) {
usleep(100000); // FIXME ... should poll instead
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(ass_mutex);
if (!ass_track)
continue;
if (ass_size != sub_font_size) {
ass_size = sub_font_size;
ass_set_font_scale(ass_renderer, ((double) ass_size)/ASS_CUSTOM_FONT_SIZE);
}
int detect_change = 0;
int64_t pts;
getPlayerPts(&pts);
ASS_Image *image = ass_render_frame(ass_renderer, ass_track, pts/90, &detect_change);
if (detect_change) {
if (clr_x1 && clr_y1) {
fb->paintBox(clr_x0, clr_y0, clr_x1 + 1, clr_y1 + 1, 0);
clr_x0 = xres;
clr_y0 = yres;
clr_x1 = clr_y1 = 0;
}
while (image) {
if (last_color != image->color) {
last_color = image->color;
uint32_t c = last_color >> 8, a = 255 - (last_color & 0xff);
for (int i = 0; i < 256; i++) {
uint32_t k = (a * i) >> 8;
colortable[i] = k ? (c | (k << 24)) : 0;
}
}
if (image->w && image->h && image->dst_x > -1 && image->dst_x + image->w < xres && image->dst_y > -1 && image->dst_y + image->h < yres) {
if (image->dst_x < clr_x0)
clr_x0 = image->dst_x;
if (image->dst_y < clr_y0)
clr_y0 = image->dst_y;
if (image->dst_x + image->w > clr_x1)
clr_x1 = image->dst_x + image->w;
if (image->dst_y + image->h > clr_y1)
clr_y1 = image->dst_y + image->h;
uint32_t *lfb = fb->getFrameBufferPointer() + image->dst_x + xres * image->dst_y;
unsigned char *bm = image->bitmap;
int bm_add = image->stride - image->w;
int lfb_add = xres - image->w;
for (int y = 0; y < image->h; y++) {
for (int x = 0; x < image->w; x++) {
if (*bm)
*lfb = colortable[*bm];
lfb++, bm++;
}
lfb += lfb_add;
bm += bm_add;
}
}
image = image->next;
}
fb->getInstance()->blit();
}
continue;
} else {
if (clr_x1 && clr_y1) {
static void *ass_reader_thread(void *)
{
set_threadname("ass_reader_thread");
while (!sem_wait(&ass_sem)) {
if (!ass_reader_running)
break;
ass_data *a = (ass_data *) ass_queue.pop();
if (!a) {
if (!ass_reader_running)
break;
continue;
}
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(ass_mutex);
std::map<int,ASS_Track*>::iterator it = ass_map.find(a->pid);
ASS_Track *track;
if (it == ass_map.end()) {
CFrameBuffer *fb = CFrameBuffer::getInstance();
int xres = fb->getScreenWidth(true);
int yres = fb->getScreenHeight(true);
if (!ass_library) {
ass_library = ass_library_init();
ass_set_extract_fonts(ass_library, 1);
ass_set_style_overrides(ass_library, NULL);
ass_renderer = ass_renderer_init(ass_library);
ass_set_frame_size(ass_renderer, xres, yres);
ass_set_margins(ass_renderer, 3 * yres / 100, 3 * yres / 100, 3 * xres / 100, 3 * xres / 100);
ass_set_use_margins(ass_renderer, 1);
ass_set_hinting(ass_renderer, ASS_HINTING_LIGHT);
ass_set_aspect_ratio(ass_renderer, 1.0, 1.0);
ass_font = *sub_font_file;
ass_set_fonts(ass_renderer, ass_font.c_str(), "Arial", 0, NULL, 1);
}
track = ass_new_track(ass_library);
track->PlayResX = xres;
track->PlayResY = yres;
ass_size = sub_font_size;
ass_set_font_scale(ass_renderer, ((double) ass_size)/ASS_CUSTOM_FONT_SIZE);
if (a->c->subtitle_header) {
std::string ass_hdr = ass_subtitle_header_default();
if (ass_hdr.compare((char*) a->c->subtitle_header)) {
ass_process_codec_private(track, (char *) a->c->subtitle_header, a->c->subtitle_header_size);
} else {
// This is the FFMPEG default ASS header. Use something more suitable instead:
ass_hdr = ass_subtitle_header_custom();
ass_process_codec_private(track, (char *) ass_hdr.c_str(), ass_hdr.length());
}
}
ass_map[a->pid] = track;
if (a->pid == dvbsub_pid)
ass_track = track;
//fprintf(stderr, "### got subtitle track %d, subtitle header: \n---\n%s\n---\n", pid, c->subtitle_header);
} else
track = it->second;
for (unsigned int i = 0; i < a->sub.num_rects; i++)
if (a->sub.rects[i]->ass)
ass_process_data(track, a->sub.rects[i]->ass, strlen(a->sub.rects[i]->ass));
avsubtitle_free(&a->sub);
delete a;
}
ass_reader_running = false;
pthread_exit(NULL);
}
bool Manager::selectProgram(const int id)
{
ScopedLock m_lock(mutex);
std::map<int,Program>::iterator i = Programs.find(id);
if (i != Programs.end()) {
// mark all tracks as hidden
for (std::map<int,Track*>::iterator it = audioTracks.begin(); it != audioTracks.end(); ++it)
it->second->hidden = true;
for (std::map<int, Track*>::iterator it = videoTracks.begin(); it != videoTracks.end(); ++it)
it->second->hidden = true;
for (std::map<int,Track*>::iterator it = subtitleTracks.begin(); it != subtitleTracks.end(); ++it)
it->second->hidden = true;
for (std::map<int,Track*>::iterator it = teletextTracks.begin(); it != teletextTracks.end(); ++it)
it->second->hidden = true;
// unhide tracks that are part of the selected program
for (unsigned int j = 0; j < i->second.streams.size(); j++) {
AVStream *stream = i->second.streams[j];
bool h = true;
for (std::map<int,Track*>::iterator it = audioTracks.begin(); h && (it != audioTracks.end()); ++it)
if (stream == it->second->stream)
h = it->second->hidden = false;
if (!h)
continue;
for (std::map<int, Track*>::iterator it = videoTracks.begin(); h && (it != videoTracks.end()); ++it)
if (stream == it->second->stream)
h = it->second->hidden = false;
if (!h)
continue;
for (std::map<int,Track*>::iterator it = subtitleTracks.begin(); h && (it != subtitleTracks.end()); ++it)
if (stream == it->second->stream)
h = it->second->hidden = false;
if (!h)
continue;
for (std::map<int,Track*>::iterator it = teletextTracks.begin(); h && (it != teletextTracks.end()); ++it)
if (stream == it->second->stream)
h = it->second->hidden = false;
}
// tell ffmpeg what we're interested in
for (std::map<int,Track*>::iterator it = audioTracks.begin(); it != audioTracks.end(); ++it)
if (it->second->hidden || it->second->inactive) {
it->second->stream->discard = AVDISCARD_ALL;
} else {
it->second->stream->discard = AVDISCARD_NONE;
player->input.SwitchAudio(it->second);
}
for (std::map<int, Track*>::iterator it = videoTracks.begin(); it != videoTracks.end(); ++it)
if (it->second->hidden || it->second->inactive) {
it->second->stream->discard = AVDISCARD_ALL;
} else {
it->second->stream->discard = AVDISCARD_NONE;
player->input.SwitchVideo(it->second);
}
for (std::map<int,Track*>::iterator it = subtitleTracks.begin(); it != subtitleTracks.end(); ++it)
if (it->second->hidden || it->second->inactive) {
it->second->stream->discard = AVDISCARD_ALL;
} else {
it->second->stream->discard = AVDISCARD_NONE;
player->input.SwitchSubtitle(it->second);
}
for (std::map<int,Track*>::iterator it = teletextTracks.begin(); it != teletextTracks.end(); ++it)
if (it->second->hidden || it->second->inactive) {
it->second->stream->discard = AVDISCARD_ALL;
} else {
it->second->stream->discard = AVDISCARD_NONE;
player->input.SwitchTeletext(it->second);
}
return true;
}
return false;
}
void func(const char* name, int mokey)
{
boost::mutex m_mutex;
boost::mutex::scoped_lock m_lock(m_mutex);
std::cout << name << ": make money " << mokey << "a day" << std::endl;
}
int bano_open(struct inode *inode, struct file *filp) {
int rc= 0;
m_lock(&mutex);
if (filp->f_mode & FMODE_WRITE) {
int dv = iminor(filp->f_inode);
int rc;
if (dv == 0) {
// Esta entrando una dama
printk("<1>open request for write dama\n");
while (varones > 0) {
printk("no cacho 1");
if (c_wait(&cond, &mutex)) {
c_broadcast(&cond);
rc= -EINTR;
if (damas == 0) {
damas_pos = 0;
}
damas++;
goto epilog;
}
}
if (damas == 0) {
damas_pos = 0;
}
damas++;
curr_size_d = 0;
printk("no cacho 2");
c_broadcast(&cond);
printk("<1>open for write successful damas: %d \n", damas);
} else {
// Esta entrando un varon
printk("<1>open request for write varon\n");
while (damas > 0) {
if (c_wait(&cond, &mutex)) {
c_broadcast(&cond);
rc= -EINTR;
if (varones == 0) {
varones_pos = 0;
}
varones++;
goto epilog;
}
}
if (varones == 0) {
varones_pos = 0;
}
varones++;
curr_size_v= 0;
c_broadcast(&cond);
printk("<1>open for write successful varones: %d\n", varones);
}
}
else if (filp->f_mode & FMODE_READ) {
printk("<1>open for read\n");
}
epilog:
m_unlock(&mutex);
return rc;
}
void Player::SetChapters(std::vector<Chapter> &Chapters)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(chapterMutex);
chapters = Chapters;
}
int CFEManager::getEnabledCount()
{
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(mutex);
return enabled_count;
}
void CFEManager::unlockDemux(int i)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(mutex);
if ((unsigned int) i < dmap.size())
dmap[i].Unlock();
}
ssize_t bano_read(struct file *filp, char *buf, size_t count, loff_t *f_pos) {
ssize_t rc;
int dv;
m_lock(&mutex);
dv = iminor(filp->f_inode);
if (dv == 0) {
// Dama
while (curr_size_d <= *f_pos && damas > 0) {
printk("What? \n");
/* si el lector esta en el final del archivo pero hay un proceso
* escribiendo todavia en el archivo, el lector espera.
*/
if (c_wait(&cond, &mutex)) {
printk("<1>read interrupted\n");
rc= -EINTR;
goto epilog;
}
}
printk("Curresize: %d\n", (int) curr_size_d);
printk("Damas: %d\n", damas);
if (count > curr_size_d-*f_pos) {
count= curr_size_d-*f_pos;
}
printk("<1>read %d bytes at (damas) %d\n", (int)count, (int)*f_pos);
/* Transfiriendo datos hacia el espacio del usuario */
if (copy_to_user(buf, buffer_d+*f_pos, count)!=0) {
/* el valor de buf es una direccion invalida */
rc= -EFAULT;
goto epilog;
}
} else {
// Varon
while (curr_size_v <= *f_pos && varones > 0) {
printk("What? \n");
/* si el lector esta en el final del archivo pero hay un proceso
* escribiendo todavia en el archivo, el lector espera.
*/
if (c_wait(&cond, &mutex)) {
printk("<1>read interrupted\n");
rc= -EINTR;
goto epilog;
}
}
printk("Curresize: %d\n", (int) curr_size_v);
printk("Varones: %d\n", varones);
if (count > curr_size_v-*f_pos) {
count= curr_size_v-*f_pos;
}
printk("<1>read %d bytes at (varones) %d\n", (int)count, (int)*f_pos);
/* Transfiriendo datos hacia el espacio del usuario */
if (copy_to_user(buf, buffer_v+*f_pos, count)!=0) {
/* el valor de buf es una direccion invalida */
rc= -EFAULT;
goto epilog;
}
}
*f_pos+= count;
rc= count;
epilog:
m_unlock(&mutex);
return rc;
}
