int main (int argc, char **argv)
{
int rv='X',i;
char *key=NULL;
int tmo=0;
	InitRC();
	for(i=1; i<argc; i++)
	{
		if(strstr(argv[i],"key=")==argv[i])
		{
			key=argv[i]+4;
		}
		if(strstr(argv[i],"timeout=")==argv[i])
		{
			if(sscanf(argv[i]+8,"%d",&tmo)!=1)
			{
				tmo=0;
			}
		}
	}

	rv=GetRCCode(key, tmo);
	
	CloseRC();

	printf("%c\n",rv);
	return rv;
}
Beispiel #2
0
int GetRCCodeNW(void)
{
  return GetRCCode();
}
int main (int argc, char **argv)
{
	int i,j,found=0,m,mask=1,kmode=1,pmode=0, lc=-1, changed=0, todo=1, help=1, help_changed=0, move=0;
	unsigned char actchan[20]=""/*,channel[128]=""*/;
	FILE *fh,*fh2;
	char *cpt1,*cpt2;
	gpixel mp, mc[MAX_MASK], tp;
	int tsx=430, tsy=120, tdy=24, tsz=28, txw=500, tcol=TURQUOISE;
	int xp[MAX_MASK][8],yp[MAX_MASK][8],xw[MAX_MASK][8],yw[MAX_MASK][8],valid[MAX_MASK],cmc[MAX_MASK],xxp,xxw,yyp,yyw,nmsk=0,amsk=0;
	double xs=1.0, ys=1.0;
	time_t t1,t2;

		for(j=0; j<MAX_MASK; j++)
		{
			valid[j]=0;
			cmc[j]=BLACK;
			make_color(BLACK, &mc[j]);
			for(i=0; i<8; i++)
			{
				xp[j][i]=(1280-40)/2;
				xw[j][i]=40;
				yp[j][i]=(720-20)/2;
				yw[j][i]=20;
			}	
		}
		system("pzapit -var > /tmp/logomaskset.stat");
		if((fh=fopen("/tmp/logomaskset.stat","r"))!=NULL)
		{
			if(fgets(tstr,500,fh))
			{
				TrimString(tstr);
				if(strlen(tstr))
				{
					if(sscanf(tstr+strlen(tstr)-1,"%d",&pmode)!=1)
					{
						pmode=0;
					}
				}
			}
			fclose(fh);
		}
	
		system("touch /tmp/.logomask_kill");

		fb = open(FB_DEVICE, O_RDWR);

		if(ioctl(fb, FBIOGET_FSCREENINFO, &fix_screeninfo) == -1)
		{
			printf("logomask <FBIOGET_FSCREENINFO failed>\n");
			return -1;
		}
		if(ioctl(fb, FBIOGET_VSCREENINFO, &var_screeninfo) == -1)
		{
			printf("logomask <FBIOGET_VSCREENINFO failed>\n");
			return -1;
		}
		
		if(!(lfb = (unsigned char*)mmap(0, fix_screeninfo.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fb, 0)))
		{
			printf("logomask <mapping of Framebuffer failed>\n");
			return -1;
		}

	//init fontlibrary

		if((error = FT_Init_FreeType(&library)))
		{
			printf("logomask <FT_Init_FreeType failed with Errorcode 0x%.2X>", error);
			munmap(lfb, fix_screeninfo.smem_len);
			return -1;
		}

		if((error = FTC_Manager_New(library, 1, 2, 0, &MyFaceRequester, NULL, &manager)))
		{
			printf("logomask <FTC_Manager_New failed with Errorcode 0x%.2X>\n", error);
			FT_Done_FreeType(library);
			munmap(lfb, fix_screeninfo.smem_len);
			return -1;
		}

		if((error = FTC_SBitCache_New(manager, &cache)))
		{
			printf("logomask <FTC_SBitCache_New failed with Errorcode 0x%.2X>\n", error);
			FTC_Manager_Done(manager);
			FT_Done_FreeType(library);
			munmap(lfb, fix_screeninfo.smem_len);
			return -1;
		}

		if((error = FTC_Manager_LookupFace(manager, FONT, &face)))
		{
			printf("logomask <FTC_Manager_Lookup_Face failed with Errorcode 0x%.2X>\n", error);
			FTC_Manager_Done(manager);
			FT_Done_FreeType(library);
			munmap(lfb, fix_screeninfo.smem_len);
			return -1;
		}

		use_kerning = FT_HAS_KERNING(face);

		desc.face_id = FONT;
		desc.flags = FT_LOAD_MONOCHROME;


		InitRC();

	//init backbuffer

		if(!(lbb = malloc(fix_screeninfo.line_length*var_screeninfo.yres)))
		{
			printf("logomask <allocating of Backbuffer failed>\n");
			munmap(lfb, fix_screeninfo.smem_len);
			return -1;
		}

		memset(lbb, 0, fix_screeninfo.line_length*var_screeninfo.yres);

		system("pzapit -gi > /tmp/logomask.chan");
		if((fh=fopen("/tmp/logomask.chan","r"))!=NULL)
		{
			if(fgets(tstr, BUFSIZE, fh))
			{
				TrimString(tstr);
				if((cpt1=strchr(tstr,' '))!=NULL)
					*cpt1=0;
			}
			fclose(fh);
			if(strlen(tstr))
			{
				strcpy(actchan,tstr);
			}

			if((fh=fopen(CFG_FILE,"r"))!=NULL)
			{
				found=0;
				while(fgets(tstr, BUFSIZE, fh) && !found)
				{
					TrimString(tstr);
					if(strlen(tstr))
					{
						if(strstr(tstr,actchan)!=NULL)
						{
							mask=1;
							nmsk=0;
							cpt2=strstr(tstr,",MC");
							if((cpt1=strchr(tstr,','))!=NULL)
							{
								while(cpt1)
								{
									valid[nmsk]=0;
									if(cpt2 && sscanf(cpt2+1,"MC%8X",&mp.lpixel)==1)
									{
										cpt2=strchr(cpt2+1,',');
									}
									else
									{
										make_color(BLACK, &mp);
									}
									for(i=0; i<8 && cpt1; i++)
									{
										cpt1++;
										if(sscanf(cpt1,"%d,%d,%d,%d",&xxp,&xxw,&yyp,&yyw)==4)
										{
											xp[nmsk][i]=xxp;
											xw[nmsk][i]=xxw;
											yp[nmsk][i]=yyp;
											yw[nmsk][i]=yyw;
											mc[nmsk].lpixel=mp.lpixel;
											found=1;
											valid[nmsk]=1;
										}
										for(j=0; j<4 && cpt1; j++)
										{
											cpt1=strchr(cpt1+1,',');
										}
									}
									if(valid[nmsk])
									{
										nmsk++;
									}
								}
							}
						}
					}
				}
				fclose(fh);
			}
		}

		if(!nmsk)
		{
			nmsk=1;
			valid[0]=1;
		}
		mask=nmsk;
		for(m=0; m<MAX_MASK; m++)
		{
			if(valid[m])
			{
				xxp=xp[m][pmode];
				xxw=xw[m][pmode];				
				yyp=yp[m][pmode];
				yyw=yw[m][pmode];
				tp.lpixel=mc[m].lpixel;
				RenderBox(xxp, yyp, xxp+xxw, yyp+yyw, FILL, &tp);
				if(m==amsk)
					RenderBox(xxp, yyp, xxp+xxw, yyp+yyw, GRID, make_color(LBLUE,&tp));
				for(i=0;i<=yyw;i++)
				{
					j=(yyp+i)*fix_screeninfo.line_length+(xxp<<2);
					if((j+(xxw<<2))<fix_screeninfo.line_length*var_screeninfo.yres)
					{
						memcpy(lfb+j, lbb+j, xxw<<2);
					}
				}
			}
		}
		time(&t1);
		while((rc!=KEY_EXIT) && (rc!=KEY_OK))
		{
			rc=GetRCCode();
			if((rc!=-1) && (rc!=KEY_EXIT) && (rc!=KEY_OK))
			{
				time(&t1);
				move=0;
				xxp=xp[amsk][pmode];
				xxw=xw[amsk][pmode];
				yyp=yp[amsk][pmode];
				yyw=yw[amsk][pmode];
				lpix.lpixel=mc[amsk].lpixel;
				switch(rc)
				{
					case KEY_LEFT:
					if(lc==KEY_LEFT)
					{
						xs+=0.3;
					}
					else
					{
						xs=1.0;
					}
					if(kmode)
					{
						if(xxp>0)
						{
							changed=1;
							xxp-=xs;
						}
					}
					else
					{
						if(xxw>6)
						{
							changed=1;
							xxw-=xs;
						}
					}
					move=1;
					break;
				
					case KEY_RIGHT:
					if((xxp+xxw)<(fix_screeninfo.line_length-1))
					{
						changed=1;
						if(lc==KEY_RIGHT)
						{
							xs+=0.3;
						}
						else
						{
							xs=1.0;
						}
						if(kmode)
						{
							xxp+=xs;
						}
						else
						{
							xxw+=xs;
						}
					}
					move=1;
					break;
				
					case KEY_UP:
					if(lc==KEY_UP)
					{
						ys+=0.2;
					}
					else
					{
						ys=1.0;
					}
					if(kmode)
					{
						if(yyp>0)
						{
							changed=1;
							yyp-=ys;
						}
					}
					else
					{
						if(yyw>6)
						{
							changed=1;
							yyw-=ys;
						}
					}
					move=1;
					break;
				
					case KEY_DOWN:
					if((yyp+yyw)<(var_screeninfo.yres-1))
					{
						changed=1;
						if(lc==KEY_DOWN)
						{
							ys+=0.2;
						}
						else
						{
							ys=1.0;
						}
						if(kmode)
						{
							yyp+=ys;
						}
						else
						{
							yyw+=ys;
						}
					}
					move=1;
					break;
				
					case KEY_RED:
						changed=1;
						RenderBox(xxp, yyp, xxp+xxw, yyp+yyw, FILL, make_color(TRANSP,&tp));
						for(i=0;i<=yyw;i++)
						{
							j=(yyp+i)*fix_screeninfo.line_length+(xxp<<2);
							if(((j+(xxw<<2)))<fix_screeninfo.line_length*var_screeninfo.yres)
							{
								memcpy(lfb+j, lbb+j, xxw<<2);
							}
						}
						valid[amsk]=0;
						nmsk--;
						kmode=1;
						if(nmsk)
						{
							todo=2;
							amsk=-1;
							for(m=0; m<MAX_MASK && amsk<0; m++)
							{
								if(valid[m])
								{
									amsk=m;
									xxp=xp[amsk][pmode];
									xxw=xw[amsk][pmode];
									yyp=yp[amsk][pmode];
									yyw=yw[amsk][pmode];
									lpix.lpixel=mc[amsk].lpixel;
								}
							}	
						}
						else
						{
							todo=mask=0;
						}
					break;
				
					case KEY_GREEN:
						if(nmsk<MAX_MASK)
						{
							todo=2;
							changed=1;
							kmode=1;
							amsk=-1;
							for(m=0; amsk<0 && m<MAX_MASK; m++)
							{
								if(!valid[m])
								{
									amsk=m;
									valid[amsk]=1;
									nmsk++;
									cmc[amsk]=BLACK;
									make_color(BLACK, &mc[amsk]);
									for(i=0; i<8; i++)
									{
										xp[amsk][i]=(1280-40)/2;
										xw[amsk][i]=40;
										yp[amsk][i]=(720-20)/2;
										yw[amsk][i]=20;
									}
									xxp=xp[amsk][pmode];
									xxw=xw[amsk][pmode];
									yyp=yp[amsk][pmode];
									yyw=yw[amsk][pmode];
									lpix.lpixel=mc[amsk].lpixel;
								}
							}
						}	
					break;
					
					case KEY_PAGEUP:
						if(nmsk>1)
						{
							m=amsk+1;
							if(m>=MAX_MASK)
							{
								m=0;
							}
							while(!valid[m])
							{
								if(++m>=MAX_MASK)
								{
									m=0;
								}
							}
							RenderBox(xxp, yyp, xxp+xxw, yyp+yyw, FILL, &lpix);
							amsk=m;
							xxp=xp[amsk][pmode];
							xxw=xw[amsk][pmode];
							yyp=yp[amsk][pmode];
							yyw=yw[amsk][pmode];
							lpix.lpixel=mc[amsk].lpixel;
						}
					break;
				
					case KEY_PAGEDOWN:
						if(nmsk>1)
						{
							m=amsk-1;
							if(m<0)
							{
								m=MAX_MASK-1;
							}
							while(!valid[m])
							{
								if(--m<0)
								{
									m=MAX_MASK;
								}
							}
							RenderBox(xxp, yyp, xxp+xxw, yyp+yyw, FILL, &lpix);
							amsk=m;
							xxp=xp[amsk][pmode];
							xxw=xw[amsk][pmode];
							yyp=yp[amsk][pmode];
							yyw=yw[amsk][pmode];
							lpix.lpixel=mc[amsk].lpixel;
						}
					break;

					case KEY_YELLOW:
						kmode=0;
					break;
				
					case KEY_BLUE:
						kmode=1;
					break;
					
					case KEY_1:
						if(nmsk)
						{
							if(mc[amsk].cpixel.rd < 0xF0)
								mc[amsk].cpixel.rd+=0x10;
							else
								mc[amsk].cpixel.rd=0xFF;
							changed=1;
						}
					break;

					case KEY_4:
						if(nmsk)
						{
							mc[amsk].cpixel.rd=0x80;
							changed=1;
						}
					break;

					case KEY_7:
						if(nmsk)
						{
							if(mc[amsk].cpixel.rd > 0x0F)
								mc[amsk].cpixel.rd-=0x10;
							else
								mc[amsk].cpixel.rd=0x00;
							changed=1;
						}
					break;

					case KEY_2:
						if(nmsk)
						{
							if(mc[amsk].cpixel.gn < 0xF0)
								mc[amsk].cpixel.gn+=0x10;
							else
								mc[amsk].cpixel.gn=0xFF;
							changed=1;
						}
					break;

					case KEY_5:
						if(nmsk)
						{
							mc[amsk].cpixel.gn=0x80;
							changed=1;
						}
					break;

					case KEY_8:
						if(nmsk)
						{
							if(mc[amsk].cpixel.gn > 0x0F)
								mc[amsk].cpixel.gn-=0x10;
							else
								mc[amsk].cpixel.gn=0x00;
							changed=1;
						}
					break;

					case KEY_3:
						if(nmsk)
						{
							if(mc[amsk].cpixel.bl < 0xF0)
								mc[amsk].cpixel.bl+=0x10;
							else
								mc[amsk].cpixel.bl=0xFF;
							changed=1;
						}
					break;

					case KEY_6:
						if(nmsk)
						{
							mc[amsk].cpixel.bl=0x80;
							changed=1;
						}
					break;

					case KEY_9:
						if(nmsk)
						{
							if(mc[amsk].cpixel.bl > 0x0F)
								mc[amsk].cpixel.bl-=0x10;
							else
								mc[amsk].cpixel.bl=0x00;
							changed=1;
						}
					break;

					case KEY_VOLUMEDOWN:
						if(nmsk)
						{
							if(mc[amsk].cpixel.tr < 0xF8)
								mc[amsk].cpixel.tr+=0x08;
							else
								mc[amsk].cpixel.tr=0xFF;
							changed=1;
						}
					break;

					case KEY_VOLUMEUP:
						if(nmsk)
						{
							if(mc[amsk].cpixel.tr > 0x08)
								mc[amsk].cpixel.tr-=0x08;
							else
								mc[amsk].cpixel.tr=0x00;
							changed=1;
						}
					break;

					case KEY_MUTE:
						if(nmsk)
						{
							if(++cmc[amsk]>LTURQUOISE)
								cmc[amsk]=BLACK;
							make_color(cmc[amsk], &mc[amsk]);
							changed=1;
						}
					break;

					case KEY_HELP:
						help_changed=1;
					break;
				}
				lc=rc;
				lpix.lpixel=mc[amsk].lpixel;
				if(mask || todo==2)
				{
					RenderBox(xp[amsk][pmode], yp[amsk][pmode], xp[amsk][pmode]+xw[amsk][pmode], yp[amsk][pmode]+yw[amsk][pmode], FILL, make_color(TRANSP, &tp));
					for(i=0;i<=yw[amsk][pmode];i++)
					{
						j=(yp[amsk][pmode]+i)*fix_screeninfo.line_length+(xp[amsk][pmode]<<2);
						if((j+(xw[amsk][pmode]<<2))<fix_screeninfo.line_length*var_screeninfo.yres)
						{
							memcpy(lfb+j, lbb+j, (xw[amsk][pmode]+1)<<2);
						}
					}
					xp[amsk][pmode]=xxp;
					xw[amsk][pmode]=xxw;
					yp[amsk][pmode]=yyp;
					yw[amsk][pmode]=yyw;
					for(m=0; mask && m<MAX_MASK; m++)
					{
						if(valid[m])
						{
							xxp=xp[m][pmode];
							xxw=xw[m][pmode];
							yyp=yp[m][pmode];
							yyw=yw[m][pmode];
							tp.lpixel=mc[m].lpixel;
							RenderBox(xxp, yyp, xxp+xxw, yyp+yyw, FILL, ((m==amsk) && move)?make_color(TRANSP, &tp):&tp);
							if(m==amsk)
								RenderBox(xxp, yyp, xxp+xxw, yyp+yyw, GRID, make_color((kmode)?LBLUE:LYELLOW,&tp));
							for(i=0;i<=yyw;i++)
							{
								j=(yyp+i)*fix_screeninfo.line_length+(xxp<<2);
								if((j+(xxw<<2))<fix_screeninfo.line_length*var_screeninfo.yres)
								{
									memcpy(lfb+j, lbb+j, (xxw+1)<<2);
								}
							}
						}
					}
				}
			}
			time(&t2);
			if((t2-t1)>1)
			{
				xs=1.0;
				ys=1.0;
				tsy=120;
				if(move)
				{
					RenderBox(xp[amsk][pmode], yp[amsk][pmode], xp[amsk][pmode]+xw[amsk][pmode], yp[amsk][pmode]+yw[amsk][pmode], FILL, &mc[amsk]);
					RenderBox(xp[amsk][pmode], yp[amsk][pmode], xp[amsk][pmode]+xw[amsk][pmode], yp[amsk][pmode]+yw[amsk][pmode], GRID, make_color((kmode)?LBLUE:LYELLOW,&tp));
				}
				move=0;
				if(help_changed)
				{
					help^=1;
				}
				if(help)
				{
					RenderBox(tsx,tsy,tsx+txw,tsy+21*tdy,FILL,make_color(TRANSP, &tp));
					if(nmsk)
						RenderBox(xp[amsk][pmode], yp[amsk][pmode], xp[amsk][pmode]+xw[amsk][pmode], yp[amsk][pmode]+yw[amsk][pmode], GRID, make_color((kmode)?LBLUE:LYELLOW, &tp));
					RenderString("Maskensteuerung", tsx, tsy+=tdy, txw, LEFT, tsz, tcol);
					RenderString("Blau  :  Umschalten auf Positionseinstellung", tsx, tsy+=tdy, txw, LEFT, tsz, tcol);
					RenderString("Gelb  :  Umschalten auf Größeneinstellung", tsx, tsy+=tdy, txw, LEFT, tsz, tcol);
					RenderString("Grün  :  Maske hinzufügen", tsx, tsy+=tdy, txw, LEFT, tsz, tcol);
					RenderString("Rot    :  Maske löschen", tsx, tsy+=tdy, txw, LEFT, tsz, tcol);
					RenderString("PgUp :  nächste Maske auswählen", tsx, tsy+=tdy, txw, LEFT, tsz, tcol);
					RenderString("PgDn :  vorherige Maske auswählen", tsx, tsy+=tdy, txw, LEFT, tsz, tcol);
					RenderString("Maskenfarbe", tsx, tsy+=(2*tdy), txw, LEFT, tsz, tcol);
					RenderString("Mute  :  Maskenfarbe aus Vorgabe auswählen", tsx, tsy+=tdy, txw, LEFT, tsz, tcol);
					RenderString("1,4,7   :  Farbton Rot erhöhen, auf Mitte setzen, verringern", tsx, tsy+=tdy, txw, LEFT, tsz, tcol);
					RenderString("2,5,8  :  Farbton Grün erhöhen, auf Mitte setzen, verringern", tsx, tsy+=tdy, txw, LEFT, tsz, tcol);
					RenderString("3,6,9  :  Farbton Blau erhöhen, auf Mitte setzen, verringern", tsx, tsy+=tdy, txw, LEFT, tsz, tcol);
					RenderString("Vol +  :  Transparenz erhöhen", tsx, tsy+=tdy, txw, LEFT, tsz, tcol);
					RenderString("Vol -  :  Transparenz verringern", tsx, tsy+=tdy, txw, LEFT, tsz, tcol);
					RenderString("Allgemein", tsx, tsy+=(2*tdy), txw, LEFT, tsz, tcol);
					RenderString("?        :  Hilfetext ein/ausschalten", tsx, tsy+=tdy, txw, LEFT, tsz, tcol);
					RenderString("Exit    :  Abbrechen", tsx, tsy+=tdy, txw, LEFT, tsz, tcol);
					RenderString("OK     :  Speichern und Beenden", tsx, tsy+=tdy, txw, LEFT, tsz, tcol);
				}
				else
				{
					if(help_changed)
					{
						RenderBox(tsx, tsy, tsx+txw, tsy+21*tdy, FILL, make_color(TRANSP, &tp));
						if(nmsk)
							RenderBox(xp[amsk][pmode], yp[amsk][pmode], xp[amsk][pmode]+xw[amsk][pmode], yp[amsk][pmode]+yw[amsk][pmode], GRID, make_color((kmode)?LBLUE:LYELLOW, &tp));
					}
				}
				help_changed=0;
				memcpy(lfb, lbb, fix_screeninfo.line_length*var_screeninfo.yres);
			}
		}
		if(rc==KEY_EXIT)
		{
			changed=0;
			todo=0;
		}
		if(rc==KEY_OK && changed)
		{
			if((fh2=fopen("/tmp/logomask.conf","w"))!=NULL)
			{
				fh=fopen(CFG_FILE,"r");
				while(fh && fgets(tstr, BUFSIZE, fh))
				{
					TrimString(tstr);
					if(strlen(tstr))
					{
						if(strstr(tstr,actchan)==NULL)
						{
							fprintf(fh2,"%s\n",tstr);
						}
					}
				}
				if(fh)
				{
					fclose(fh);
				}
				if(todo)
				{
					fprintf(fh2,"%s",actchan);
					for(j=0; j<MAX_MASK; j++)
					{
						if(valid[j])
						{
							for(i=0; i<8; i++)
							{
								fprintf(fh2,",%d,%d,%d,%d",xp[j][i],xw[j][i],yp[j][i],yw[j][i]);
							}
						}
					}
					for(j=0; j<MAX_MASK; j++)
					{
						if(valid[j])
						{
							fprintf(fh2,",MC%08X",mc[j].lpixel);
						}
					}
					fprintf(fh2,",\n");
				}
				fclose(fh2);
				remove(CFG_FILE);
				system("mv /tmp/logomask.conf /var/tuxbox/config/logomask.conf");
			}
		}		
		free(lbb);
		munmap(lfb, fix_screeninfo.smem_len);

		close(fb);
		CloseRC();
		remove("/tmp/.logomask_kill");
		remove("/tmp/logomaskset.*");
		system("logomask &");
		return 0;
}
Beispiel #4
0
void BitrateDialog::Run()
{
   unsigned char buf[TS_BUF_SIZE];
   struct pollfd pfd;
#if HAVE_DVB_API_VERSION < 3
   struct dmxPesFilterParams flt;
#else
   struct dmx_pes_filter_params flt;
#endif
   int dmxfd;
   struct timeval tv, first_tv, last_print_tv;
   long d_tim_ms, d_print_ms;
   unsigned long long b_total, b_tot1;
   unsigned long long curr_kb_s, kb_s;
   unsigned long long min_kb_s = 50000ULL, max_kb_s = 0ULL;
   long b;
   int rcHandle;

   startTimer.stop();
   int audio_type = Decoder::current.audio_type;
   int apid = Decoder::current.apid;
   int vpid = Decoder::current.vpid;
   int ac3_type = -1;

   if (audio_type == DECODE_AUDIO_AC3)
   {
      PMT *pmt = eDVB::getInstance()->getPMT();
      for (ePtrList<PMTEntry>::iterator i(pmt->streams); i != pmt->streams.end() && ac3_type == -1; ++i)
      {
         if ((*i)->stream_type == 6 && (*i)->elementary_PID == apid)
         {
            for (ePtrList<Descriptor>::const_iterator ii((*i)->ES_info); ii != (*i)->ES_info.end(); ++ii)
            {
               if (ii->Tag() == 0x6A)
               {
                  ac3_type = ((AC3Descriptor*)*ii)->AC3_type;
                  break;
               }
            }
         }
      }
   }

   pfd.events = POLLIN | POLLPRI;
   if ((pfd.fd = open(DVR_DEVICE, O_RDONLY | O_NONBLOCK)) < 0)
   {
      DisplayErrorMessage("Cannot open DVR device");
      return;
   }
   if ((dmxfd = open(DEMUX_DEVICE, O_RDWR)) < 0)
   {
      ::close(pfd.fd);
      DisplayErrorMessage("Cannot open DEMUX device");
      return;
   }
   if (apid == -1)
      audioVal->setText("N/A");
   if (vpid == -1)
   {
      currVal->setText("N/A");
      avrgVal->setText("N/A");
      minVal->setText("N/A");
      maxVal->setText("N/A");
   }
   if (apid == -1 && vpid == -1)
   {
      ::close(pfd.fd);
      ::close(dmxfd);
      rcHandle = eRCInput::getInstance()->lock();
      while (1)
      {
         short rccode = GetRCCode(rcHandle);
         if (rccode == RC_HOME || rccode == RC_RED)
            break;
         usleep(150000);
      }
      eRCInput::getInstance()->unlock();
      close(-1);
      return;
   }
   ioctl(dmxfd, DMX_SET_BUFFER_SIZE, sizeof(buf));
   if (apid != -1)
   {
      flt.pid = apid;
      flt.input = DMX_IN_FRONTEND;
      flt.output = DMX_OUT_TS_TAP;
#if HAVE_DVB_API_VERSION < 3
      flt.pesType=DMX_PES_OTHER;
#else
      flt.pes_type=DMX_PES_OTHER;
#endif
      flt.flags = DMX_IMMEDIATE_START;
      if (ioctl(dmxfd, DMX_SET_PES_FILTER, &flt) < 0)
      {
         ::close(pfd.fd);
         ::close(dmxfd);
         DisplayErrorMessage("Cannot set PES filter");
         close(-1);
         return;
      }
      gettimeofday(&first_tv, 0);
      last_print_tv.tv_sec = first_tv.tv_sec;
      last_print_tv.tv_usec = first_tv.tv_usec;

      b_total = b_tot1 = 0;

      while (1)
      {
         int b_len, b_start;
         int timeout = 1000;

         b_len = 0;
         b_start = 0;
         if (poll(&pfd, 1, timeout) > 0)
         {
            if (pfd.revents & POLLIN)
            {
               b_len = read(pfd.fd, buf, sizeof(buf));
               gettimeofday(&tv, 0);
            
               if (b_len >= TS_LEN)
                  b_start = SyncTS(buf, b_len);
               else
                  b_len = 0;

               b = b_len - b_start;
               if (b <= 0)
                  continue;
               b_total += b;
               b_tot1 += b;

               d_print_ms = DeltaTimeMs(&tv, &last_print_tv);
               if (d_print_ms >= 1000)
               {
                  d_tim_ms = DeltaTimeMs(&tv, &first_tv);
                  kb_s = (b_total * 8ULL) / (unsigned long long)d_tim_ms;
                  kb_s = kb_s * 97ULL / 100ULL;
                  kb_s = int(((kb_s / 32.0) + .5)) * 32;
                  // if (audio_type != DECODE_AUDIO_MPEG) kb_s -= 32;
                  eString val;
                  val.sprintf("%llu", kb_s);
                  audioVal->setText(val);
                  switch (audio_type)
                  {
                     case DECODE_AUDIO_MPEG:
                        audioType->setText("MPEG");
                        break;
                     case DECODE_AUDIO_AC3:
                        audioType->setText("AC3");
                        break;
                        /*
                        if ((ac3_type & 7) == 1)
                           audioType->setText("AC3 (1.0)");
                        else if ((ac3_type & 7) == 2 || (ac3_type & 7) == 3)
                           audioType->setText("AC3 (2.0)");
                        else if ((ac3_type & 7) == 4)
                           audioType->setText("AC3 (5.1)");
                        else
                        {
                           val.sprintf("AC3 (0x%x)", ac3_type & 7);
                           audioType->setText(val);
                        }
                        break;
                        */
                     case DECODE_AUDIO_DTS:
                        audioType->setText("DTS");
                        break;
                     case DECODE_AUDIO_AC3_VOB:
                        audioType->setText("AC3/VOB");
                        break;
                  }
                  break;
               }
            }
         }
         else
         {
            audioVal->setText("N/A");
            break;
         }
      }
      ioctl(dmxfd, DMX_STOP);
   }
   if (vpid != -1)
   {
      flt.pid = vpid;
      flt.input = DMX_IN_FRONTEND;
      flt.output = DMX_OUT_TS_TAP;
#if HAVE_DVB_API_VERSION < 3
      flt.pesType=DMX_PES_OTHER;
#else
      flt.pes_type=DMX_PES_OTHER;
#endif
      flt.flags = DMX_IMMEDIATE_START;
      if (ioctl(dmxfd, DMX_SET_PES_FILTER, &flt) < 0)
      {
         ::close(pfd.fd);
         ::close(dmxfd);
         DisplayErrorMessage("Cannot set PES filter");
         close(-1);
         return;
      }
      gettimeofday(&first_tv, 0);
      last_print_tv.tv_sec = first_tv.tv_sec;
      last_print_tv.tv_usec = first_tv.tv_usec;

      b_total = b_tot1 = 0;

      rcHandle = eRCInput::getInstance()->lock();
      while (1)
      {
         int b_len, b_start;
         int timeout = 1000;

         b_len = 0;
         b_start = 0;
         if (poll(&pfd, 1, timeout) > 0)
         {
            if (pfd.revents & POLLIN)
            {
               b_len = read(pfd.fd, buf, sizeof(buf));
               gettimeofday(&tv, 0);
            
               if (b_len >= TS_LEN)
                  b_start = SyncTS(buf, b_len);
               else
                  b_len = 0;

               b = b_len - b_start;
               if (b <= 0)
                  continue;
               b_total += b;
               b_tot1 += b;

               d_print_ms = DeltaTimeMs(&tv, &last_print_tv);
               if (d_print_ms >= 1000)
               {
                  d_tim_ms = DeltaTimeMs(&tv, &first_tv);
                  kb_s = (b_total * 8ULL) / (unsigned long long)d_tim_ms;
                  kb_s = kb_s * 97ULL / 100ULL;
                  curr_kb_s = (b_tot1 * 8ULL) / (unsigned long long)d_print_ms;
                  curr_kb_s = curr_kb_s * 97ULL / 100ULL;
                  b_tot1 = 0;
                  eString val;
                  val.sprintf("%llu", curr_kb_s);
                  currVal->setText(val);
                  val.sprintf("%llu", kb_s);
                  avrgVal->setText(val);
                  if (curr_kb_s < min_kb_s)
                  {
                     min_kb_s = curr_kb_s;
                     val.sprintf("%llu", min_kb_s);
                     minVal->setText(val);
                  }
                  if (curr_kb_s > max_kb_s)
                  {
                     max_kb_s = curr_kb_s;
                     val.sprintf("%llu", max_kb_s);
                     maxVal->setText(val);
                  }
                  last_print_tv.tv_sec = tv.tv_sec;
                  last_print_tv.tv_usec = tv.tv_usec;
               }
            }
         }
         else
         {
            currVal->setText("N/A");
            avrgVal->setText("N/A");
            minVal->setText("N/A");
            maxVal->setText("N/A");
         }
         short rccode = GetRCCode(rcHandle);
         if (rccode == RC_HOME || rccode == RC_RED)
            break;
      }
      ioctl(dmxfd, DMX_STOP);
   }
   else
   {
      rcHandle = eRCInput::getInstance()->lock();
      while (1)
      {
         short rccode = GetRCCode(rcHandle);
         if (rccode == RC_HOME || rccode == RC_RED)
            break;
         usleep(150000);
      }
   }
   ::close(pfd.fd);
   ::close(dmxfd);
   eRCInput::getInstance()->unlock();
   close(-1);
}
int Get_Selection(MENU *m)
{
	int rv=1,rccode, mloop=1,i,j,first,last,active,knew=1;
	time_t tm1,tm2;

	if(m->num_active)
	{
		i=m->act_entry;
		while((i>=0) && ((m->list[i]->type==TYP_COMMENT) || (m->list[i]->type==TYP_INACTIVE)))
		{
			++i;
			if(i>=m->num_entrys)
			{
				i=-1;
			}
		}
		if(i==-1)
		{
			i=0;
		}
		m->act_entry=i;
	}
	time(&tm1);
	do{
		//usleep(100000L);
		first=(paging)?0:(MAX_FUNCS*(int)(m->act_entry/MAX_FUNCS));
		last=(paging)?(m->num_entrys-1):(MAX_FUNCS*(int)(m->act_entry/MAX_FUNCS)+MAX_FUNCS-1);
		if(last>=m->num_entrys)
		{
			last=m->num_entrys-1;
		}

		active=0;
		for(i=first; i<=last && !active; i++)
		{
			active |= ((m->list[i]->type != TYP_COMMENT) && (m->list[i]->type != TYP_INACTIVE));
		}

		rccode=-1;
		if(knew)
		{
			ShowInfo(m, knew);
		}
		knew=1;
		switch(rccode = GetRCCode(mtmo * 1000))
		{
			case RC_RED:
				if(active && direct[0]>=0)
				{
					m->act_entry=direct[0];
					rv=1;
					mloop=0;
				}
				break;

			case RC_GREEN:
				if(active && direct[1]>=0)
				{
					m->act_entry=direct[1];
					rv=1;
					mloop=0;
				}
				break;

			case RC_YELLOW:
				if(active && direct[2]>=0)
				{
					m->act_entry=direct[2];
					rv=1;
					mloop=0;
				}
				break;

			case RC_BLUE:
				if(active && direct[3]>=0)
				{
					m->act_entry=direct[3];
					rv=1;
					mloop=0;
				}
				break;

			case RC_1:
				if(active && direct[4]>=0)
				{
					m->act_entry=direct[4];
					rv=1;
					mloop=0;
				}
				break;

			case RC_2:
				if(active && direct[5]>=0)
				{
					m->act_entry=direct[5];
					rv=1;
					mloop=0;
				}
				break;

			case RC_3:
				if(active && direct[6]>=0)
				{
					m->act_entry=direct[6];
					rv=1;
					mloop=0;
				}
				break;

			case RC_4:
				if(active && direct[7]>=0)
				{
					m->act_entry=direct[7];
					rv=1;
					mloop=0;
				}
				break;

			case RC_5:
				if(active && direct[8]>=0)
				{
					m->act_entry=direct[8];
					rv=1;
					mloop=0;
				}
				break;

			case RC_6:
				if(active && direct[9]>=0)
				{
					m->act_entry=direct[9];
					rv=1;
					mloop=0;
				}
				break;

			case RC_7:
				if(active && direct[10]>=0)
				{
					m->act_entry=direct[10];
					rv=1;
					mloop=0;
				}
				break;

			case RC_8:
				if(active && direct[11]>=0)
				{
					m->act_entry=direct[11];
					rv=1;
					mloop=0;
				}
				break;

			case RC_9:
				if(active && direct[12]>=0)
				{
					m->act_entry=direct[12];
					rv=1;
					mloop=0;
				}
				break;

			case RC_0:
				if(active && direct[13]>=0)
				{
					m->act_entry=direct[13];
					rv=1;
					mloop=0;
				}
				break;

			case RC_UP:
			case RC_MINUS:
				if(m->num_active)
				{
					i=m->act_entry-1;
					if(i<first)
					{
						i=last;
					}
					while(active && ((m->list[i]->type==TYP_COMMENT) || (m->list[i]->type==TYP_INACTIVE)))
					{
						--i;
						if(i<first)
						{
							i=last;
						}
					}
					m->act_entry=i;
				}
				//knew=1;
				break;

			case RC_DOWN:
			case RC_PLUS:
				if(m->num_active)
				{
					i=m->act_entry+1;
					if(i>last)
					{
						i=first;
					}
					while(active && ((m->list[i]->type==TYP_COMMENT) || (m->list[i]->type==TYP_INACTIVE)))
					{
						++i;
						if(i>last)
						{
							i=first;
						}
					}
					m->act_entry=i;
				}
				//knew=1;
				break;

			case RC_PAGEUP:
				i=MAX_FUNCS*(m->act_entry/MAX_FUNCS)-MAX_FUNCS;
				if(i<0)
				{
					i=MAX_FUNCS*((m->num_entrys-1)/MAX_FUNCS);
				}
				j=0;
				while((m->list[i+j]->type==TYP_COMMENT || m->list[i+j]->type==TYP_INACTIVE) && active && (i+j)<=(last+MAX_FUNCS) && (i+j)<m->num_entrys)
				{
					++j;
				}
				if((i+j)<=(last+MAX_FUNCS) && (i+j)<m->num_entrys)
				{
					i+=j;
				}
				m->act_entry=i;
				break;

			case RC_PAGEDOWN:
				i=MAX_FUNCS*(m->act_entry/MAX_FUNCS)+MAX_FUNCS;
				if(i>=m->num_entrys)
				{
					i=0;
				}
				j=0;
				while((m->list[i+j]->type==TYP_COMMENT || m->list[i+j]->type==TYP_INACTIVE) && active && (i+j)<=(last+MAX_FUNCS) && (i+j)<m->num_entrys)
				{
					++j;
				}
				if((i+j)<=(last+MAX_FUNCS) && (i+j)<m->num_entrys)
				{
					i+=j;
				}
				m->act_entry=i;
				break;

			case RC_OK:
				if(m->num_active)
				{
					rv=1;
					mloop=0;
				}
				break;

			case -1:
				knew=0;
				time(&tm2);
				if(mtmo==0 || (tm2-tm1)<mtmo)
				{
					break;
				}
				rv=RC_HOME;
			case RC_HOME:
				rv=0;
				mloop=0;
				break;

			case RC_MUTE:
#ifdef MARTII
#if defined(HAVE_SPARK_HARDWARE) || defined(HAVE_DUCKBOX_HARDWARE)
				FillRect(0, 0, DEFAULT_XRES, DEFAULT_YRES, 0);
#else
				memset(lbb, TRANSP, var_screeninfo.xres * var_screeninfo.yres * sizeof(uint32_t));
#endif
				blit();
#else
				memset(lfb, TRANSP, var_screeninfo.xres*var_screeninfo.yres*sizeof(uint32_t));
#endif


#ifdef MARTII
				usleep(500000L);
				ClearRC();
				while(GetRCCode(-1)!=RC_MUTE);
				ClearRC();
#else
				while(GetRCCode(300)!=RC_MUTE);
#endif
				break;

			case RC_STANDBY:
				rv=-1;
				mloop=0;
				break;

			default: knew=0; break;
		}
		if(rccode!=-1)
		{
			time(&tm1);
		}
	} while(mloop);

	ShowInfo(m, knew);

	return rv;
}
Beispiel #6
0
int main (int argc, char **argv)
{
    int index,index2,tv,found=0;
    int dloop=1, rcc=-1, flsh=0, cupd=0;
    char rstr[BUFSIZE], *rptr, *aptr;
    time_t tm1,tm2;
    unsigned int alpha;
    clock_t tk1=0;
    FILE *fh;

    if(argc<2)
    {
        ShowUsage();
        return 0;
    }
    dloop=0;
    for(tv=1; !dloop && tv<argc; tv++)
    {
        aptr=argv[tv];
        if((rptr=strchr(aptr,'='))!=NULL)
        {
            rptr++;
            if(strstr(aptr,"size=")!=NULL)
            {
                if(sscanf(rptr,"%d",&size)!=1)
                {
                    dloop=1;
                }
            }
            else
            {
                if(strstr(aptr,"title=")!=NULL)
                {
                    title=strdup(rptr);
                    CatchTabs(title);
                    if(strcmp(title,"none")==0)
                    {
                        header=0;
                    }
                    /*
                    						tpos=0;
                    						while(*rptr)
                    						{
                    							if(*rptr!='~')
                    							{
                    								nstr[tpos]=*rptr;
                    							}
                    							else
                    							{
                    								rc=*(rptr+1);
                    								found=0;
                    								for(i=0; i<sizeof(sc) && !found; i++)
                    								{
                    									if(rc==sc[i])
                    									{
                    										rc=tc[i];
                    										found=1;
                    									}
                    								}
                    								if(found)
                    								{
                    									nstr[tpos]=rc;
                    									++rptr;
                    								}
                    								else
                    								{
                    									nstr[tpos]=*rptr;
                    								}
                    							}
                    							++tpos;
                    							++rptr;
                    						}
                    						nstr[tpos]=0;
                    						title=strdup(nstr);
                    */
                }
                else
                {
                    if(strstr(aptr,"timeout=")!=NULL)
                    {
                        if(sscanf(rptr,"%d",&timeout)!=1)
                        {
                            dloop=1;
                        }
                    }
                    else
                    {
                        if(strstr(aptr,"msg=")!=NULL)
                        {
                            dloop=Transform_Msg(rptr);
                            if(timeout==0)
                            {
                                if((timeout=Read_Neutrino_Cfg("timing.epg"))<0)
                                    timeout=300;
                            }
                            type=1;
                        }
                        else
                        {
                            if(strstr(aptr,"popup=")!=NULL)
                            {
                                dloop=Transform_Msg(rptr);
                                if(timeout==0)
                                {
                                    if((timeout=Read_Neutrino_Cfg("timing.infobar"))<0)
                                        timeout=6;
                                }
                                type=2;
                            }
                            else
                            {
                                if(strstr(aptr,"refresh=")!=NULL)
                                {
                                    if(sscanf(rptr,"%d",&refresh)!=1)
                                    {
                                        dloop=1;
                                    }
                                }
                                else
                                {
                                    if(strstr(aptr,"select=")!=NULL)
                                    {
                                        dloop=GetSelection(rptr);
                                    }
                                    else
                                    {
                                        if(strstr(aptr,"default=")!=NULL)
                                        {
                                            if((sscanf(rptr,"%d",&selection)!=1) || selection<1)
                                            {
                                                dloop=1;
                                            }
                                        }
                                        else
                                        {
                                            if(strstr(aptr,"order=")!=NULL)
                                            {
                                                if(sscanf(rptr,"%d",&bpline)!=1)
                                                {
                                                    dloop=1;
                                                }
                                            }
                                            else
                                            {
                                                if(strstr(aptr,"echo=")!=NULL)
                                                {
                                                    if(sscanf(rptr,"%d",&echo)!=1)
                                                    {
                                                        dloop=1;
                                                    }
                                                }
                                                else
                                                {
                                                    if(strstr(aptr,"absolute=")!=NULL)
                                                    {
                                                        if(sscanf(rptr,"%d",&absolute)!=1)
                                                        {
                                                            dloop=1;
                                                        }
                                                    }
                                                    else
                                                    {
                                                        if(strstr(aptr,"hide=")!=NULL)
                                                        {
                                                            if(sscanf(rptr,"%d",&mute)!=1)
                                                            {
                                                                dloop=1;
                                                            }
                                                        }
                                                        else
                                                        {
                                                            if(strstr(aptr,"cyclic=")!=NULL)
                                                            {
                                                                if(sscanf(rptr,"%d",&cyclic)!=1)
                                                                {
                                                                    dloop=1;
                                                                }
                                                            }
                                                            else
                                                            {
                                                                dloop=2;
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        switch (dloop)
        {
        case 1:
            printf("msgbox <param error: %s>\n",aptr);
            return 0;
            break;

        case 2:
            printf("msgbox <unknown command: %s>\n\n",aptr);
            ShowUsage();
            return 0;
            break;
        }
    }
    /*for(tv=0; tv<buttons; tv++)
    {
    	printf("%cButton %d: %s\n",(tv==selection-1)?'>':' ',tv+1,butmsg[tv]);
    }
    return 0;*/

    if(!echo)
    {
        printf("\nmsgbox  Message-Box Version %.2f\n",M_VERSION);
    }
    if(!buttons)
    {
        butmsg[0]=strdup("OK");
        buttons=1;
    }
    /*
    		if(selection>buttons)
    		{
    			printf("msgbox <param error: default=%d>\n",selection);
    			return 0;
    		}
    */
    if(!absolute)
    {
        for(tv=0; tv<buttons; tv++)
        {
            rbutt[tv]=tv+1;
        }
    }
    if(selection)
    {
        for(tv=0; tv<buttons && !found; tv++)
        {
            if(rbutt[tv]==selection)
            {
                selection=tv+1;
                found=1;
            }
        }
        if(!found)
        {
            printf("msgbox <param error: default=%d>\n",selection);
            return 0;
        }
    }
    else
    {
        for(tv=0; tv<buttons && !selection; tv++)
        {
            if(strlen(butmsg[tv]))
            {
                selection=tv+1;
            }
        }
    }
    /*		for(tv=0; selection!=rbutt[tv] && tv<buttons; tv++);

    		if(tv>=buttons)
    		{
    			selection=1;
    		}
    */
    if(!title)
    {
        title=strdup("Information");
    }
    if((line_buffer=calloc(BUFSIZE+1, sizeof(char)))==NULL)
    {
        printf(NOMEM);
        return -1;
    }

    if((debounce=Read_Neutrino_Cfg("repeat_genericblocker"))<0)
        debounce=200;

    if((rblock=Read_Neutrino_Cfg("repeat_blocker"))<0)
        rblock=50;

    if(((sx=Read_Neutrino_Cfg("screen_StartX"))<0)&&((sx=Read_Neutrino_Cfg("/enigma/plugins/needoffsets/left"))<0))
        sx=80;

    if(((ex=Read_Neutrino_Cfg("screen_EndX"))<0)&&((ex=Read_Neutrino_Cfg("/enigma/plugins/needoffsets/right"))<0))
        ex=620;

    if(((sy=Read_Neutrino_Cfg("screen_StartY"))<0)&&((sy=Read_Neutrino_Cfg("/enigma/plugins/needoffsets/top"))<0))
        sy=80;

    if(((ey=Read_Neutrino_Cfg("screen_EndY"))<0)&&((ey=Read_Neutrino_Cfg("/enigma/plugins/needoffsets/bottom"))<0))
        ey=505;

    if(Read_Neutrino_Cfg("rounded_corners")>0)
        radius=9;
    else
        radius=0;

    if((trstr=malloc(BUFSIZE))==NULL)
    {
        printf(NOMEM);
        return -1;
    }

    fb = open(FB_DEVICE, O_RDWR);
#ifdef HAVE_DBOX_HARDWARE
    ioctl(fb, AVIA_GT_GV_GET_BLEV, &alpha);
#endif
    rc = open(RC_DEVICE, O_RDONLY);
    fcntl(rc, F_SETFL, (fcntl(rc, F_GETFL) | O_EXCL) | O_NONBLOCK);

    //init framebuffer

    if(ioctl(fb, FBIOGET_FSCREENINFO, &fix_screeninfo) == -1)
    {
        printf("msgbox <FBIOGET_FSCREENINFO failed>\n");
        return -1;
    }
    if(ioctl(fb, FBIOGET_VSCREENINFO, &var_screeninfo) == -1)
    {
        printf("msgbox <FBIOGET_VSCREENINFO failed>\n");
        return -1;
    }

    if(ioctl(fb, FBIOGETCMAP, &oldcmap) == -1)
    {
        printf("msgbox <FBIOGETCMAP failed>\n");
        return -1;
    }
    /*
    		fh=fopen("/tmp/cmap.log","w");
    		fprintf(fh,"Start: %d, LEN: %d\n",oldcmap.start,oldcmap.len);
    		for(tv=0; tv<256; tv++)
    		{
    			fprintf(fh,"%02d %04x %04x %04x %04x\n",tv,oldcmap.red[tv],oldcmap.green[tv],oldcmap.blue[tv],oldcmap.transp[tv]);
    		}
    		fclose(fh);
    */
    for(index=0; index<8; index++)
    {
        sprintf(rstr,"menu_%s_alpha",menucoltxt[index]);
        if((tv=Read_Neutrino_Cfg(rstr))>=0)
            for(index2=0; index2<7; index2++)
                otr[menucolval[index]+index2]=(tv<<8);
    }

    ord[FLASH]=ord[CMCT];
    ogn[FLASH]=ogn[CMCT];
    obl[FLASH]=obl[CMCT];
    otr[FLASH]=otr[CMCT];
    /*
    		fh=fopen("/tmp/cmap2.log","w");
    		fprintf(fh,"Start: %d, LEN: %d\n",oldcmap.start,oldcmap.len);
    		for(tv=0; tv<256; tv++)
    		{
    			fprintf(fh,"%02d %04x %04x %04x %04x\n",tv,oldcmap.red[tv],oldcmap.green[tv],oldcmap.blue[tv],oldcmap.transp[tv]);
    		}
    		fclose(fh);

    */
    /*
    {
    int i;
    printf("unsigned short rd[] = {");
    for(i=CMCST; i<=CMH;i++)
    printf("0x%02x<<8, ",(ord[i]>>8)&0xFF);
    printf("\nunsigned short gn[] = {");
    for(i=CMCST; i<=CMH;i++)
    printf("0x%02x<<8, ",(ogn[i]>>8)&0xFF);
    printf("\nunsigned short bl[] = {");
    for(i=CMCST; i<=CMH;i++)
    printf("0x%02x<<8, ",(obl[i]>>8)&0xFF);
    printf("\nunsigned short tr[] = {");
    for(i=CMCST; i<=CMH;i++)
    printf("0x%02x<<8, ",(otr[i]>>8)&0xFF);
    printf("\n");
    }
    return 0;
    */

    if(ioctl(fb, FBIOPUTCMAP, &oldcmap) == -1)
    {
        printf("msgbox <FBIOPUTCMAP failed>\n");
        return -1;
    }

    if(!(lfb = (unsigned char*)mmap(0, fix_screeninfo.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fb, 0)))
    {
        printf("msgbox <mapping of Framebuffer failed>\n");
        return -1;
    }

    //init fontlibrary

    if((error = FT_Init_FreeType(&library)))
    {
        printf("msgbox <FT_Init_FreeType failed with Errorcode 0x%.2X>", error);
        munmap(lfb, fix_screeninfo.smem_len);
        return -1;
    }

    if((error = FTC_Manager_New(library, 1, 2, 0, &MyFaceRequester, NULL, &manager)))
    {
        printf("msgbox <FTC_Manager_New failed with Errorcode 0x%.2X>\n", error);
        FT_Done_FreeType(library);
        munmap(lfb, fix_screeninfo.smem_len);
        return -1;
    }

    if((error = FTC_SBitCache_New(manager, &cache)))
    {
        printf("msgbox <FTC_SBitCache_New failed with Errorcode 0x%.2X>\n", error);
        FTC_Manager_Done(manager);
        FT_Done_FreeType(library);
        munmap(lfb, fix_screeninfo.smem_len);
        return -1;
    }

    if((error = FTC_Manager_Lookup_Face(manager, FONT, &face)))
    {
        printf("msgbox <FTC_Manager_Lookup_Face failed with Errorcode 0x%.2X>\n", error);
        FTC_Manager_Done(manager);
        FT_Done_FreeType(library);
        munmap(lfb, fix_screeninfo.smem_len);
        return -1;
    }

    use_kerning = FT_HAS_KERNING(face);

#ifdef FT_NEW_CACHE_API
    desc.face_id = FONT;
#else
    desc.font.face_id = FONT;
#endif

#if FREETYPE_MAJOR == 2 && FREETYPE_MINOR == 0
    desc.image_type = ftc_image_mono;
#else
    desc.flags = FT_LOAD_MONOCHROME;
#endif

    //init backbuffer

    if(!(lbb = malloc(var_screeninfo.xres*var_screeninfo.yres)))
    {
        printf("msgbox <allocating of Backbuffer failed>\n");
        FTC_Manager_Done(manager);
        FT_Done_FreeType(library);
        munmap(lfb, fix_screeninfo.smem_len);
        return -1;
    }

    if(!(obb = malloc(var_screeninfo.xres*var_screeninfo.yres)))
    {
        printf("msgbox <allocating of Backbuffer failed>\n");
        FTC_Manager_Done(manager);
        FT_Done_FreeType(library);
        free(lbb);
        munmap(lfb, fix_screeninfo.smem_len);
        return -1;
    }

    if(!(hbb = malloc(var_screeninfo.xres*var_screeninfo.yres)))
    {
        printf("msgbox <allocating of Backbuffer failed>\n");
        FTC_Manager_Done(manager);
        FT_Done_FreeType(library);
        free(lbb);
        free(obb);
        munmap(lfb, fix_screeninfo.smem_len);
        return -1;
    }

    if(!(ibb = malloc(var_screeninfo.xres*var_screeninfo.yres)))
    {
        printf("msgbox <allocating of Backbuffer failed>\n");
        FTC_Manager_Done(manager);
        FT_Done_FreeType(library);
        free(lbb);
        free(obb);
        free(hbb);
        munmap(lfb, fix_screeninfo.smem_len);
        return -1;
    }

    if(refresh & 1)
    {
        memcpy(ibb, lfb, var_screeninfo.xres*var_screeninfo.yres);
    }
    else
    {
        memset(ibb, TRANSP, var_screeninfo.xres*var_screeninfo.yres);
    }
    if(mute==2)
    {
        memcpy(hbb, lfb, var_screeninfo.xres*var_screeninfo.yres);
    }
    else
    {
        memset(hbb, TRANSP, var_screeninfo.xres*var_screeninfo.yres);
    }
    if(refresh & 2)
    {
        memcpy(obb, lfb, var_screeninfo.xres*var_screeninfo.yres);
    }
    else
    {
        memset(obb, TRANSP, var_screeninfo.xres*var_screeninfo.yres);
    }

    startx = sx /*+ (((ex-sx) - 620)/2)*/;
    starty = sy /* + (((ey-sy) - 505)/2)*/;


    /* Set up signal handlers. */
    signal(SIGINT, quit_signal);
    signal(SIGTERM, quit_signal);
    signal(SIGQUIT, quit_signal);

    put_instance(instance=get_instance()+1);

    show_txt(0);
//FBEnterWord( 100, 100, 100,20,CMCT);
//rc=RC_HOME;

    time(&tm1);
    tm2=tm1;
    tk1=clock()/(CLOCKS_PER_SEC/1000);
#ifdef HAVE_DREAMBOX_HARDWARE
    ClearKeys();
#endif

    //main loop

    while((rcc!=RC_HOME) && (rcc!=RC_OK) && ((timeout==-1)||((tm2-tm1)<timeout)))
    {
        rcc=GetRCCode();
        if(rcc!=-1)
        {
            time(&tm1);
        }
        else
        {
            if(++cupd>10)
            {
                if(cyclic)
                {
                    show_txt(0);
                    cupd=0;
                }
            }
            usleep(100000L);
        }
        if(mute && rcc==RC_MUTE)
        {
            hide^=1;
            show_txt(0);
            usleep(500000L);
            while(GetRCCode()!=-1);
            if(hide)
            {
                if((fh=fopen(HDF_FILE,"w"))!=NULL)
                {
                    fprintf(fh,"hidden");
                    fclose(fh);
                }
            }
            else
            {
                remove(HDF_FILE);
            }
        }
        if((!hide) && (rcc!=RC_HOME) && (rcc!=RC_OK))
        {
            switch(rcc)
            {
            case RC_LEFT:
                if(!hide && (--selection<1))
                {
                    selection=buttons;
                }
                show_txt(1);
                break;

            case RC_RIGHT:
                if(!hide && (++selection>buttons))
                {
                    selection=1;
                }
                show_txt(1);
                break;

            case RC_UP:
                if(!hide && ((selection-=bpline)<1))
                {
                    selection=1;
                }
                show_txt(1);
                break;

            case RC_DOWN:
                if(!hide && ((selection+=bpline)>buttons))
                {
                    selection=buttons;
                }
                show_txt(1);
                break;

            default:
                if(++flsh==7)
                {
                    flsh=0;
                    flash^=1;

                    ord[FLASH]=(flash)?ord[CMC]:ord[CMCT];
                    ogn[FLASH]=(flash)?ogn[CMC]:ogn[CMCT];
                    obl[FLASH]=(flash)?obl[CMC]:obl[CMCT];
                    otr[FLASH]=(flash)?otr[CMC]:otr[CMCT];
                    ioctl(fb, FBIOPUTCMAP, &oldcmap);
                }
                break;
            }
        }
        time(&tm2);
        if(hide)
        {
            rcc=-1;
        }
    }
    if((type!=1) || (rcc!=RC_OK))
    {
        selection=0;
    }


    //cleanup

    // clear Display
//	memset(lbb, TRANSP, var_screeninfo.xres*var_screeninfo.yres);
//	memcpy(lfb, lbb, var_screeninfo.xres*var_screeninfo.yres);

    memcpy(lfb, obb, var_screeninfo.xres*var_screeninfo.yres);
    munmap(lfb, fix_screeninfo.smem_len);
#ifdef HAVE_DBOX_HARDWARE
    ioctl(fb, AVIA_GT_GV_SET_BLEV, alpha);
#endif
    close(fb);
    free(lbb);

    put_instance(get_instance()-1);

    if(echo && selection>0)
    {
        printf("%s\n",butmsg[selection-1]);
    }

    for(tv=0; tv<buttons; tv++)
    {
        free(butmsg[tv]);
    }
    free(trstr);
    free(line_buffer);
    free(title);

    FTC_Manager_Done(manager);
    FT_Done_FreeType(library);

    free(obb);
    free(hbb);
    free(ibb);

    close(rc);

    remove("/tmp/msgbox.tmp");

    if(selection)
    {
        return rbutt[selection-1];
    }
    return 0;
}
Beispiel #7
0
int main (int argc, char **argv)
{
int ix,tv,found=0, spr, resolution;
int dloop=1, rcc=-1;
char rstr[BUFSIZE]={0}, *rptr=NULL, *aptr=NULL;
time_t tm1,tm2;
#ifndef MARTII
FILE *fh;
#endif

		if(argc<2)
		{
			ShowUsage();
			return 0;
		}

		//init framebuffer before 1st scale2res
		fb = open(FB_DEVICE, O_RDWR);
#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE
		if (fb < 0)
			fb = open(FB_DEVICE_FALLBACK, O_RDWR);
#endif
		if(fb == -1)
		{
			perror(__plugin__ " <open framebuffer device>");
			exit(1);
		}
		if(ioctl(fb, FBIOGET_FSCREENINFO, &fix_screeninfo) == -1)
		{
			perror(__plugin__ " <FBIOGET_FSCREENINFO>\n");
			return -1;
		}
		if(ioctl(fb, FBIOGET_VSCREENINFO, &var_screeninfo) == -1)
		{
			perror(__plugin__ " <FBIOGET_VSCREENINFO>\n");
			return -1;
		}
#if defined(HAVE_SPARK_HARDWARE) || defined(HAVE_DUCKBOX_HARDWARE)
		var_screeninfo.xres = DEFAULT_XRES;
		var_screeninfo.yres = DEFAULT_YRES;
#endif

		if(!(lfb = (uint32_t*)mmap(0, fix_screeninfo.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fb, 0)))
		{
			perror(__plugin__ " <mapping of Framebuffer>\n");
			return -1;
		}

		dloop=0;
		for(tv=1; !dloop && tv<argc; tv++)
		{
			aptr=argv[tv];
			if(!strcmp(aptr,"-v") || !strcmp(aptr,"--version"))
			{
				printf("%s Version %.2f\n", __plugin__, M_VERSION);
				return 0;
			}
			if((rptr=strchr(aptr,'='))!=NULL)
			{
				rptr++;
				if(strstr(aptr,"size=")!=NULL)
				{
					if(sscanf(rptr,"%d",&FSIZE_MED)!=1)
					{
						dloop=1;
					}
				}
				else
				{
					if(strstr(aptr,"title=")!=NULL)
					{
						size_t l = strlen(rptr);
						char *t = (char *)alloca(l * 4 + 1);
						memcpy(t, rptr, l + 1);
						TranslateString(t, l * 4);
						title = strdup(t);
						CatchTabs(title);

						if(strcmp(title,"none")==0)
						{
							header=0;
						}
					}
					else
					{
						if(strstr(aptr,"timeout=")!=NULL)
						{
							if(sscanf(rptr,"%d",&timeout)!=1)
							{
								dloop=1;
							}
						}
						else
						{
							if(strstr(aptr,"msg=")!=NULL)
							{
								dloop=Transform_Msg(rptr);
								if(timeout==0)
								{
										if((timeout=Read_Neutrino_Cfg("timing.epg"))<0)
											timeout=300;
								}
								type=1;
							}
							else
							{
								if(strstr(aptr,"popup=")!=NULL)
								{
									dloop=Transform_Msg(rptr);
									if(timeout==0)
									{
										if((timeout=Read_Neutrino_Cfg("timing.infobar"))<0)
											timeout=6;
									}
									type=2;
								}
								else
								{
									if(strstr(aptr,"refresh=")!=NULL)
									{
										if(sscanf(rptr,"%d",&refresh)!=1)
										{
											dloop=1;
										}
									}
									else
									{
										if(strstr(aptr,"select=")!=NULL)
										{
											dloop=GetSelection(rptr);
										}
										else
										{
											if(strstr(aptr,"default=")!=NULL)
											{
												if((sscanf(rptr,"%d",&selection)!=1) || selection<1)
												{
													dloop=1;
												}
											}
											else
											{
												if(strstr(aptr,"order=")!=NULL)
												{
													if(sscanf(rptr,"%d",&bpline)!=1)
													{
														dloop=1;
													}
												}
												else
												{
													if(strstr(aptr,"echo=")!=NULL)
													{
														if(sscanf(rptr,"%d",&echo)!=1)
														{
															dloop=1;
														}
													}
													else
													{
														if(strstr(aptr,"absolute=")!=NULL)
														{
															if(sscanf(rptr,"%d",&absolute)!=1)
															{
																dloop=1;
															}
														}
														else
														{
															if(strstr(aptr,"hide=")!=NULL)
															{
																if(sscanf(rptr,"%d",&mute)!=1)
																{
																	dloop=1;
																}
															}
															else
															{
																if(strstr(aptr,"cyclic=")!=NULL)
																{
																	if(sscanf(rptr,"%d",&cyclic)!=1)
																	{
																		dloop=1;
																	}
																}
																else
																{
																	if(strstr(aptr,"icon=")!=NULL)
																	{
																		icon=rptr;
																		dloop=Transform_Icon(icon)==0;
																	}
																	else
																	{
																		dloop=2;
																	}
																}
															}
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
			switch (dloop)
			{
				case 1:
					printf("%s <param error: %s>\n", __plugin__, aptr);
					return 0;
					break;
				
				case 2:
					printf("%s <unknown command: %s>\n\n", __plugin__, aptr);
					ShowUsage();
					return 0;
					break;
			}
		}

		FSIZE_BIG=(float)FSIZE_MED*1.25;
		FSIZE_SMALL=(FSIZE_MED*4)/5;
		TABULATOR=2*FSIZE_MED;
		size=FSIZE_MED;
		
		/*
		if(!echo)
		{
			printf("\nMsgBox Version %.2f\n", M_VERSION);
		}
		*/
		if(!buttons)
		{
			butmsg[0]=strdup("OK");
			buttons=1;
		}
		if(!absolute)
		{
			for(tv=0; tv<buttons; tv++)
			{
				rbutt[tv]=tv+1;
			}
		}
		if(selection)
		{	
			for(tv=0; tv<buttons && !found; tv++)		
			{
				if(rbutt[tv]==selection)
				{
					selection=tv+1;
					found=1;
				}
			}
			if(!found)
			{
				printf("%s <param error: default=%d>\n", __plugin__, selection);
				return 0;
			}
		}
		else
		{
			for(tv=0; tv<buttons && !selection; tv++)
			{
				if(strlen(butmsg[tv]))
				{
					selection=tv+1;
				}
			}
		}
		if(!icon)
		{
			icon=strdup("info");
		}
		if(!title)
		{
			title=strdup("Information");
		}
		if((line_buffer=calloc(BUFSIZE+1, sizeof(char)))==NULL)
		{
			printf(NOMEM);
			return -1;
		}
	
		spr=Read_Neutrino_Cfg("screen_preset")+1;
		resolution=Read_Neutrino_Cfg("osd_resolution");

		if (resolution == -1)
			sprintf(line_buffer,"screen_StartX_%s", spres[spr]);
		else
			sprintf(line_buffer,"screen_StartX_%s_%d", spres[spr], resolution);
		if((sx=Read_Neutrino_Cfg(line_buffer))<0)
			sx=scale2res(100);

		if (resolution == -1)
			sprintf(line_buffer,"screen_EndX_%s", spres[spr]);
		else
			sprintf(line_buffer,"screen_EndX_%s_%d", spres[spr], resolution);
		if((ex=Read_Neutrino_Cfg(line_buffer))<0)
			ex=scale2res(1180);

		if (resolution == -1)
			sprintf(line_buffer,"screen_StartY_%s", spres[spr]);
		else
			sprintf(line_buffer,"screen_StartY_%s_%d", spres[spr], resolution);
		if((sy=Read_Neutrino_Cfg(line_buffer))<0)
			sy=scale2res(100);

		if (resolution == -1)
			sprintf(line_buffer,"screen_EndY_%s", spres[spr]);
		else
			sprintf(line_buffer,"screen_EndY_%s_%d", spres[spr], resolution);
		if((ey=Read_Neutrino_Cfg(line_buffer))<0)
			ey=scale2res(620);

		for(ix=CMCST; ix<=CMH; ix++)
		{
			sprintf(rstr,"menu_%s_alpha",menucoltxt[ix]);
			if((tv=Read_Neutrino_Cfg(rstr))>=0)
				tr[ix]=255-(float)tv*2.55;

			sprintf(rstr,"menu_%s_blue",menucoltxt[ix]);
			if((tv=Read_Neutrino_Cfg(rstr))>=0)
				bl[ix]=(float)tv*2.55;

			sprintf(rstr,"menu_%s_green",menucoltxt[ix]);
			if((tv=Read_Neutrino_Cfg(rstr))>=0)
				gn[ix]=(float)tv*2.55;

			sprintf(rstr,"menu_%s_red",menucoltxt[ix]);
			if((tv=Read_Neutrino_Cfg(rstr))>=0)
				rd[ix]=(float)tv*2.55;
		}

		int	cix=CMC;
		for(ix=COL_MENUCONTENT_PLUS_0; ix<=COL_MENUCONTENT_PLUS_3; ix++)
		{
			rd[ix]=rd[cix]+25;
			gn[ix]=gn[cix]+25;
			bl[ix]=bl[cix]+25;
			tr[ix]=tr[cix];
			cix=ix;
		}

		sprintf(rstr,"infobar_alpha");
		if((tv=Read_Neutrino_Cfg(rstr))>=0)
			tr[COL_SHADOW_PLUS_0]=255-(float)tv*2.55;

		sprintf(rstr,"infobar_blue");
		if((tv=Read_Neutrino_Cfg(rstr))>=0)
			bl[COL_SHADOW_PLUS_0]=(float)tv*2.55*0.4;

		sprintf(rstr,"infobar_green");
		if((tv=Read_Neutrino_Cfg(rstr))>=0)
			gn[COL_SHADOW_PLUS_0]=(float)tv*2.55*0.4;

		sprintf(rstr,"infobar_red");
		if((tv=Read_Neutrino_Cfg(rstr))>=0)
			rd[COL_SHADOW_PLUS_0]=(float)tv*2.55*0.4;

		for (ix = 0; ix <= COL_SHADOW_PLUS_0; ix++)
			bgra[ix] = (tr[ix] << 24) | (rd[ix] << 16) | (gn[ix] << 8) | bl[ix];

		if(Read_Neutrino_Cfg("rounded_corners")>0)
		{
			radius = scale2res(11);
			radius_small = scale2res(5);
		}
		else
			radius = radius_small = 0;

		InitRC();
		
		if((trstr=malloc(BUFSIZE))==NULL)
		{
			printf(NOMEM);
			return -1;
		}
		
	//init fontlibrary

		if((error = FT_Init_FreeType(&library)))
		{
			printf("%s <FT_Init_FreeType failed with Errorcode 0x%.2X>", __plugin__, error);
			munmap(lfb, fix_screeninfo.smem_len);
			return -1;
		}

		if((error = FTC_Manager_New(library, 1, 2, 0, &MyFaceRequester, NULL, &manager)))
		{
			printf("%s <FTC_Manager_New failed with Errorcode 0x%.2X>\n", __plugin__, error);
			FT_Done_FreeType(library);
			munmap(lfb, fix_screeninfo.smem_len);
			return -1;
		}

		if((error = FTC_SBitCache_New(manager, &cache)))
		{
			printf("%s <FTC_SBitCache_New failed with Errorcode 0x%.2X>\n", __plugin__, error);
			FTC_Manager_Done(manager);
			FT_Done_FreeType(library);
			munmap(lfb, fix_screeninfo.smem_len);
			return -1;
		}

		Read_Neutrino_Cfg("font_file=");
		if((error = FTC_Manager_LookupFace(manager, FONT, &face)))
		{
			if((error = FTC_Manager_LookupFace(manager, FONT2, &face)))
			{
				printf("%s <FTC_Manager_LookupFace failed with Errorcode 0x%.2X>\n", __plugin__, error);
				FTC_Manager_Done(manager);
				FT_Done_FreeType(library);
				munmap(lfb, fix_screeninfo.smem_len);
				return 2;
			}
			else
				desc.face_id = FONT2;
		}
		else
			desc.face_id = FONT;
		
		use_kerning = FT_HAS_KERNING(face);

		desc.flags = FT_LOAD_RENDER | FT_LOAD_FORCE_AUTOHINT;

		//init backbuffer
#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE
		lbb = lfb + 1920 * 1080;
		fix_screeninfo.line_length = DEFAULT_XRES * sizeof(uint32_t);
		stride = DEFAULT_XRES;
#else
		stride = fix_screeninfo.line_length/sizeof(uint32_t);
		if(stride == 7680 && var_screeninfo.xres == 1280) {
			var_screeninfo.yres = 1080;
		}
		if(!(lbb = malloc(var_screeninfo.xres*var_screeninfo.yres*sizeof(uint32_t))))
		{
			perror(__plugin__ " <allocating of Backbuffer>\n");
			FTC_Manager_Done(manager);
			FT_Done_FreeType(library);
			munmap(lfb, fix_screeninfo.smem_len);
			return -1;
		}
#endif
		if(!(obb = malloc(var_screeninfo.xres*var_screeninfo.yres*sizeof(uint32_t))))
		{
			perror(__plugin__ " <allocating of Backbuffer>\n");
			FTC_Manager_Done(manager);
			FT_Done_FreeType(library);
			free(lbb);
			munmap(lfb, fix_screeninfo.smem_len);
			return -1;
		}
		if(!(hbb = malloc(var_screeninfo.xres*var_screeninfo.yres*sizeof(uint32_t))))
		{
			perror(__plugin__ " <allocating of Backbuffer>\n");
			FTC_Manager_Done(manager);
			FT_Done_FreeType(library);
			free(lbb);
			free(obb);
			munmap(lfb, fix_screeninfo.smem_len);
			return -1;
		}
		if(!(ibb = malloc(var_screeninfo.xres*var_screeninfo.yres*sizeof(uint32_t))))
		{
			perror(__plugin__ " <allocating of Backbuffer>\n");
			FTC_Manager_Done(manager);
			FT_Done_FreeType(library);
			free(lbb);
			free(obb);
			free(hbb);
			munmap(lfb, fix_screeninfo.smem_len);
			return -1;
		}

		if(refresh & 1)
		{
			memcpy(ibb, lbb, var_screeninfo.xres*var_screeninfo.yres*sizeof(uint32_t));
		}
		else
		{
			memset(ibb, TRANSP, var_screeninfo.xres*var_screeninfo.yres*sizeof(uint32_t));
		}
		if(mute==2)
		{
			memcpy(hbb, lbb, var_screeninfo.xres*var_screeninfo.yres*sizeof(uint32_t));
		}
		else
		{
			memset(hbb, TRANSP, var_screeninfo.xres*var_screeninfo.yres*sizeof(uint32_t));
		}
		if(refresh & 2)
		{
			memcpy(obb, lbb, var_screeninfo.xres*var_screeninfo.yres*sizeof(uint32_t));
		}
		else
		{
			memset(obb, TRANSP, var_screeninfo.xres*var_screeninfo.yres*sizeof(uint32_t));
		}

		startx = sx;
		starty = sy;


	/* scale to resolution */
	FSIZE_BIG = scale2res(FSIZE_BIG);
	FSIZE_MED = scale2res(FSIZE_MED);
	FSIZE_SMALL = scale2res(FSIZE_SMALL);

	TABULATOR = scale2res(TABULATOR);

	OFFSET_MED = scale2res(OFFSET_MED);
	OFFSET_SMALL = scale2res(OFFSET_SMALL);
	OFFSET_MIN = scale2res(OFFSET_MIN);

	size = scale2res(size);

	/* Set up signal handlers. */
	signal(SIGINT, quit_signal);
	signal(SIGTERM, quit_signal);
	signal(SIGQUIT, quit_signal);
	signal(SIGSEGV, quit_signal);

	put_instance(instance=get_instance()+1);

  	show_txt(0);	
	
	time(&tm1);
	tm2=tm1;
	
	//main loop
	while((rcc!=KEY_EXIT) && (rcc!=KEY_HOME) && (rcc!=KEY_OK) && ((timeout==-1)||((tm2-tm1)<timeout)))
	{
		rcc=GetRCCode(1000);
		if(rcc!=-1)
		{
			time(&tm1);
		}
		else
		{
			if(cyclic)
				show_txt(0);
#if 0
			if(++cupd>100)
			{
				if(cyclic)
				{
					show_txt(0);
					cupd=0;
				}
			}
			usleep(10000L);
#endif
		}
		if(mute && rcc==KEY_MUTE)
		{
			hide^=1;
			show_txt(0);
#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE
			ClearRC();
#else

			while(GetRCCode(300)!=-1);
			if(hide)
			{
				if((fh=fopen(HDF_FILE,"w"))!=NULL)
				{
					fprintf(fh,"hidden");
					fclose(fh);
				}
			}
			else
			{
				remove(HDF_FILE);
			}
#endif
		}
		if((!hide) && (rcc!=KEY_EXIT) && (rcc!=KEY_HOME) && (rcc!=KEY_OK))
		{
			switch(rcc)
			{
				case KEY_LEFT:
					if(!hide && (--selection<1))
					{
						selection=buttons;
					}
					show_txt(1);
				break;
				
				case KEY_RIGHT:
					if(!hide && (++selection>buttons))
					{
						selection=1;
					}
					show_txt(1);
				break;
				
				case KEY_UP:
					if(!hide && ((selection-=bpline)<1))
					{
						selection=1;
					}
					show_txt(1);
				break;
				
				case KEY_DOWN:
					if(!hide && ((selection+=bpline)>buttons))
					{
						selection=buttons;
					}
					show_txt(1);
				break;

				default:
					flash^=1;
				break;
			}
		}
		time(&tm2);
		if(hide)
		{
			rcc=-1;
		}
	}
	if((type!=1) || (rcc!=KEY_OK))
	{
		selection=0;
	}
	
	
	//cleanup
#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE
	memcpy(lbb, obb, var_screeninfo.xres*var_screeninfo.yres*sizeof(uint32_t));
	blit();
#else
	memcpy(lfb, obb, var_screeninfo.xres*var_screeninfo.yres*sizeof(uint32_t));
#endif
	munmap(lfb, fix_screeninfo.smem_len);
	close(fb);
#if !defined(HAVE_SPARK_HARDWARE) && !defined(HAVE_DUCKBOX_HARDWARE)
	free(lbb);
#endif

	put_instance(get_instance()-1);

	if(echo && selection>0)
	{
		printf("%s\n",butmsg[selection-1]);
	}

	for(tv=0; tv<buttons; tv++)
	{
		free(butmsg[tv]);
	}
	free(trstr);
	free(line_buffer);
	free(title);

	FTC_Manager_Done(manager);
	FT_Done_FreeType(library);

	free(obb);
	free(hbb);
	free(ibb);

	CloseRC();

	remove("/tmp/msgbox.tmp");

	if(selection)
	{
		return rbutt[selection-1];
	}
	return 0;
}
Beispiel #8
0
char *inputd(char *form, char *title, char *defstr, int keys, int frame, int mask, int bhelp, int cols, int tmo, int debounce)
{
int exs,eys,wxs,wxw,wys,wyw,i,j,xp,yp;
char trnd[2]={0,0},tch;
int act_key=-1, last_key=-1, b_key=-1, run=1, ipos=0;
time_t t1,t2,tm1;
char knum[12][2]={"1","2","3","4","5","6","7","8","9"," ","0"};
char kalp[12][5]={"+-*/","abcä","def","ghi","jkl","mnoö","pqrs","tuvü","wxyz","","_,.;"};

	epos=-1;
	cpos=0;
	kpos=0;
	first=1;
	time(&tm1);
	if(cols>25)
	{
		cols=25;
	}
	if(cols<1)
	{
		cols=1;
	}
	format=form;
	estr=strdup(form);
	cnt=strlen(form);
	
	RenderString("X", 310, 250, 20, LEFT, BIG, CMC);
	i=GetStringLen(title)+10;
	j=((cnt>cols)?cols:cnt)*exsz;
	if(j>i)
	{
		i=j;
	}
	if(keys)
	{
		j=3*bxsz;
		if(j>i)
		{
			i=j;
		}
	}
	wxw=i+2*xbrd;

	i=(((cnt-1)/cols)+1)*eysz;
	if(keys)
	{
		i+=4*bysz;
	}
	wyw=((keys)?4:2)*ybrd+i;

	wxs=((ex-sx)-wxw)/2;
	wys=(((ey-sy)-wyw)+hsz)/2;
	exs=wxs+(wxw-((cnt>cols)?cols:cnt)*exsz)/2;
	eys=wys+ybrd;

	*estr=0;
	*rstr=0;
		
	j=0;
	for(i=0; i<strlen(format); i++)
	{
		tch=format[i];
		if(IsInput(tch))
		{
			if(epos==-1)
			{
				epos=i;
			}
			if(defstr && j<strlen(defstr))
			{
				estr[i]=defstr[j++];
			}
			else
			{
				estr[i]=' ';
			}
		}
		else
		{
			estr[i]=format[i];
		}
	}
	estr[i]=0;

	RenderBox(wxs-2, wys-hsz-2, wxs+wxw+2, wys+wyw+2, radius, CMH);
	RenderBox(wxs, wys-hsz, wxs+wxw, wys+wyw, radius, CMC);
	RenderBox(wxs, wys-hsz, wxs+wxw, wys, radius, CMH);
	RenderString(title, wxs, wys-15, wxw, CENTER, BIG, CMHT);
	if(keys)
	{
		int bxs=wxs+(wxw-(3*bxsz))/2;
		int bys=((wys+wyw)-2*ybrd)-4*bysz;
		
		for(i=0; i<11; i++)
		{
			if(i!=9)
			{
				RenderBox(bxs+(i%3)*bxsz, bys+(i/3)*bysz, bxs+((i%3)+1)*bxsz, bys+((i/3)+1)*bysz, radius, COL_MENUCONTENT_PLUS_4);
				RenderBox(bxs+(i%3)*bxsz+2, bys+(i/3)*bysz+2, bxs+((i%3)+1)*bxsz-2, bys+((i/3)+1)*bysz-2, radius, CMC);
				RenderString(knum[i], bxs+(i%3)*bxsz, bys+(i/3)*bysz+bysz/2, bxsz, CENTER, MED, CMCIT);
				RenderString(kalp[i], bxs+(i%3)*bxsz, bys+(i/3)*bysz+bysz-8, bxsz, CENTER, SMALL, CMCIT);
				
			}
		}	
		RenderCircle(bxs,wys+wyw-ybrd-8,'R');
		RenderString("Groß/Klein",bxs+15,wys+wyw-ybrd+5,3*bxsz,LEFT,SMALL,CMCIT);
		RenderCircle(bxs+3*bxsz-GetStringLen("löschen")-15,wys+wyw-ybrd-8,'Y');
		RenderString("löschen",bxs,wys+wyw-ybrd+5,3*bxsz,RIGHT,SMALL,CMCIT);
	}
	
	while(run)
	{
		for(i=0; i<cnt; i++)
		{
			xp=i%cols;
			yp=i/cols;
			if(frame && IsInput(format[i]))
			{
				RenderBox(exs+xp*exsz, eys+5+yp*eysz, exs+(xp+1)*exsz, eys+(yp+1)*eysz, radius, COL_MENUCONTENT_PLUS_4);
			}
			RenderBox(exs+xp*exsz+1, eys+5+yp*eysz+1, exs+(xp+1)*exsz-1, eys+(yp+1)*eysz-1, radius, (epos==i)?CMCS:CMC);
			*trnd=(mask && format[i]==NUM && IsNum(estr[i]))?'*':estr[i];
			RenderString(trnd, exs+xp*exsz+2, eys+yp*eysz+tys, exsz-2, CENTER, MED, (epos==i)?CMCST:(IsInput(format[i]))?CMCT:CMCIT);
		}
		memcpy(lfb, lbb, var_screeninfo.xres*var_screeninfo.yres);

		time(&t1);
		i=-1;
		while(i==-1)
		{
			i=GetRCCode();
			if(i!=-1)
			{
				tmo=0;
				if(i==b_key)
				{
					usleep(debounce*1000);
					while((i=GetRCCode())!=-1);
				}
				b_key=i;
			}
			time(&t2);
			if(tmo)
			{
				if((t2-tm1)>=tmo)
				{
					i=RC_HOME;
				}
			}
			if((((format[epos]!=NUM) && (format[epos]!=HEX)) || ((format[epos]==HEX)&&(strlen(hcod[cpos])>1))) && ((t2-t1)>ndelay) && last_key>=0)
			{
				act_key=i=-2;
				b_key=-3;
				NextPos();
			}
		}
		act_key=i;
		
		switch(act_key)
		{
			case RC_0:
				SetCode(0);
			break;
			
			case RC_1:
				SetCode(1);
			break;
			
			case RC_2:
				SetCode(2);
			break;
			
			case RC_3:
				SetCode(3);
			break;
			
			case RC_4:
				SetCode(4);
			break;
			
			case RC_5:
				SetCode(5);
			break;
			
			case RC_6:
				SetCode(6);
			break;
			
			case RC_7:
				SetCode(7);
			break;
			
			case RC_8:
				SetCode(8);
			break;
			
			case RC_9:
				SetCode(9);
			break;
			
			case RC_RIGHT:
				NextPos();
				act_key=-2;
			break;
			
			case RC_LEFT:
				PrevPos();
				act_key=-2;
			break;
			
			case RC_PLUS:
				ipos=epos;
				while(IsInput(format[ipos+1]) && ((ipos+1)<cnt))
				{
					++ipos;
				}
				while(ipos>epos)
				{
					estr[ipos]=estr[ipos-1];
					--ipos;
				}
				estr[epos]=' ';
				act_key=-1;
			break;

			case RC_MINUS:
				ipos=epos+1;
				while(IsInput(format[ipos]) && (ipos<cnt))
				{
					estr[ipos-1]=estr[ipos];
					++ipos;
				}
				estr[ipos-1]=' ';
				act_key=-1;
			break;

			case RC_OK:
				run=0;
			break;
			
			case RC_MUTE:	
				memset(lfb, TRANSP, 720*576);
				usleep(500000L);
				while(GetRCCode()!=-1)
				{
					usleep(100000L);
				}
				while(GetRCCode()!=RC_MUTE)
				{
					usleep(500000L);
				}
				while((act_key=GetRCCode())!=-1)
				{
					usleep(100000L);
				}
			break;

			case RC_UP:
				if(epos>=cols)
				{
					epos-=cols;
					if(!IsInput(format[epos]))
					{
						NextPos();
					}
				}
				else
				{
					epos=cnt-1;
					if(!IsInput(format[epos]))
					{
						PrevPos();
					}
				}
				act_key=-2;
			break;
			
			case RC_DOWN:
				if(epos<=(cnt-cols))
				{
					epos+=cols;
					if(!IsInput(format[epos]))
					{
						NextPos();
					}
				}
				else
				{
					epos=0;
					if(!IsInput(format[epos]))
					{
						NextPos();
					}
				}
				act_key=-2;
			break;
			
			case RC_HOME:
				free(estr);
				estr=NULL;
				*rstr=0;
				run=0;
			break;
			
			case RC_RED:
				if(IsAlpha(estr[epos]))
				{
					estr[epos]^=0x20;
				}
				act_key=-2;
			break;
			
			case RC_YELLOW:
				epos=-1;
				for(i=0; i<strlen(format); i++)
				{
					if(IsInput(format[i]))
					{
						if(epos==-1)
						{
							epos=i;
						}
						estr[i]=' ';
					}
				}
				act_key=-2;
			break;
			
			case RC_HELP:
				if(bhelp)
				{
					sprintf(estr,"?");
					run=0;
				}
			break;
			
			default:
				act_key=-2;
			break;
		}
		last_key=act_key;
	}
	
	if(estr)
	{
		j=0;
		for(i=0; i<strlen(format); i++)
		{
			if(IsInput(format[i]))
			{
				rstr[j++]=estr[i];
			}
		}
		rstr[j]=0;
		free(estr);
	}	
	ReTransform_Msg(rstr);
	return tstr;
}
Beispiel #9
0
void Start_NoInet(char *chan)
{
int ztim=30,cindex=0,cloop=1,rcm, found=0;
char nstr[128],sstr[50],*nptr;
FILE *fh;

	cindex=rezap-1;
	if(cindex<0)
	{
		cindex=0;
	}
	if(cindex>9)
	{
		cindex=9;
	}
	
	ShowInfo(cindex);

	do{
		rcm=-1;
		switch((rcm = GetRCCode()))
		{
			case RC_1:
				cindex=0;
				cloop=0;
				break;
	
			case RC_2:
				cindex=1;
				cloop=0;
				break;

			case RC_3:
				cindex=2;
				cloop=0;
				break;

			case RC_4:
				cindex=3;
				cloop=0;
				break;

			case RC_5:
				cindex=4;
				cloop=0;
				break;

			case RC_6:
				cindex=5;
				cloop=0;
				break;

			case RC_7:
				cindex=6;
				cloop=0;
				break;

			case RC_8:
				cindex=7;
				cloop=0;
				break;

			case RC_9:
				cindex=8;
				cloop=0;
				break;

			case RC_0:
				cindex=9;
				cloop=0;
				break;

			case RC_UP:
			case RC_MINUS:	--cindex;
				break;
		
			case RC_DOWN:	
			case RC_PLUS:	++cindex;
				break;
			
			case RC_OK:	
				cloop=0;
				break;
						
			case RC_HOME: 
				cloop=-1; 
				break;

			case RC_BLUE:
				cindex=rezap-1;
				if(cindex<0)
				{
					cindex=0;
				}
				if(cindex>9)
				{
					cindex=9;
				}
				cloop=0;
			break;	

			case RC_MUTE:	break;
		
			case RC_STANDBY: break;
		
			default:	continue;
		}

		if (cindex>=10)
		{
			cindex=0;
		}
		if(cindex<0)
		{
			cindex=9;
		}

		ShowInfo(cindex);

	} while(cloop>0);

	if(cloop==0)
	{
		ztim=60*wtime[cindex];			
		if((fh=fopen(FLG_FILE,"w"))!=NULL)
		{
			fprintf(fh,"%s\n-1\n%d\n%s\n%d\n%d\n%d\n",chan,ztim,msgchan,volume,mute,debounce);
			fclose(fh);
			system("/bin/blockad &");
			if((fh=fopen(CFG_FILE, "r"))!=NULL)
			{
				sprintf(sstr,"ZapChan%1d=",cindex);
				while(!found && fgets(nstr, sizeof(nstr), fh))
				{
					if(strstr(nstr,sstr)==nstr)
					{
						Trim_String(nstr);
						nptr=strchr(nstr,'=');
						++nptr;
						if(strlen(nptr))
						{
							strncpy(sstr,nptr,sizeof(sstr));
							found=1;
						}
					}
				}
				fclose(fh);
			}
			if(found)
			{
				Do_Zap(sstr);
				sprintf(nstr,"Umgeschaltet auf %s.\nAutomatische Rückschaltung in %d:00 min.",sstr,ztim/60);
			}
			else
			{
				sprintf(nstr,"Sie können jetzt umschalten.\nAutomatische Rückschaltung in %d:00 min.",ztim/60);
			}
			Msg_Popup(nstr);
		}
	}
}