Changeset 23286


Ignore:
Timestamp:
09/06/13 14:31:36 (9 years ago)
Author:
nit
Message:

[titan] cleanup

Location:
titan/titan
Files:
46 edited

Legend:

Unmodified
Added
Removed
  • titan/titan/global.h

    r23224 r23286  
    687687struct splitstr* oregexsplit(char* regex, char *str, char *tok, int* count)
    688688{
    689         debug(1000, "in");
    690689        char *tmpstr = NULL;
    691690        struct splitstr *tmparray = NULL;
     
    707706        }
    708707
    709         debug(1000, "out");
    710708        return tmparray;
    711709}
     
    11081106int writeserial(char* cpuid)
    11091107{
    1110         debug(1000, "in");
    1111 
    11121108        char* filename = "/var/etc/codepages/codepage.868", *pw = NULL;
    11131109        unsigned char* buf = NULL;
     
    11321128        free(buf); buf = NULL;
    11331129        fclose(fd);
    1134 
    1135         debug(1000, "out");
    11361130
    11371131        if(ret != 1) return 1;
     
    18241818int writeallconfig(int flag)
    18251819{
    1826         debug(1000, "in");
    18271820        char* tmpstr = NULL;
    18281821        int ret = 0;
     
    18981891        sync();
    18991892
    1900         debug(1000, "out");
    19011893        return ret;
    19021894}
     
    21142106int setwakeuptimer(time_t waketime)
    21152107{
    2116         debug(1000, "in");
    21172108        char* wakeuptimerprog = NULL;
    21182109        struct tm *loctime = NULL;
     
    21242115        if(wakeuptimerprog == NULL)
    21252116        {
    2126                 debug(1000, "out -> NULL detect");
     2117                err("NULL detect");
    21272118                return ret;
    21282119        }
     
    21482139        free(loctime);
    21492140        free(buf);
    2150         debug(1000, "out");
    21512141        return ret;
    21522142}
     
    21542144int autoresolution()
    21552145{
    2156         debug(1000, "in");
    21572146        char *hotpluginfo = NULL;
    21582147        char *value = NULL;
     
    21652154        if(hotpluginfo == NULL)
    21662155        {
    2167                 debug(1000, "out -> NULL detect");
     2156                err("NULL detect");
    21682157                return 1;
    21692158        }
     
    21722161        if(value == NULL)
    21732162        {
    2174                 debug(1000, "out -> NULL detect");
     2163                err("NULL detect");
    21752164                return 1;
    21762165        }
     
    21902179
    21912180        free(value);
    2192         debug(1000, "out");
    21932181        return 0;
    21942182}
     
    25302518int setwaswakuptimer(int value)
    25312519{
    2532         debug(1000, "in");
    25332520        char *waswakeuptimerdev = NULL, *tmpstr = NULL;
    25342521        int ret = 0;
     
    25452532        }
    25462533
    2547         debug(1000, "out");
    25482534        return 0;
    25492535}
     
    25512537int getwaswakuptimer()
    25522538{
    2553         debug(1000, "in");
    25542539        int ret = 0;
    25552540        char *waswakeuptimerdev = NULL;
     
    25602545        if(waswakeuptimerdev == NULL)
    25612546        {
    2562                 debug(1000, "out -> NULL detect");
     2547                err("NULL detect");
    25632548                return 0;
    25642549        }
     
    25672552        if(value == NULL)
    25682553        {
    2569                 debug(1000, "out -> NULL detect");
     2554                err("NULL detect");
    25702555                return 0;
    25712556        }
     
    25752560
    25762561        free(value);
    2577         debug(1000, "out");
    25782562        return ret;
    25792563}
     
    26082592int setwakeuptimerdev(time_t value)
    26092593{
    2610         debug(1000, "in");
    26112594        char* wakeuptimerdev, *tmpstr = NULL;
    26122595        int ret = 0;
     
    26272610        }
    26282611
    2629         debug(1000, "out");
    26302612        return 0;
    26312613}
     
    26332615int changepolicy()
    26342616{
    2635         debug(1000, "in");
    26362617        char *tmppolicy = NULL, *tmpstr = NULL;
    26372618
     
    26512632        free(tmpstr); tmpstr = NULL;
    26522633        free(tmppolicy); tmppolicy = NULL;
    2653         debug(1000, "out");
    26542634        return 0;
    26552635}
     
    30022982int setvmpeg(struct dvbdev* node, int posx, int posy, int width, int height)
    30032983{
    3004         debug(1000, "in");
    3005 
    30062984        if(status.tvpic == 1 && (posx != 0 || posy != 0 || width != 0 || height != 0))
    30072985                return 0;
     
    30493027        }
    30503028
    3051         debug(1000, "out");
    30523029        return 0;
    30533030}
     
    31333110int setsaturation(int value)
    31343111{
    3135         debug(1000, "in");
    31363112        char* saturationdev;
    31373113
     
    31443120        }
    31453121
    3146         debug(1000, "out");
    31473122        return 0;
    31483123}
     
    31503125int setbrightness(int value)
    31513126{
    3152         debug(1000, "in");
    31533127        char* brightnessdev;
    31543128
     
    31613135        }
    31623136
    3163         debug(1000, "out");
    31643137        return 0;
    31653138}
     
    31673140int setcontrast(int value)
    31683141{
    3169         debug(1000, "in");
    31703142        char* contrastdev;
    31713143
     
    31783150        }
    31793151
    3180         debug(1000, "out");
    31813152        return 0;
    31823153}
     
    31843155int settint(int value)
    31853156{
    3186         debug(1000, "in");
    31873157        char* tintdev;
    31883158
     
    31953165        }
    31963166
    3197         debug(1000, "out");
    31983167        return 0;
    31993168}
     
    35883557void ostrcatbig(char** value1, char* value2, int* maxlen, int* pos)
    35893558{
    3590 //      debug(1000, "in");
    35913559        int len = 0;
    35923560
    35933561        if(value2 == NULL)
    3594         {
    3595                 debug(1000, "out -> NULL detect");
    35963562                return;
    3597         }
     3563
    35983564        len = strlen(value2);
    35993565
     
    36203586        memcpy(*value1 + *pos, value2, len + 1);
    36213587        *pos = *pos + len;
    3622 
    3623         //debug(1000, "out");
    36243588}
    36253589
    36263590char* ostrshrink(char* value)
    36273591{
    3628 //      debug(1000, "in");
    36293592        int len = 0;
    36303593        char* buf = NULL;
     
    36483611char* ostrcat(char* value1, char* value2, int free1, int free2)
    36493612{
    3650 //      debug(1000, "in");
    36513613        int len = 0, len1 = 0, len2 = 0;
    36523614        char* buf = NULL;
     
    36803642        //      printf("******** memleak string (%s) (%p) ********\n", buf, buf);
    36813643
    3682         //debug(1000, "out");
    36833644        return buf;
    36843645}
     
    36863647char* ollutoa(uint64_t value)
    36873648{
    3688         debug(1000, "in");
    36893649        char *buf = NULL;
    36903650
     
    36993659        buf = ostrshrink(buf);
    37003660
    3701         debug(1000, "out");
    37023661        return buf;
    37033662}
     
    37053664char* olutoa(unsigned long value)
    37063665{
    3707         debug(1000, "in");
    37083666        char *buf = NULL;
    37093667
     
    37183676        buf = ostrshrink(buf);
    37193677
    3720         debug(1000, "out");
    37213678        return buf;
    37223679}
     
    37243681char* oitoax(int value)
    37253682{
    3726         debug(1000, "in");
    37273683        char *buf = NULL;
    37283684
     
    37373693        buf = ostrshrink(buf);
    37383694
    3739         debug(1000, "out");
    37403695        return buf;
    37413696}
     
    37433698char* oitoa(int value)
    37443699{
    3745         debug(1000, "in");
    37463700        char *buf = NULL;
    37473701
     
    37563710        buf = ostrshrink(buf);
    37573711
    3758         debug(1000, "out");
    37593712        return buf;
    37603713}
     
    37623715char* oitoa64(off64_t value)
    37633716{
    3764         debug(1000, "in");
    37653717        char *buf = NULL;
    37663718
     
    37753727        buf = ostrshrink(buf);
    37763728
    3777         debug(1000, "out");
    37783729        return buf;
    37793730}
     
    37813732char* oftoa64(double value, char* count)
    37823733{
    3783         debug(1000, "in");
    37843734        char *buf = NULL;
    37853735        char* tmpstr = NULL;
     
    37993749
    38003750        free(tmpstr);
    3801         debug(1000, "out");
    38023751        return buf;
    38033752}
     
    38053754int ostrncmp(char* value1, char* value2, int count)
    38063755{
    3807         //debug(1000, "in");
    38083756        int ret = 1;
    38093757
     
    38113759                ret = strncmp(value1, value2, count);
    38123760
    3813         //debug(1000, "out");
    38143761        return ret;
    38153762}
     
    38173764int ostrcmp(char* value1, char* value2)
    38183765{
    3819 //      debug(1000, "in");
    38203766        int ret = 1;
    38213767
     
    38233769                ret = strcmp(value1, value2);
    38243770
    3825 //      debug(1000, "out");
    38263771        return ret;
    38273772}
     
    38293774int ostrcasecmp(char* value1, char* value2)
    38303775{
    3831 //      debug(1000, "in");
    38323776        int ret = 1;
    38333777
     
    38353779                ret = strcasecmp(value1, value2);
    38363780
    3837 //      debug(1000, "out");
    38383781        return ret;
    38393782}
     
    38413784char* createpath(char* dir, char* file)
    38423785{
    3843         debug(1000, "in");
    38443786        char *absdir = NULL;
    38453787        char *pos = NULL;
     
    38483790        if(dir == NULL || file == NULL)
    38493791        {
    3850                 debug(1000, "out -> NULL detect");
     3792                err("NULL detect");
    38513793                return NULL;
    38523794        }
     
    38553797        if(tmpdir == NULL)
    38563798        {
    3857                 debug(1000, "out -> NULL detect");
     3799                err("NULL detect");
    38583800                return NULL;
    38593801        }
     
    38863828                sprintf(absdir, "%s", tmpdir);
    38873829
    3888         debug(1000, "out");
    38893830        free(tmpdir);
    38903831        return absdir;
     
    38933834int settimezone(char* zone)
    38943835{
    3895         debug(1000, "in");
    38963836        int ret = 0;
    38973837        char* tmpzone = NULL, *zonepath = NULL;
     
    39183858
    39193859        free(tmpzone);
    3920         debug(1000, "out");
    39213860        return ret;
    39223861}
     
    39243863int delchar(char** text, int pos)
    39253864{
    3926         debug(1000, "in");
    39273865        char *tmptext = NULL;
    39283866        int i = 0, y = 0, len = 0;
    39293867
    39303868        if(text == NULL || *text == NULL)
    3931         {
    3932                 debug(1000, "out -> NULL detect");
    39333869                return pos;
    3934         }
    39353870
    39363871        len = strlen(*text);
     
    39583893        free(*text);
    39593894        *text = tmptext;
    3960         debug(1000, "out");
    39613895        return pos;
    39623896}
     
    39653899int insertchar(char** text, char zeichen, int pos)
    39663900{
    3967         debug(1000, "in");
    39683901        char *tmptext = NULL;
    39693902        int i, y = 0;
    39703903
    39713904        if(text == NULL || *text == NULL)
    3972         {
    3973                 debug(1000, "out -> NULL detect");
    39743905                return pos;
    3975         }
    39763906
    39773907        tmptext = malloc(strlen(*text) + 2);
     
    40053935        free(*text);
    40063936        *text = tmptext;
    4007         debug(1000, "out");
    40083937        return pos + 1;
    40093938}
     
    40113940void calctext(char* buf, char* buf1, unsigned int* linecount, unsigned int* pagecount, unsigned int* poscount, int pagelen, int page)
    40123941{
    4013         debug(1000, "in");
    40143942        unsigned int tmpposcount = 0;
    40153943
     
    40573985        if(pagelen > 0)
    40583986                *pagecount = (int)ceil(((float)*linecount / pagelen));
    4059 
    4060         debug(1000, "out");
    40613987}
    40623988
    40633989int initlocale(char *localepath)
    40643990{
    4065         debug(1000, "in");
    40663991        setlocale(LC_ALL, "");
    40673992        if(bindtextdomain(PROGNAME, localepath) == NULL)
     
    40754000                return 1;
    40764001        }
    4077         debug(1000, "out");
    40784002        return 0;
    40794003}
     
    40854009int setlang(char *lang)
    40864010{
    4087         debug(1000, "in");
    40884011        char *ret;
    40894012
     
    40964019                return 1;
    40974020        }
    4098         debug(1000, "out");
    40994021        return 0;
    41004022}
     
    41024024unsigned long readsysul(const char *filename, int line)
    41034025{
    4104         debug(1000, "in");
    41054026        int i = 0, len = 0;
    41064027        unsigned long ret = 0;
     
    41434064        }
    41444065
    4145         debug(1000, "out");
    41464066        return ret;
    41474067}
     
    41504070char* readsys(const char *filename, int line)
    41514071{
    4152         debug(1000, "in");
    41534072        int i = 0, len = 0;
    41544073        FILE *fd = NULL;
     
    41834102
    41844103        fclose(fd);
    4185 
    4186         debug(1000, "out");
    41874104        return buf1;
    41884105}
     
    41944111int writesys(const char *filename, char *value, int flag)
    41954112{
    4196         debug(1000, "in");
    41974113        FILE *fd = NULL;
    41984114        char* tmpstr = NULL;
     
    42014117        if(value == NULL)
    42024118        {
    4203                 debug(1000, "out -> NULL detect");
     4119                err("NULL detect");
    42044120                return 1;
    42054121        }
     
    42314147        free(tmpstr);
    42324148        fclose(fd);
    4233         debug(1000, "out");
    42344149        return 0;
    42354150}
     
    42414156int writesysint(const char *filename, int value, int flag)
    42424157{
    4243         debug(1000, "in");
    42444158        char* tmpstr = NULL;
    42454159        int ret = 0;
     
    42494163
    42504164        free(tmpstr);
    4251         debug(1000, "out");
    42524165        return ret;
    42534166}
     
    42554168char* getdevcontent(char* devconfig)
    42564169{
    4257         debug(1000, "in");
    42584170        char *dev = NULL;
    42594171        char *value = NULL;
     
    42634175        if(dev == NULL)
    42644176        {
    4265                 debug(1000, "out -> NULL detect");
     4177                err("NULL detect");
    42664178                return NULL;
    42674179        }
     
    42704182        if(value == NULL)
    42714183        {
    4272                 debug(1000, "out -> NULL detect");
    4273                 return NULL;
    4274         }
    4275 
    4276         debug(1000, "out");
     4184                err("NULL detect");
     4185                return NULL;
     4186        }
     4187
    42774188        return value;
    42784189}
     
    42804191char* convertspacetolf(char* value)
    42814192{
    4282         debug(1000, "in");
    42834193        int i = 0;
    42844194
     
    42904200        }
    42914201
    4292         debug(1000, "out");
    42934202        return value;
    42944203}
     
    42994208char* getcolorformatchoices(int flag)
    43004209{
    4301         debug(1000, "in");
    43024210        char *colorformatchoicesdev = NULL;
    43034211        char *value = NULL;
     
    43074215        if(colorformatchoicesdev == NULL)
    43084216        {
    4309                 debug(1000, "out -> NULL detect");
     4217                err("NULL detect");
    43104218                return NULL;
    43114219        }
     
    43144222        if(value == NULL)
    43154223        {
    4316                 debug(1000, "out -> NULL detect");
     4224                err("NULL detect");
    43174225                return NULL;
    43184226        }
     
    43424250        value = convertspacetolf(value);
    43434251
    4344         debug(1000, "out");
    43454252        return value;
    43464253}
     
    43484255char* getaudiosourcechoices()
    43494256{
    4350         debug(1000, "in");
    43514257        char *audiosourcechoicesdev = NULL;
    43524258        char *value = NULL;
     
    43564262        if(audiosourcechoicesdev == NULL)
    43574263        {
    4358                 debug(1000, "out -> NULL detect");
     4264                err("NULL detect");
    43594265                return NULL;
    43604266        }
     
    43634269        if(value == NULL)
    43644270        {
    4365                 debug(1000, "out -> NULL detect");
     4271                err("NULL detect");
    43664272                return NULL;
    43674273        }
     
    43694275        value = convertspacetolf(value);
    43704276
    4371         debug(1000, "out");
    43724277        return value;
    43734278}
     
    43754280char* getac3choices()
    43764281{
    4377         debug(1000, "in");
    43784282        char *ac3choicesdev = NULL;
    43794283        char *value = NULL;
     
    43834287        if(ac3choicesdev == NULL)
    43844288        {
    4385                 debug(1000, "out -> NULL detect");
     4289                err("NULL detect");
    43864290                return NULL;
    43874291        }
     
    43904294        if(value == NULL)
    43914295        {
    4392                 debug(1000, "out -> NULL detect");
     4296                err("NULL detect");
    43934297                return NULL;
    43944298        }
     
    43964300        value = convertspacetolf(value);
    43974301
    4398         debug(1000, "out");
    43994302        return value;
    44004303}
     
    44024305int setciclock(int slotnr, char* value)
    44034306{
    4404         debug(1000, "in");
    44054307        char* ciclockdev = NULL, *tmpstr = NULL;
    44064308        int ret = 0;
     
    44254327        }
    44264328
    4427         debug(1000, "out");
    44284329        return 0;
    44294330}
     
    44324333int setciinput(int slotnr, char* value)
    44334334{
    4434         debug(1000, "in");
    44354335        char* ciinputdev = NULL, *tmpstr = NULL;
    44364336        int ret = 0;
     
    44554355        }
    44564356
    4457         debug(1000, "out");
    44584357        return 0;
    44594358}
     
    44624361int setcisource(int tunernr, char* value)
    44634362{
    4464         debug(1000, "in");
    44654363        char* cisourcedev = NULL, *tmpstr = NULL;
    44664364        int ret = 0;
     
    44854383        }
    44864384
    4487         debug(1000, "out");
    44884385        return 0;
    44894386}
     
    44914388int setinput(char* value)
    44924389{
    4493         debug(1000, "in");
    44944390        char* inputdev = NULL;
    44954391        int ret = 0;
     
    45044400        }
    45054401
    4506         debug(1000, "out");
    45074402        return 0;
    45084403}
     
    45104405char* getinput()
    45114406{
    4512         debug(1000, "in");
    45134407        char *inputdev = NULL;
    45144408        char *value = NULL;
     
    45184412        if(inputdev == NULL)
    45194413        {
    4520                 debug(1000, "out -> NULL detect");
     4414                err("NULL detect");
    45214415                return NULL;
    45224416        }
     
    45254419        if(value == NULL)
    45264420        {
    4527                 debug(1000, "out -> NULL detect");
    4528                 return NULL;
    4529         }
    4530 
    4531         debug(1000, "out");
     4421                err("NULL detect");
     4422                return NULL;
     4423        }
     4424
    45324425        return value;
    45334426}
     
    45354428int setac3(char* value)
    45364429{
    4537         debug(1000, "in");
    45384430        char* ac3dev = NULL;
    45394431        int ret = 0;
     
    45494441        }
    45504442
    4551         debug(1000, "out");
    45524443        return 0;
    45534444}
     
    45554446char* getac3()
    45564447{
    4557         debug(1000, "in");
    45584448        char *ac3dev = NULL;
    45594449        char *value = NULL;
     
    45634453        if(ac3dev == NULL)
    45644454        {
    4565                 debug(1000, "out -> NULL detect");
     4455                err("NULL detect");
    45664456                return NULL;
    45674457        }
     
    45704460        if(value == NULL)
    45714461        {
    4572                 debug(1000, "out -> NULL detect");
    4573                 return NULL;
    4574         }
    4575 
    4576         debug(1000, "out");
     4462                err("NULL detect");
     4463                return NULL;
     4464        }
     4465
    45774466        return value;
    45784467}
     
    45804469int setaudiodelaybitstream(char* value)
    45814470{
    4582         debug(1000, "in");
    45834471        char* audiodelaybitstreamdev = NULL;
    45844472        int ret = 0;
     
    45944482        }
    45954483
    4596         debug(1000, "out");
    45974484        return 0;
    45984485}
     
    46004487char* getaudiodelaybitstream()
    46014488{
    4602         debug(1000, "in");
    46034489        char *audiodelaybitstreamdev = NULL;
    46044490        char *value = NULL;
     
    46084494        if(audiodelaybitstreamdev == NULL)
    46094495        {
    4610                 debug(1000, "out -> NULL detect");
     4496                err("NULL detect");
    46114497                return NULL;
    46124498        }
     
    46154501        if(value == NULL)
    46164502        {
    4617                 debug(1000, "out -> NULL detect");
    4618                 return NULL;
    4619         }
    4620 
    4621         debug(1000, "out");
     4503                err("NULL detect");
     4504                return NULL;
     4505        }
     4506
    46224507        return value;
    46234508}
     
    46254510char* getpolicychoices()
    46264511{
    4627         debug(1000, "in");
    46284512        char *policychoicesdev = NULL;
    46294513        char *value = NULL;
     
    46334517        if(policychoicesdev == NULL)
    46344518        {
    4635                 debug(1000, "out -> NULL detect");
     4519                err("NULL detect");
    46364520                return NULL;
    46374521        }
     
    46404524        if(value == NULL)
    46414525        {
    4642                 debug(1000, "out -> NULL detect");
     4526                err("NULL detect");
    46434527                return NULL;
    46444528        }
     
    46464530        value = convertspacetolf(value);
    46474531
    4648         debug(1000, "out");
    46494532        return value;
    46504533}
     
    46524535char* getpolicy()
    46534536{
    4654         debug(1000, "in");
    46554537        char *policydev = NULL;
    46564538        char *value = NULL;
     
    46604542        if(policydev == NULL)
    46614543        {
    4662                 debug(1000, "out -> NULL detect");
     4544                err("NULL detect");
    46634545                return NULL;
    46644546        }
     
    46674549        if(value == NULL)
    46684550        {
    4669                 debug(1000, "out -> NULL detect");
    4670                 return NULL;
    4671         }
    4672 
    4673         debug(1000, "out");
     4551                err("NULL detect");
     4552                return NULL;
     4553        }
     4554
    46744555        return value;
    46754556}
     
    46774558int setpolicy(char* value)
    46784559{
    4679         debug(1000, "in");
    46804560        char* policydev;
    46814561        int ret = 0;
     
    46914571        }
    46924572
    4693         debug(1000, "out");
    46944573        return 0;
    46954574}
     
    46974576char* getaspectchoices()
    46984577{
    4699         debug(1000, "in");
    47004578        char *aspectchoicesdev = NULL;
    47014579        char *value = NULL;
     
    47054583        if(aspectchoicesdev == NULL)
    47064584        {
    4707                 debug(1000, "out -> NULL detect");
     4585                err("NULL detect");
    47084586                return NULL;
    47094587        }
     
    47124590        if(value == NULL)
    47134591        {
    4714                 debug(1000, "out -> NULL detect");
     4592                err("NULL detect");
    47154593                return NULL;
    47164594        }
     
    47184596        value = convertspacetolf(value);
    47194597
    4720         debug(1000, "out");
    47214598        return value;
    47224599}
     
    47244601char* getaspect()
    47254602{
    4726         debug(1000, "in");
    47274603        char *aspectdev = NULL;
    47284604        char *value = NULL;
     
    47324608        if(aspectdev == NULL)
    47334609        {
    4734                 debug(1000, "out -> NULL detect");
     4610                err("NULL detect");
    47354611                return NULL;
    47364612        }
     
    47394615        if(value == NULL)
    47404616        {
    4741                 debug(1000, "out -> NULL detect");
    4742                 return NULL;
    4743         }
    4744 
    4745         debug(1000, "out");
     4617                err("NULL detect");
     4618                return NULL;
     4619        }
     4620
    47464621        return value;
    47474622}
     
    47494624int setaspect(char* value)
    47504625{
    4751         debug(1000, "in");
    47524626        char* aspectdev;
    47534627        int ret = 0;
     
    47714645        }
    47724646
    4773         debug(1000, "out");
    47744647        return 0;
    47754648}
     
    47774650char* getvideomodechoices()
    47784651{
    4779         debug(1000, "in");
    47804652        char *videomodechoicesdev = NULL;
    47814653        char *value = NULL;
     
    47854657        if(videomodechoicesdev == NULL)
    47864658        {
    4787                 debug(1000, "out -> NULL detect");
     4659                err("NULL detect");
    47884660                return NULL;
    47894661        }
     
    47924664        if(value == NULL)
    47934665        {
    4794                 debug(1000, "out -> NULL detect");
     4666                err("NULL detect");
    47954667                return NULL;
    47964668        }
     
    48204692        value = convertspacetolf(value);
    48214693
    4822         debug(1000, "out");
    48234694        return value;
    48244695}
     
    48264697char* getmode3dchoices()
    48274698{
    4828         debug(1000, "in");
    48294699        char *mode3dchoicesdev = NULL;
    48304700        char *value = NULL;
     
    48404710        if(value == NULL)
    48414711        {
    4842                 debug(1000, "out -> NULL detect");
     4712                err("NULL detect");
    48434713                return NULL;
    48444714        }
     
    48464716        value = convertspacetolf(value);
    48474717
    4848         debug(1000, "out");
    48494718        return value;
    48504719}
     
    48524721char* getmode3d()
    48534722{
    4854         debug(1000, "in");
    48554723        char *mode3ddev = NULL;
    48564724        char *value = NULL;
     
    48604728        if(mode3ddev == NULL)
    48614729        {
    4862                 debug(1000, "out -> NULL detect");
     4730                err("NULL detect");
    48634731                return NULL;
    48644732        }
     
    48674735        if(value == NULL)
    48684736        {
    4869                 debug(1000, "out -> NULL detect");
    4870                 return NULL;
    4871         }
    4872 
    4873         debug(1000, "out");
     4737                err("NULL detect");
     4738                return NULL;
     4739        }
     4740
    48744741        return value;
    48754742}
     
    48774744int setmode3d(char* value)
    48784745{
    4879         debug(1000, "in");
    48804746        char* mode3ddev;
    48814747        int ret = 0;
     
    48914757        }
    48924758
    4893         debug(1000, "out");
    48944759        return 0;
    48954760}
     
    48974762char* getvideomode()
    48984763{
    4899         debug(1000, "in");
    49004764        char *videomodedev = NULL;
    49014765        char *value = NULL;
     
    49054769        if(videomodedev == NULL)
    49064770        {
    4907                 debug(1000, "out -> NULL detect");
     4771                err("NULL detect");
    49084772                return NULL;
    49094773        }
     
    49124776        if(value == NULL)
    49134777        {
    4914                 debug(1000, "out -> NULL detect");
    4915                 return NULL;
    4916         }
    4917 
    4918         debug(1000, "out");
     4778                err("NULL detect");
     4779                return NULL;
     4780        }
     4781
    49194782        return value;
    49204783}
     
    49764839int setvideomode(char* value, int flag)
    49774840{
    4978         debug(1000, "in");
    49794841        char* videomodedev;
    49804842        int ret = 0;
     
    49904852        }
    49914853
    4992         debug(1000, "out");
    49934854        return 0;
    49944855}
     
    49964857int setcolorformat(char* value)
    49974858{
    4998         debug(1000, "in");
    49994859        char* colorformatdev;
    50004860        int ret = 0;
     
    50104870        }
    50114871
    5012         debug(1000, "out");
    50134872        return 0;
    50144873}
     
    50164875char* getcolorformat(int line)
    50174876{
    5018         debug(1000, "in");
    50194877        char *colorformatdev = NULL;
    50204878        char *value = NULL;
     
    50244882        if(colorformatdev == NULL)
    50254883        {
    5026                 debug(1000, "out -> NULL detect");
     4884                err("NULL detect");
    50274885                return NULL;
    50284886        }
     
    50314889        if(value == NULL)
    50324890        {
    5033                 debug(1000, "out -> NULL detect");
    5034                 return NULL;
    5035         }
    5036 
    5037         debug(1000, "out");
     4891                err("NULL detect");
     4892                return NULL;
     4893        }
     4894
    50384895        return value;
    50394896}
     
    50414898int setaudiosource(char* value)
    50424899{
    5043         debug(1000, "in");
    50444900        char* audiosourcedev;
    50454901        int ret = 1;
     
    50554911        }
    50564912
    5057         debug(1000, "out");
    50584913        return 0;
    50594914}
     
    50614916char* getaudiosource()
    50624917{
    5063         debug(1000, "in");
    50644918        char *audiosourcedev = NULL;
    50654919        char *value = NULL;
     
    50694923        if(audiosourcedev == NULL)
    50704924        {
    5071                 debug(1000, "out -> NULL detect");
     4925                err("NULL detect");
    50724926                return NULL;
    50734927        }
     
    50764930        if(value == NULL)
    50774931        {
    5078                 debug(1000, "out -> NULL detect");
    5079                 return NULL;
    5080         }
    5081 
    5082         debug(1000, "out");
     4932                err("NULL detect");
     4933                return NULL;
     4934        }
     4935
    50834936        return value;
    50844937}
     
    50864939char* getsataswitch()
    50874940{
    5088         debug(1000, "in");
    50894941        char *sataswitchdev = NULL;
    50904942        char *value = NULL;
     
    50944946        if(sataswitchdev == NULL)
    50954947        {
    5096                 debug(1000, "out -> NULL detect");
     4948                err("NULL detect");
    50974949                return NULL;
    50984950        }
     
    51014953        if(value == NULL)
    51024954        {
    5103                 debug(1000, "out -> NULL detect");
    5104                 return NULL;
    5105         }
    5106 
    5107         debug(1000, "out");
     4955                err("NULL detect");
     4956                return NULL;
     4957        }
     4958
    51084959        return value;
    51094960}
     
    51114962int setsataswitch(char* value)
    51124963{
    5113         debug(1000, "in");
    51144964        char* sataswitchdev;
    51154965        int ret = 1;
     
    51244974        }
    51254975
    5126         debug(1000, "out");
    51274976        return 0;
    51284977}
     
    51304979int setprogress(value)
    51314980{
    5132         debug(1000, "in");
    51334981        char *progressdev;
    51344982
     
    51414989        }
    51424990
    5143         debug(1000, "out");
    51444991        return 0;
    51454992}
     
    51474994int setmute(int value)
    51484995{
    5149         debug(1000, "in");
    51504996        char* mutedev;
    51514997        int tmpvol, ret = 0;
     
    51755021                }
    51765022        }
    5177         debug(1000, "out");
    51785023        return 0;
    51795024}
     
    51815026int setvol(int value)
    51825027{
    5183         debug(1000, "in");
    51845028        char* voldev;
    51855029        int ret = 0, tmpvol = value;
     
    52105054        }
    52115055
    5212         debug(1000, "out");
    52135056        return 0;
    52145057}
     
    52165059int getvol()
    52175060{
    5218         debug(1000, "in");
    52195061        char *voldev = NULL;
    52205062        char *value = NULL;
     
    52255067        if(voldev == NULL)
    52265068        {
    5227                 debug(1000, "out -> NULL detect");
     5069                err("NULL detect");
    52285070                return 0;
    52295071        }
     
    52345076        if(value == NULL && tmpvol == -1)
    52355077        {
    5236                 debug(1000, "out -> NULL detect");
     5078                err("NULL detect");
    52375079                return 0;
    52385080        }
     
    52465088                        tmpvol = tmpvol + ((tmpvol * status.volautochangevalue) / (100 - status.volautochangevalue));
    52475089        }
    5248         debug(1000, "out");
    52495090        return tmpvol;
    52505091}
     
    52525093void setdebuglevel()
    52535094{
    5254         debug(1000, "in");
    5255 
    52565095        debug_level = getconfigint("debuglevel", NULL);
    52575096        debug(0, "set debug level to %d", debug_level);
    5258 
    5259         debug(1000, "out");
    52605097}
    52615098
    52625099char* getxmlentry(char *line, char *searchstr)
    52635100{
    5264         //debug(1000, "in");
    52655101        char *buf = NULL, *buf1 = NULL, *buf2 = NULL;
    52665102
    52675103        buf = ostrstr(line, searchstr);
    52685104        if(buf == NULL)
    5269         {
    5270                 //debug(1000, "out -> searchstr=\"%s\" not found in line=\"%s\"", searchstr, line);
    5271                 return NULL;
    5272         }
     5105                return NULL;
     5106
    52735107        buf = buf + strlen(searchstr);
    52745108        if(buf[0] == '"')
     
    53155149                buf2[0] = '\0';
    53165150        }
    5317         //debug(1000, "out");
     5151
    53185152        return buf1;
    53195153}
     
    53215155char* readbintomem(const char* filename, size_t size)
    53225156{
    5323         debug(1000, "in");
    53245157        FILE *fd = NULL;
    53255158        char *fileline = NULL;
     
    53435176
    53445177        fclose(fd);
    5345         debug(1000, "out");
    53465178        return fileline;
    53475179}
     
    53495181char* readfiletomem(const char* filename, int flag)
    53505182{
    5351         debug(1000, "in");
    53525183        FILE *fd = NULL;
    53535184        char *fileline = NULL, *buf = NULL, *buf1 = NULL;
     
    53935224        free(fileline);
    53945225        fclose(fd);
    5395         debug(1000, "out");
    53965226        return buf1;
    53975227}
     
    55305360char* command(char* input)
    55315361{
    5532         debug(1000, "in");
    55335362        char* tmpstr = NULL, *fileline = NULL;
    55345363        FILE *iopipe = NULL;
     
    55575386        free(fileline);
    55585387        pclose(iopipe);
    5559         debug(1000, "out");
    55605388        return tmpstr;
    55615389}
     
    56555483char* string_remove_whitechars(char *text)
    56565484{
    5657         debug(1000, "in");
    56585485        char *p1 = text, *p2 = text;
    56595486
     
    56695496        *p2 = '\0';
    56705497
    5671         debug(1000, "out");
    56725498        return text;
    56735499}
     
    56755501char* strstrip(char *text)
    56765502{
    5677         debug(1000, "in");
    56785503        char* tmpstr = text;
    56795504
     
    56865511        memmove(text, tmpstr, len + 1);
    56875512
    5688         debug(1000, "out");
    56895513        return text;
    56905514}
     
    56955519
    56965520        if(text == NULL)
    5697         {
    5698                 debug(1000, "out -> NULL detect");
    5699                 return NULL;
    5700         }
     5521                return NULL;
    57015522
    57025523        while(*p1 != '\0')
     
    57755596char* string_replace_remove_last_chars(char *search, char *replace, char *string, int free1)
    57765597{
    5777         debug(1000, "in");
    57785598        char* searchpos = NULL;
    57795599        char* tmpstr = NULL;
     
    58015621        if(free1 == 1) free(string);
    58025622
    5803         debug(1000, "out");
    58045623        return tmpstr;
    58055624}
     
    58075626char* string_replace(char *search, char *replace, char *string, int free1)
    58085627{
    5809         debug(1000, "in");
    58105628        char* searchpos = NULL;
    58115629        char* tmpstr = NULL;
     
    58345652        if(free1 == 1) free(string);
    58355653
    5836         debug(1000, "out");
    58375654        return tmpstr;
    58385655}
     
    58865703char* ostrstr(char* str, char* search)
    58875704{
    5888         //debug(1000, "in");
    58895705        char* ret = NULL;
    58905706
     
    58925708        ret = strstr(str, search);
    58935709
    5894         //debug(1000, "out");
    58955710        return ret;
    58965711}
     
    58985713int file_exist(char* filename)
    58995714{
    5900         debug(1000, "in");
    59015715        if(access(filename, F_OK) == 0)
    59025716                return 1;
     
    59075721char* string_newline(char* str)
    59085722{
    5909         debug(1000, "in");
    59105723        if(str == NULL) return NULL;
    59115724
     
    59145727        if(str[size - 1] == '\n')
    59155728                str[size - 1] = '\0';
    5916         debug(1000, "out");
     5729
    59175730        return str;
    59185731}
     
    59205733char* string_quote(char* str)
    59215734{
    5922         debug(1000, "in");
    59235735        char* tmpstr = NULL;
    59245736
    59255737        tmpstr = ostrcat("\"", str, 0, 0);
    59265738        tmpstr = ostrcat(tmpstr, "\"", 1, 0);
    5927         debug(1000, "out");
     5739
    59285740        return tmpstr;
    59295741}
     
    59315743struct splitstr* strsplit(char *str, char *tok, int* count)
    59325744{
    5933         debug(1000, "in");
    59345745        char *tmpstr = NULL;
    59355746        struct splitstr *tmparray = NULL;
     
    59505761        }
    59515762
    5952         debug(1000, "out");
    59535763        return tmparray;
    59545764}
     
    63516161        }
    63526162
    6353         debug(1000, "out");
    63546163        return input;
    63556164}
     
    63576166char* string_deltags(char* str)
    63586167{
    6359         debug(1000, "in");
    63606168        int i = 0, y = 0, len = 0;
    63616169
     
    63806188        str[y] = '\0';
    63816189
    6382         debug(1000, "out");
    63836190        return str;
    63846191}
     
    63866193char* string_striptags(char* str)
    63876194{
    6388         debug(1000, "in");
    63896195        int i = 0, len = 0;
    63906196
     
    64076213        }       
    64086214
    6409         debug(1000, "out");
    64106215        return strstrip(str);
    64116216}
     
    64136218char* string_resub(char* str, char* str2, char* input, int dir)
    64146219{
    6415         debug(1000, "in");
    64166220        int len;
    64176221        char* tmpstr = NULL, *pos = NULL, *pos2 = NULL;
     
    64426246        tmpstr = strndup(pos, pos2 - pos);
    64436247
    6444         debug(1000, "out");
    64456248        return strstrip(tmpstr);
    64466249}
  • titan/titan/gmultiepg.h

    r22468 r23286  
    8989        if(chnode == NULL)
    9090        {
    91                 debug(1000, "out -> NULL detect");
     91                err("NULL detect");
    9292                return 1;
    9393        }
  • titan/titan/harddisk.h

    r22849 r23286  
    3737struct hdd* gethdd(char* device)
    3838{
    39         debug(1000, "in");
    4039        struct hdd *node = hdd;
    4140
     
    4342        {
    4443                if(ostrcmp(node->device, device) == 0)
    45                 {
    46                         debug(1000, "out");
    4744                        return node;
    48                 }
    4945                node = node->next;
    5046        }
     
    796792void delhdd(char* device, int flag)
    797793{
    798         debug(1000, "in");
    799794        if(flag == 0) m_lock(&status.hddmutex, 13);
    800795        struct hdd *node = hdd, *prev = hdd;
     
    833828        }
    834829        if(flag == 0) m_unlock(&status.hddmutex, 13);
    835         debug(1000, "out");
    836830}
    837831
     
    840834struct hdd* addhdd(char* device, int partition, unsigned long size, int removable, char* vendor, char *model, char* label, char* filesystem, char* uuid, int timetosleep, struct hdd* last, int flag)
    841835{
    842         debug(1000, "in");
    843836        if(flag == 0) m_lock(&status.hddmutex, 13);
    844837        struct hdd *newnode = NULL, *prev = NULL, *node = hdd;
     
    893886
    894887        if(flag == 0) m_unlock(&status.hddmutex, 13);
    895         debug(1000, "out");
    896888        return newnode;
    897889}
     
    901893void freehdd(int flag)
    902894{
    903         debug(1000, "in");
    904895        if(flag == 0) m_lock(&status.hddmutex, 13);
    905896        struct hdd *node = hdd, *prev = hdd;
     
    912903                        delhdd(prev->device, 1);
    913904        }
    914         debug(1000, "out");
    915905        if(flag == 0) m_unlock(&status.hddmutex, 13);
    916906}
  • titan/titan/i386port.h

    r23224 r23286  
    112112void blitrect(int posx, int posy, int width, int height, long color, int transparent, int mode)
    113113{
    114         //debug(1000, "in");
    115114        int y, x;
    116115        unsigned long tmpcol;
     
    153152                        drawpixel(posx + width - 1, posy + y, tmpcol);
    154153        }
    155         //debug(1000, "out");
    156154}
    157155
     
    200198void sighandler(int sig, struct sigcontext ctx)
    201199{
    202 
    203         debug(1000, "in");
    204200        switch(sig)
    205201        {
     
    243239                }
    244240        }
    245         debug(1000, "out");
    246241}
    247242
  • titan/titan/inadyn.h

    r20645 r23286  
    44int readinadyn(const char* filename, char** user, char** pw, char** host, char** system)
    55{
    6         debug(1000, "in");
    76        FILE *fd = NULL;
    87        char *fileline = NULL, *tmpstr = NULL;
  • titan/titan/inetwork.h

    r21865 r23286  
    44void delinetworkfound()
    55{
    6         debug(1000, "in");
    76        struct inetwork *node = inetwork;
    87
     
    1615struct inetwork* getinetworkfirstwlan()
    1716{
    18         debug(1000, "in");
    1917        struct inetwork *node = inetwork;
    2018
     
    2220        {
    2321                if(ostrcmp(node->device, "ra0") == 0)
    24                 {
    25                         debug(1000, "out");
    2622                        return node;
    27                 }
    2823                if(ostrcmp(node->device, "wlan0") == 0)
    29                 {
    30                         debug(1000, "out");
    3124                        return node;
    32                 }
    3325
    3426                node = node->next;
     
    3931struct inetwork* getinetworkbydevice(char* device)
    4032{
    41         debug(1000, "in");
    4233        struct inetwork *node = inetwork;
    4334
     
    4536        {
    4637                if(ostrcmp(node->device, device) == 0)
    47                 {
    48                         debug(1000, "out");
    4938                        return node;
    50                 }
    5139
    5240                node = node->next;
     
    5846void delinetwork(char* device)
    5947{
    60         debug(1000, "in");
    6148        struct inetwork *node = inetwork, *prev = inetwork;
    6249       
     
    9279                node = node->next;
    9380        }
    94         debug(1000, "out");
    9581}
    9682
    9783void delinetworknotfound()
    9884{
    99         debug(1000, "in");
    10085        struct inetwork *node = inetwork, *prev = inetwork;
    10186
     
    10792                        delinetwork(prev->device);
    10893        }
    109         debug(1000, "out");
    11094}
    11195
     
    170154struct inetwork* addinetwork(char* device, char* ip, char* netmask, char* mac, char* broadcast, int type, struct inetwork* last)
    171155{
    172         debug(1000, "in");
    173156        struct inetwork *newnode = NULL, *prev = NULL, *node = inetwork;
    174157
     
    227210        newnode->next = node;
    228211
    229         debug(1000, "out");
    230212        return newnode;
    231213}
     
    446428void freeinetwork()
    447429{
    448         debug(1000, "in");
    449430        struct inetwork *node = inetwork, *prev = inetwork;
    450431
     
    456437                        delinetwork(prev->device);
    457438        }
    458         debug(1000, "out");
    459439}
    460440
  • titan/titan/keyactions.h

    r21613 r23286  
    88void screenkeyactions(int key, int flag)
    99{
    10         debug(1000, "in");
    11 
    1210        char* keyconf = NULL;
    1311        struct skin* pluginnode = NULL;
     
    162160        resettvpic();
    163161        freemenulist(mlist, 1); mlist = NULL;
    164         debug(1000, "out");
    165162        return;
    166163}
  • titan/titan/language.h

    r19958 r23286  
    77int screenlanguage(int flag)
    88{
    9         debug(1000, "in");
    109        int rcret = 0, change = 0, reloadskin = 0;
    1110        struct skin* language = getscreen("language");
     
    1413        if(listbox == NULL || language == NULL)
    1514        {
    16                 debug(1000, "out -> NULL detect");
     15                err("NULL detect");
    1716                return 1;
    1817        }
     
    6867                readscreen(getconfig("skinfile", NULL), 0, 0);
    6968        }
    70         debug(1000, "out");
    7169        return 0;
    7270}
  • titan/titan/linkedchannel.h

    r21072 r23286  
    160160struct linkedchannel* addlinkedchannel(struct channel* chnode, int serviceid, uint64_t transponderid, time_t starttime, time_t endtime, struct linkedchannel* last)
    161161{
    162         debug(1000, "in");
    163162        struct linkedchannel *newnode = NULL, *prev = NULL, *node = NULL;
    164163
    165164        if(chnode == NULL)
    166165        {
    167                 debug(1000, "out -> NULL detect");
     166                err("NULL detect");
    168167                return NULL;
    169168        }
     
    205204
    206205        m_unlock(&status.linkedchannelmutex, 14);
    207         debug(1000, "out");
    208206        return newnode;
    209207}
     
    215213        if(chnode == NULL)
    216214        {
    217                 debug(1000, "out-> NULL detect");
     215                err("NULL detect");
    218216                return;
    219217        }
     
    245243void freelinkedchannel(struct channel* chnode)
    246244{
    247         debug(1000, "in");
    248245        struct linkedchannel *node = NULL, *prev = NULL;
    249246
    250247        if(chnode == NULL)
    251248        {
    252                 debug(1000, "out -> NULL detect");
     249                err("NULL detect");
    253250                return;
    254251        }
     
    268265        }
    269266        m_unlock(&status.linkedchannelmutex, 14);
    270         debug(1000, "out");
    271267}
    272268
  • titan/titan/list.h

    r20079 r23286  
    2020struct clist* addlisttmp(struct clist **clist, char *key1, char *value1)
    2121{
    22         debug(1000, "in");
    2322        m_lock(&status.clistmutex, 12);
    2423        struct clist *newnode = NULL, *node = NULL, *prev = NULL;
     
    2827        if(key1 == NULL || value1 == NULL)
    2928        {
    30                 debug(1000, "out -> NULL dedect");
    3129                m_unlock(&status.clistmutex, 12);
    3230                return NULL;
     
    8583                                free(node->tmp);
    8684                                node->tmp = value;
    87                                 debug(1000, "out -> key %s found, use change instread add", key);
    8885                                m_unlock(&status.clistmutex, 12);
    8986                                return newnode;
     
    9794                clist[hash] = newnode;
    9895
    99         debug(1000, "out");
    10096        m_unlock(&status.clistmutex, 12);
    10197        return newnode;
     
    104100struct clist* addlistdef(struct clist **clist, char *key1, char *value1)
    105101{
    106         debug(1000, "in");
    107102        m_lock(&status.clistmutex, 12);
    108103        struct clist *newnode = NULL, *node = NULL, *prev = NULL;
     
    112107        if(key1 == NULL || value1 == NULL)
    113108        {
    114                 debug(1000, "out -> NULL dedect");
    115109                m_unlock(&status.clistmutex, 12);
    116110                return NULL;
     
    169163                                free(node->def);
    170164                                node->def = value;
    171                                 debug(1000, "out -> key %s found, use change instread add", key);
    172165                                m_unlock(&status.clistmutex, 12);
    173166                                return newnode;
     
    181174                clist[hash] = newnode;
    182175
    183         debug(1000, "out");
    184176        m_unlock(&status.clistmutex, 12);
    185177        return newnode;
     
    188180struct clist* addlist(struct clist **clist, char *key1, char *value1)
    189181{
    190         debug(1000, "in");
    191182        m_lock(&status.clistmutex, 12);
    192183        struct clist *newnode = NULL, *node = NULL, *prev = NULL;
     
    196187        if(key1 == NULL || value1 == NULL)
    197188        {
    198                 debug(1000, "out -> NULL dedect");
    199189                m_unlock(&status.clistmutex, 12);
    200190                return NULL;
     
    259249                                free(node->value);
    260250                                node->value = value;
    261                                 debug(1000, "out -> key %s found, use change instread add", key);
    262251                                m_unlock(&status.clistmutex, 12);
    263252                                return node;
     
    271260                clist[hash] = newnode;
    272261
    273         debug(1000, "out");
    274262        m_unlock(&status.clistmutex, 12);
    275263        return newnode;
     
    278266int writelist(struct clist **clist, const char *filename)
    279267{
    280         debug(1000, "in");
    281268        m_lock(&status.clistmutex, 12);
    282269        FILE *fd = NULL;
     
    318305       
    319306        fclose(fd);
    320         debug(1000, "out");
    321307        m_unlock(&status.clistmutex, 12);
    322308        return 0;
     
    325311char* getlistbyval(struct clist **clist, char *value, char *ext)
    326312{
    327         //debug(1000, "in");
    328313        m_lock(&status.clistmutex, 12);
    329314        struct clist *node = NULL;
     
    351336                        {
    352337                                free(tmpstr);
    353                                 //debug(1000, "out");
    354338                                m_unlock(&status.clistmutex, 12);
    355339                                return node->key;
     
    367351char* getlistnotmp(struct clist **clist, char *key, char *ext)
    368352{
    369         //debug(1000, "in");
    370353        m_lock(&status.clistmutex, 12);
    371354        struct clist *node = NULL;
     
    392375                {
    393376                        free(tmpstr);
    394                         //debug(1000, "out");
    395377                        if(node->value != NULL)
    396378                        {
     
    415397char* getlist(struct clist **clist, char *key, char *ext)
    416398{
    417         //debug(1000, "in");
    418399        m_lock(&status.clistmutex, 12);
    419400        struct clist *node = NULL;
     
    440421                {
    441422                        free(tmpstr);
    442                         //debug(1000, "out");
    443423                        if(node->tmp != NULL && strlen(node->tmp) > 0)
    444424                        {
     
    470450void dellist(struct clist **clist, char *key, int flag)
    471451{
    472         debug(1000, "in");
    473452        if(flag == 0) m_lock(&status.clistmutex, 12);
    474453        struct clist *node = NULL, *prev = NULL;
     
    514493                node = node->next;
    515494        }
    516         debug(1000, "out");
    517495        if(flag == 0) m_unlock(&status.clistmutex, 12);
    518496}
     
    520498void dellisttmpall(struct clist **clist)
    521499{
    522         debug(1000, "in");
    523500        m_lock(&status.clistmutex, 12);
    524501        struct clist *node = NULL, *prev = NULL;
     
    546523                }
    547524        }
    548         debug(1000, "out");
    549525        m_unlock(&status.clistmutex, 12);
    550526}
     
    552528void dellisttmp(struct clist **clist, char *key)
    553529{
    554         debug(1000, "in");
    555530        m_lock(&status.clistmutex, 12);
    556531        struct clist *node = NULL, *prev = NULL;
     
    579554                node = node->next;
    580555        }
    581         debug(1000, "out");
    582556        m_unlock(&status.clistmutex, 12);
    583557}
     
    585559void freelist(struct clist** clist)
    586560{
    587         debug(1000, "in");
    588561        m_lock(&status.clistmutex, 12);
    589562        struct clist *node = NULL, *prev = NULL;
     
    601574                }
    602575        }
    603         debug(1000, "out");
    604576        m_unlock(&status.clistmutex, 12);
    605577}
     
    607579int writelisttmp(struct clist **clist)
    608580{
    609         debug(1000, "in");
    610581        m_lock(&status.clistmutex, 12);
    611582        struct clist *node = NULL;
     
    646617        }
    647618
    648         debug(1000, "out");
    649619        m_unlock(&status.clistmutex, 12);
    650620        return ret;
  • titan/titan/mainbouquets.h

    r22352 r23286  
    6161struct mainbouquet* getlastmainbouquet(struct mainbouquet* node)
    6262{
    63         debug(1000, "in");
    6463        struct mainbouquet *prev = NULL;
    6564
     
    7069        }
    7170
    72         debug(1000, "out");
    7371        return prev;
    7472}
     
    122120        if(node == NULL || mainbouquet == NULL)
    123121        {
    124                 debug(1000, "NULL detect");
     122                err("NULL detect");
    125123                return 1;
    126124        }
     
    155153        if(node == NULL || mainbouquet == NULL)
    156154        {
    157                 debug(1000, "NULL detect");
     155                err("NULL detect");
    158156                return 1;
    159157        }
     
    205203        if(node == NULL || mainbouquet == NULL)
    206204        {
    207                 debug(1000, "NULL detect");
     205                err("NULL detect");
    208206                return 1;
    209207        }
     
    230228        if(node == NULL || mainbouquet == NULL)
    231229        {
    232                 debug(1000, "NULL detect");
     230                err("NULL detect");
    233231                return 1;
    234232        }
     
    277275struct mainbouquet* addmainbouquet(char *line, int count, struct mainbouquet* last)
    278276{
    279         debug(1000, "in");
    280277        struct mainbouquet *newnode = NULL, *prev = NULL, *node = mainbouquet;
    281278        char *name = NULL, *filename = NULL;
     
    352349        if(node != NULL) node->prev = newnode;
    353350
    354         debug(1000, "out");
    355351        return newnode;
    356352}
     
    358354int readmainbouquet(char* filename)
    359355{
    360         debug(1000, "in");
    361356        FILE *fd = NULL;
    362357        char *fileline = NULL, *tmpstr = NULL, *tmpstr0 = NULL, *tmpstr1 = NULL;
     
    441436struct mainbouquet* getmainbouquetbybouquetpointer(struct bouquet* bouquetnode)
    442437{
    443         debug(1000, "in");
    444438        struct mainbouquet *node = mainbouquet;
    445439        struct bouquet *bnode = NULL;
     
    451445                {
    452446                        if(bnode == bouquetnode)
    453                         {
    454                                 debug(1000, "out");
    455447                                return node;
    456                         }
     448
    457449                        bnode = bnode->next;
    458450                }
     
    465457struct mainbouquet* getmainbouquetbyfilename(char *filename)
    466458{
    467         debug(1000, "in");
    468459        struct mainbouquet *node = mainbouquet;
    469460
     
    471462        {
    472463                if(ostrcmp(node->filename, filename) == 0)
    473                 {
    474                         debug(1000, "out");
    475464                        return node;
    476                 }
    477465
    478466                node = node->next;
     
    484472struct mainbouquet* getmainbouquet(char *name)
    485473{
    486         debug(1000, "in");
    487474        struct mainbouquet *node = mainbouquet;
    488475
     
    490477        {
    491478                if(ostrcmp(node->name, name) == 0)
    492                 {
    493                         debug(1000, "out");
    494479                        return node;
    495                 }
    496480
    497481                node = node->next;
     
    505489void delmainbouquet(char *name, int flag)
    506490{
    507         debug(1000, "in");
    508491        struct mainbouquet *node = mainbouquet, *prev = mainbouquet;
    509492
     
    543526                node = node->next;
    544527        }
    545         debug(1000, "out");
    546528}
    547529
    548530void freemainbouquet()
    549531{
    550         debug(1000, "in");
    551532        struct mainbouquet *node = mainbouquet, *prev = mainbouquet;
    552533
     
    558539                        delmainbouquet(prev->name, 0);
    559540        }
    560         debug(1000, "out");
    561541}
    562542
     
    574554int writemainbouquet(const char *filename)
    575555{
    576         debug(1000, "in");
    577556        FILE *fd = NULL;
    578557        struct mainbouquet *node = mainbouquet;
     
    597576
    598577        fclose(fd);
    599         debug(1000, "out");
    600578        return 0;
    601579}
  • titan/titan/mediadb.h

    r23063 r23286  
    147147        if(node == NULL || mediadb == NULL)
    148148        {
    149                 debug(1000, "NULL detect");
     149                err("NULL detect");
    150150                return 1;
    151151        }
     
    196196        if(node == NULL || mediadb == NULL)
    197197        {
    198                 debug(1000, "NULL detect");
     198                err("NULL detect");
    199199                return 1;
    200200        }
     
    286286       
    287287        m_unlock(&status.mediadbmutex, 17);
    288         //debug(1000, "out");
    289288        return newnode;
    290289}
     
    368367       
    369368        if(flag == 0) m_unlock(&status.mediadbmutex, 17);
    370         //debug(1000, "out");
    371369        return newnode;
    372370}
     
    454452struct mediadb* addmediadb(char *line, int len, int count, struct mediadb* last, int sort, int flag)
    455453{
    456         //debug(1000, "in");
    457454        struct mediadb *newnode = NULL, *prev = NULL, *node = NULL;
    458455        int ret = 0;
     
    516513
    517514        if(flag == 0) m_unlock(&status.mediadbmutex, 17);
    518         //debug(1000, "out");
    519515        return newnode;
    520516}
     
    613609int readmediadb(const char* filename, int type, int flag)
    614610{
    615         debug(1000, "in");
    616611        FILE *fd = NULL;
    617612        char *fileline = NULL;
     
    709704int delmediadbfilter(struct mediadbfilter* mnode, int flag)
    710705{
    711         debug(1000, "in");
    712706        int ret = 1;
    713707
     
    744738
    745739        if(flag == 0) m_unlock(&status.mediadbmutex, 17);
    746         debug(1000, "out");
    747740        return ret;
    748741}
     
    750743int delmediadbcategory(struct mediadbcategory* mnode, int flag)
    751744{
    752         debug(1000, "in");
    753745        int ret = 1;
    754746
     
    788780
    789781        m_unlock(&status.mediadbmutex, 17);
    790         debug(1000, "out");
    791782        return ret;
    792783}
     
    794785int delmediadb(struct mediadb* mnode, int flag)
    795786{
    796         debug(1000, "in");
    797787        int ret = 1;
    798788
     
    836826
    837827        m_unlock(&status.mediadbmutex, 17);
    838         debug(1000, "out");
    839828        return ret;
    840829}
     
    842831void freemediadbfilter(int flag)
    843832{
    844         debug(1000, "in");
    845833        struct mediadbfilter *node = mediadbfilter, *prev = mediadbfilter;
    846834
     
    852840                        delmediadbfilter(prev, flag);
    853841        }
    854         debug(1000, "out");
    855842}
    856843
    857844void freemediadbcategory(int flag)
    858845{
    859         debug(1000, "in");
    860846        struct mediadbcategory *node = mediadbcategory, *prev = mediadbcategory;
    861847
     
    867853                        delmediadbcategory(prev, flag);
    868854        }
    869         debug(1000, "out");
    870855}
    871856
    872857void freemediadb(int flag)
    873858{
    874         debug(1000, "in");
    875859        struct mediadb *node = mediadb, *prev = mediadb;
    876860
     
    884868
    885869        status.writemediadb = 0;
    886         debug(1000, "out");
    887870}
    888871
    889872int writemediadbcategory(const char *filename)
    890873{
    891         debug(1000, "in");
    892874        FILE *fd = NULL;
    893875        struct mediadbcategory *node = NULL;
     
    917899
    918900        fclose(fd);
    919         debug(1000, "out");
    920901        return 0;
    921902}
     
    923904int writemediadb(const char *filename, struct mediadb* cmediadb)
    924905{
    925         debug(1000, "in");
    926906        FILE *fd = NULL;
    927907        struct mediadb *node = NULL;
     
    979959        fclose(fd);
    980960        status.writemediadb = 0;
    981         debug(1000, "out");
    982961        return 0;
    983962}
  • titan/titan/menu.h

    r22605 r23286  
    8080struct skin* menu(struct skin* menu, int flag)
    8181{
    82         debug(1000, "in");
    8382        int rcret = 0, ret = 0;
    8483        struct skin* listbox = getscreennode(menu, "listbox");
     
    9190        if(listbox == NULL || menu == NULL)
    9291        {
    93                 debug(1000, "out -> NULL detect");
     92                err("NULL detect");
    9493                return NULL;
    9594        }
     
    168167        delownerrc(menu);
    169168        clearscreen(menu);
    170         debug(1000, "out");
    171169        return listbox->select;
    172170}
     
    174172int menucall(struct skin* menunode, struct skin* menuentry, int check)
    175173{
    176         debug(1000, "in");
    177 
    178174        void (*startplugin) (void);
    179175        int ret = 0, pincheck = 0;
     
    182178        if(menuentry == NULL)
    183179        {
    184                 debug(1000, "out -> NULL detect");
     180                err("NULL detect");
    185181                return 1;
    186182        }
     
    188184        if(!(menuentry->type & MENU)) return 1;
    189185       
    190         debug(1000, "menuentry->name=%s", menuentry->name);
     186        debug(100, "menuentry->name=%s", menuentry->name);
    191187               
    192188        tmpstr = ostrcat("protect_", menuentry->name, 0, 0);
     
    847843
    848844        resettvpic();
    849         debug(1000, "out");
    850845        return ret;
    851846}
  • titan/titan/menulist.h

    r23013 r23286  
    44void freemenulist(struct menulist* mlist, int delparam)
    55{
    6         debug(1000, "in");
    76        struct menulist *node = mlist, *prev = mlist;
    87
     
    3534                }
    3635        }
    37         debug(1000, "out");
    3836}
    3937
     
    134132struct menulist* menulistboxext(struct menulist* mlist, char* paramskinname, char* skintitle, char* paramskinpath, char* defaultpic, int showpng, int* rcreturn, int flag)
    135133{
    136         debug(1000, "in");
    137134        int rcret = 0, fromthread = 0;
    138135        struct skin* framebuffer = getscreen("framebuffer");
     
    316313                clearscreen(screen);
    317314
    318         debug(1000, "out");
    319315        return ret;
    320316}
  • titan/titan/mipselport.h

    r23224 r23286  
    376376void blitrect(int posx, int posy, int width, int height, long color, int transparent, int mode)
    377377{
    378         //debug(1000, "in");
    379378        int y, x;
    380379        unsigned long tmpcol;
     
    417416                        drawpixel(posx + width - 1, posy + y, tmpcol);
    418417        }
    419         //debug(1000, "out");
    420418
    421419/*
     
    698696void sighandler(int sig, struct sigcontext ctx)
    699697{
    700         debug(1000, "in");
    701698        switch(sig)
    702699        {
     
    755752                }
    756753        }
    757         debug(1000, "out");
    758 }
    759 
    760 #endif
     754}
     755
     756#endif
  • titan/titan/mostzap.h

    r18454 r23286  
    4747        if(node == NULL || mostzap == NULL)
    4848        {
    49                 debug(1000, "NULL detect");
     49                err("NULL detect");
    5050                return 1;
    5151        }
     
    8080struct mostzap* addmostzap(char* line, int count, struct mostzap* last)
    8181{
    82         //debug(1000, "in");
    8382        struct mostzap *newnode = NULL, *prev = NULL, *node = mostzap;
    8483        int ret = 0;
     
    121120        if(node != NULL) node->prev = newnode;
    122121       
    123         //debug(1000, "out");
    124122        return newnode;
    125123}
     
    152150int readmostzap(const char* filename)
    153151{
    154         debug(1000, "in");
    155152        FILE *fd = NULL;
    156153        char *fileline = NULL;
     
    196193int delmostzap(int serviceid, uint64_t transponderid, int flag)
    197194{
    198         debug(1000, "in");
    199195        int ret = 1;
    200196        struct mostzap *node = mostzap, *prev = mostzap;
     
    228224        }
    229225
    230         debug(1000, "out");
    231226        return ret;
    232227}
     
    234229void freemostzap(int flag)
    235230{
    236         debug(1000, "in");
    237231        struct mostzap *node = mostzap, *prev = mostzap;
    238232
     
    244238                        delmostzap(prev->serviceid, prev->transponderid, flag);
    245239        }
    246         debug(1000, "out");
    247240}
    248241
    249242int writemostzap(const char *filename)
    250243{
    251         debug(1000, "in");
    252244        FILE *fd = NULL;
    253245        struct mostzap *node = mostzap;
     
    276268
    277269        fclose(fd);
    278         debug(1000, "out");
    279270        return 0;
    280271}
  • titan/titan/multiepg.h

    r20349 r23286  
    3636        if(chnode == NULL)
    3737        {
    38                 debug(1000, "out -> NULL detect");
     38                err("NULL detect");
    3939                return 1;
    4040        }
  • titan/titan/network.h

    r22971 r23286  
    44int readwlan(const char* filename, char** type, char** ssid, char** key)
    55{
    6         debug(1000, "in");
    76        FILE *fd = NULL;
    87        char *fileline = NULL, *tmpstr = NULL;
  • titan/titan/newsletter.h

    r21799 r23286  
    9191int readnewsletter()
    9292{
    93         debug(1000, "in");
    9493        FILE *fd = NULL;
    9594        char* fileline = NULL;
  • titan/titan/numinput.h

    r22701 r23286  
    44char* numinput(char* title, char* num, char* mask, int isip)
    55{
    6         debug(1000, "in");
    76        int rcret = -1, fromthread = 0, height = 0;
    87        struct skin* numinput = getscreen("numinput");
     
    7877
    7978        numinput->height = height;
    80         debug(1000, "out");
    8179        return ret;
    8280}
  • titan/titan/oldentry.h

    r22573 r23286  
    2626struct oldentry* addoldentry(void* entry, int type, time_t del, struct oldentry* last)
    2727{
    28         debug(1000, "in");
    2928        struct oldentry *newnode = NULL, *node = NULL;
    3029
     
    6059
    6160        m_unlock(&status.oldentrymutex, 18);
    62         debug(1000, "out");
    6361        return newnode;
    6462}
     
    6866void deloldentry(struct oldentry *entry, int flag)
    6967{
    70         debug(1000, "in");
    71 
    7268        if(flag == 0) m_lock(&status.oldentrymutex, 18);
    7369        struct oldentry *node = oldentry, *prev = oldentry;
     
    10197
    10298        if(flag == 0) m_unlock(&status.oldentrymutex, 18);
    103         debug(1000, "out");
    10499}
    105100
    106101void freeoldentry()
    107102{
    108         debug(1000, "in");
    109 
    110103        m_lock(&status.oldentrymutex, 18);
    111104        struct oldentry *node = oldentry, *prev = oldentry;
     
    120113
    121114        m_unlock(&status.oldentrymutex, 18);
    122         debug(1000, "out");
    123115}
    124116
  • titan/titan/pic.h

    r21257 r23286  
    2929struct pic* addpic(char *name, unsigned char* picbuf, int memfd, unsigned long width, unsigned long height, unsigned long rowbytes, int channels, int timeout, int del, struct pic* last)
    3030{
    31         debug(1000, "in");
    32 
    3331        //chech if pic timed out and can remove
    3432        checkpictimeout();
     
    7876        newnode->next = node;
    7977
    80         debug(1000, "out");
    8178        return newnode;
    8279}
     
    10097void delpic(char* name)
    10198{
    102         debug(1000, "in");
    10399        struct pic *node = pic, *prev = pic;
    104100        char* tmpstr = NULL;
     
    126122        }
    127123        free(tmpstr);
    128         debug(1000, "out");
    129124}
    130125
    131126void delmarkedpic(int del)
    132127{
    133         debug(1000, "in");
    134128        struct pic *node = pic, *prev = pic;
    135129
     
    153147                node = node->next;
    154148        }
    155         debug(1000, "out");
    156149}
    157150
    158151struct pic* getpic(char* name)
    159152{
    160         debug(1000, "in");
    161153        struct pic *node = pic;
    162154        char* tmpstr = NULL;
     
    168160                if(ostrcmp(node->name, tmpstr) == 0)
    169161                {
    170                         debug(1000, "out");
    171162                        free(tmpstr);
    172163                        node->lastaccess = time(NULL);
     
    183174void freepic()
    184175{
    185         debug(1000, "in");
    186176        struct pic *node = pic, *prev = pic;
    187177
     
    193183                        delpic(prev->name);
    194184        }
    195         debug(1000, "out");
    196185}
    197186
  • titan/titan/pip.h

    r21301 r23286  
    99int pipstartreal(struct channel* chnode, char* pin, int flag)
    1010{
    11         debug(1000, "in");
    1211        struct transponder* tpnode = NULL;
    1312        struct dvbdev *fenode = NULL;
     
    288287        m_unlock(&status.servicemutex, 2);
    289288       
    290         debug(1000, "out");
    291289        return 0;
    292290}
  • titan/titan/playlist.h

    r19844 r23286  
    2222struct playlist* getlastplaylist(struct playlist* node)
    2323{
    24         debug(1000, "in");
    2524        struct playlist *prev = NULL;
    2625
     
    3130        }
    3231
    33         debug(1000, "out");
    3432        return prev;
    3533}
     
    4240        if(node == NULL)
    4341        {
    44                 debug(1000, "NULL detect");
     42                err("NULL detect");
    4543                return 1;
    4644        }
     
    4947        if(mainplaylistnode == NULL)
    5048        {
    51                 debug(1000, "NULL detect");
    5249                err("NULL detect");
    5350                return 1;
     
    10097        if(node == NULL)
    10198        {
    102                 debug(1000, "NULL detect");
     99                err("NULL detect");
    103100                return 1;
    104101        }
     
    107104        if(mainplaylistnode == NULL)
    108105        {
    109                 debug(1000, "NULL detect");
     106                err("NULL detect");
    110107                return 1;
    111108        }
     
    175172struct playlist* addplaylist(struct playlist **firstnode, char *line, int count, struct playlist* last)
    176173{
    177         //debug(1000, "in");
    178174        struct playlist *newnode = NULL, *prev = NULL, *node = *firstnode;
    179175        int ret = 0;
     
    240236        if(node != NULL) node->prev = newnode;
    241237
    242         //debug(1000, "out");
    243238        return newnode;
    244239}
     
    246241int readplaylist(char* filename, struct playlist** firstnode)
    247242{
    248         debug(1000, "in");
    249243        FILE *fd = NULL;
    250244        char *fileline = NULL;
     
    293287void delplaylist(char* file, struct playlist** firstnode)
    294288{
    295         debug(1000, "in");
    296289        struct playlist *node = *firstnode, *prev = *firstnode;
    297290
     
    325318                node = node->next;
    326319        }
    327         debug(1000, "out");
    328320}
    329321
    330322void freeplaylist(struct playlist** firstnode)
    331323{
    332         debug(1000, "in");
    333324        struct playlist *node = *firstnode, *prev = *firstnode;
    334325
     
    340331                        delplaylist(prev->file, firstnode);
    341332        }
    342         debug(1000, "out");
    343333}
    344334
    345335int writeplaylist(const char *filename, struct playlist *node)
    346336{
    347         debug(1000, "in");
    348337        FILE *fd = NULL;
    349338        int ret = 0;
     
    367356
    368357        fclose(fd);
    369         debug(1000, "out");
    370358        return 0;
    371359}
  • titan/titan/provider.h

    r23185 r23286  
    44int getlastproviderid()
    55{
    6         debug(1000, "in");
    76        int lastid = 0;
    87        struct provider *node = provider, *prev = NULL;
     
    1615        }
    1716
    18         debug(1000, "out");
    1917        return lastid;
    2018}
     
    2220struct provider* getlastprovider(struct provider* node)
    2321{
    24         debug(1000, "in");
    2522        struct provider *prev = NULL;
    2623
     
    3128        }
    3229
    33         debug(1000, "out");
    3430        return prev;
    3531}
     
    4238        if(node == NULL)
    4339        {
    44                 debug(1000, "NULL detect");
     40                err("NULL detect");
    4541                return 1;
    4642        }
     
    6965        if(node == NULL || provider == NULL)
    7066        {
    71                 debug(1000, "NULL detect");
     67                err("NULL detect");
    7268                return 1;
    7369        }
     
    119115        if(node == NULL)
    120116        {
    121                 debug(1000, "NULL detect");
     117                err("NULL detect");
    122118                return 1;
    123119        }
     
    140136        if(node == NULL || provider == NULL)
    141137        {
    142                 debug(1000, "NULL detect");
     138                err("NULL detect");
    143139                return 1;
    144140        }
     
    187183struct provider* addprovider(char *line, int count, struct provider* last)
    188184{
    189         //debug(1000, "in");
    190185        struct provider *newnode = NULL, *prev = NULL, *node = provider;
    191186        char *name = NULL;
     
    251246        if(node != NULL) node->prev = newnode;
    252247
    253         //debug(1000, "out");
    254248        return newnode;
    255249}
     
    257251int readprovider(const char* filename)
    258252{
    259         debug(1000, "in");
    260253        FILE *fd = NULL;
    261254        char *fileline = NULL, *tmpstr = NULL, *tmpstr0 = NULL, *tmpstr1 = NULL;
     
    322315void delprovider(int providerid)
    323316{
    324         debug(1000, "in");
    325317        struct provider *node = provider, *prev = provider;
    326318
     
    354346                node = node->next;
    355347        }
    356         debug(1000, "out");
    357348}
    358349
     
    374365struct provider* getproviderbyname(char* name)
    375366{
    376         debug(1000, "in");
    377367        struct provider *node = provider;
    378368
     
    380370        {
    381371                if(ostrcmp(node->name, name) == 0)
    382                 {
    383                         debug(1000, "out");
    384372                        return node;
    385                 }
    386373
    387374                node = node->next;
     
    393380struct provider* getprovider(int providerid)
    394381{
    395         //debug(1000, "in");
    396382        struct provider *node = provider;
    397383
     
    399385        {
    400386                if(node->providerid == providerid)
    401                 {
    402                         //debug(1000, "out");
    403387                        return node;
    404                 }
    405388
    406389                node = node->next;
     
    470453void freeprovider()
    471454{
    472         debug(1000, "in");
    473455        struct provider *node = provider, *prev = provider;
    474456
     
    480462                        delprovider(prev->providerid);
    481463        }
    482         debug(1000, "out");
    483464}
    484465
    485466int writeprovider(const char *filename)
    486467{
    487         debug(1000, "in");
    488468        FILE *fd = NULL;
    489469        struct provider *node = provider;
     
    508488
    509489        fclose(fd);
    510         debug(1000, "out");
    511490        return 0;
    512491}
  • titan/titan/queue.h

    r16380 r23286  
    1515struct queue* addqueue(int type, void* data, int len, void* data1, int len1, int flag, struct queue* last)
    1616{
    17         //debug(1000, "in");
    18 
    1917        m_lock(&status.queuemutex, 11);
    2018
     
    8583        if(node != NULL) node->prev = queue;
    8684
    87         //debug(1000, "out");
    8885        m_unlock(&status.queuemutex, 11);
    8986        return newnode;
     
    9491void delqueue(struct queue* queuenode, int flag)
    9592{
    96         debug(1000, "in");
    9793        if(flag == 0) m_lock(&status.queuemutex, 11);
    9894        struct queue *node = queue, *prev = queue;
     
    130126        }
    131127        if(flag == 0) m_unlock(&status.queuemutex, 11);
    132         debug(1000, "out");
    133128}
    134129
    135130struct queue* getqueue(int type)
    136131{
    137         //debug(1000, "in");
    138132        m_lock(&status.queuemutex, 11);
    139133        struct queue *node = queue;
     
    143137                if(node->type == type)
    144138                {
    145                         //debug(1000, "out");
    146139                        m_unlock(&status.queuemutex, 11);
    147140                        return node;
     
    156149void freequeue()
    157150{
    158         debug(1000, "in");
    159151        m_lock(&status.queuemutex, 11);
    160152        struct queue *node = queue, *prev = queue;
     
    168160        }
    169161        m_unlock(&status.queuemutex, 11);
    170         debug(1000, "out");
    171162}
    172163
  • titan/titan/rc.h

    r22985 r23286  
    7979struct rc* getrc(int key, struct skin* owner)
    8080{
    81         debug(1000, "in");
    8281        struct rc *node = rc;
    8382
     
    8584        {
    8685                if(node->key == key && node->owner == owner)
    87                 {
    88                         debug(1000, "out");
    8986                        return node;
    90                 }
    9187
    9288                node = node->next;
     
    9894        {
    9995                if(node->key == key && node->owner == NULL)
    100                 {
    101                         debug(1000, "out");
    10296                        return node;
    103                 }
    10497
    10598                node = node->next;
     
    110103int openrc()
    111104{
    112         debug(1000, "in");
    113105        char *rcdev = NULL;
    114106        int i = 0;
     
    139131        }
    140132
    141         debug(1000, "out");
    142133        return 0;
    143134}
     
    145136void closerc()
    146137{
    147         debug(1000, "in");
    148 
    149138        if(status.fdrc != -1)
    150139                close(status.fdrc);
    151 
    152         debug(1000, "out");
    153140}
    154141
     
    221208int waitrcext(struct skin* owner, unsigned int timeout, int screencalc, int filelistview)
    222209{
    223         debug(1000, "in");
    224210        fd_set rfds;
    225211        struct timeval tv;
     
    359345        }
    360346
    361         debug(1000, "out");
    362347        if(ret != RCTIMEOUT)
    363348                status.lastrcaction = time(NULL);
     
    372357struct rc* addrc(int key, void *func, struct skin* screen, struct skin *screennode)
    373358{
    374         debug(1000, "in");
    375359        struct rc *newnode, *node = rc;
    376360        struct rc **nodeaddr;
     
    401385                                free(newnode);
    402386                                newnode = NULL;
    403                                 debug(1000, "out -> key %d found, use change instread add", key);
    404387                                return node;
    405388                        }
     
    412395                rc = newnode;
    413396
    414         debug(1000, "out");
    415397        return newnode;
    416398}
     
    418400void delrc(int key, struct skin* owner, struct skin* screennode)
    419401{
    420         debug(1000, "in");
    421402        struct rc *node = rc, *prev = rc;
    422403
     
    438419                node = node->next;
    439420        }
    440         debug(1000, "out");
    441421}
    442422
    443423void delownerrc(struct skin* owner)
    444424{
    445         debug(1000, "in");
    446425        struct rc *node = rc, *prev = rc;
    447426
     
    453432                        delrc(prev->key, prev->owner, prev->screennode);
    454433        }
    455         debug(1000, "out");
    456434}
    457435
    458436void freerc()
    459437{
    460         debug(1000, "in");
    461438        struct rc *node = rc, *prev = rc;
    462439
     
    468445                        delrc(prev->key, prev->owner, prev->screennode);
    469446        }
    470         debug(1000, "out");
    471447}
    472448
  • titan/titan/rcconfig.h

    r16367 r23286  
    5353struct clist* addrcconfigint(char *key, int value)
    5454{
    55         debug(1000, "in");
    5655        char* fileline = NULL;
    5756        struct clist* ret = NULL;
     
    6160
    6261        free(fileline);
    63         debug(1000, "out");
    6462        return ret;
    6563}
     
    6765int readrcconfig(const char *filename, struct clist** tmprcconfig)
    6866{
    69         debug(1000, "in");
    7067        FILE *fd = NULL;
    7168        char *fileline = NULL, *pos;
     
    108105        fclose(fd);
    109106        free(fileline);
    110         debug(1000, "out");
    111107        return 0;
    112108}
     
    166162int reloadrcconfig(char *filename)
    167163{
    168         debug(1000, "in");
    169164        int ret = 0;
    170165
     
    173168        if(ret != 0)
    174169        {
    175                 debug(1000, "out -> readrcconfig fail");
     170                err("readrcconfig fail");
    176171                return 1;
    177172        }
    178173
    179         debug(1000, "out");
    180174        return 0;
    181175}
  • titan/titan/rcfunc.h

    r20290 r23286  
    44void progressbarright(struct skin* screen, struct skin* progressbar, int screencalc, int filelistview, int flag)
    55{
    6         debug(1000, "in");
    7 
    86        if(progressbar != NULL)
    97        {
     
    1614                        progressbar->progresssize = 100;
    1715        }
    18 
    19         debug(1000, "out");
    2016}
    2117
    2218void progressbarleft(struct skin* screen, struct skin* progressbar, int screencalc, int filelistview, int flag)
    2319{
    24         debug(1000, "in");
    25 
    2620        if(progressbar != NULL)
    2721        {
     
    3428                        progressbar->progresssize = 0;
    3529        }
    36 
    37         debug(1000, "out");
    3830}
    3931
    4032void filelistok(struct skin* screen, struct skin* filelist, int screencalc, int filelistview, int flag)
    4133{
    42         debug(1000, "in");
    4334        struct skin* path = NULL;
    4435        char* tmp = NULL, *lastdir = NULL, *plastdir = NULL;
     
    8576                }
    8677        }
    87         debug(1000, "out");
    8878}
    8979
     
    112102void inputboxchar(struct skin* screen, struct skin* inputbox, char zeichen, int screencalc, int filelistview, int flag)
    113103{
    114         debug(1000, "in");
    115104        if(inputbox != NULL && inputbox->input != NULL)
    116105        {
     
    122111                }
    123112        }
    124         debug(1000, "out");
    125113}
    126114
    127115void inputboxff(struct skin* screen, struct skin* inputbox, int screencalc, int filelistview, int flag)
    128116{
    129         debug(1000, "in");
    130117        if(inputbox != NULL)
    131118        {
     
    135122                drawscreen(screen, screencalc, flag);
    136123        }
    137         debug(1000, "out");
    138124}
    139125
    140126void inputboxfr(struct skin* screen, struct skin* inputbox, int screencalc, int filelistview, int flag)
    141127{
    142         debug(1000, "in");
    143128        if(inputbox != NULL && inputbox->input != NULL)
    144129        {
     
    146131                drawscreen(screen, screencalc, flag);
    147132        }
    148         debug(1000, "out");
    149133}
    150134
    151135void checkinputboxnumright(struct skin* inputbox)
    152136{
    153         debug(1000, "in");
    154137        int count = 0;
    155138
     
    171154                }
    172155        }
    173         debug(1000, "out");
    174156}
    175157
    176158void checkinputboxnumleft(struct skin* inputbox)
    177159{
    178         debug(1000, "in");
    179160        int count = 0;
    180161
     
    196177                }
    197178        }
    198         debug(1000, "out");
    199179}
    200180
    201181void inputboxright(struct skin* screen, struct skin* inputbox, int screencalc, int filelistview, int flag)
    202182{
    203         debug(1000, "in");
    204 
    205183        if(inputbox != NULL && inputbox->input != NULL)
    206184        {
     
    211189                drawscreen(screen, screencalc, flag);
    212190        }
    213         debug(1000, "out");
    214191}
    215192
    216193void inputboxleft(struct skin* screen, struct skin* inputbox, int screencalc, int filelistview, int flag)
    217194{
    218         debug(1000, "in");
    219 
    220195        if(inputbox != NULL && inputbox->input != NULL)
    221196        {
     
    226201                drawscreen(screen, screencalc, flag);
    227202        }
    228         debug(1000, "out");
    229203}
    230204
     
    556530void choiceboxleft(struct skin* screen, struct skin* choicebox, int screencalc, int filelistview, int flag)
    557531{
    558         debug(1000, "in");
    559532        if(choicebox != NULL)
    560533        {
     
    565538                drawscreen(screen, screencalc, flag);
    566539        }
    567         debug(1000, "out");
    568540}
    569541
    570542void choiceboxright(struct skin* screen, struct skin* choicebox, int screencalc, int filelistview, int flag)
    571543{
    572         debug(1000, "in");
    573544        if(choicebox != NULL)
    574545        {
     
    582553                drawscreen(screen, screencalc, flag);
    583554        }
    584         debug(1000, "out");
    585555}
    586556
    587557void griddown(struct skin* screen, struct skin* grid, int screencalc, int filelistview, int flag)
    588558{
    589         debug(1000, "in");
    590559        int end = 0, br = 0, mark = 0;
    591560        struct skin* node = NULL;
     
    643612                drawscreen(screen, screencalc, flag);
    644613        }
    645 
    646         debug(1000, "out");
    647614}
    648615
    649616void gridup(struct skin* screen, struct skin* grid, int screencalc, int filelistview, int flag)
    650617{
    651         debug(1000, "in");
    652618        int start = 0, br = 0, mark = 0;
    653619        struct skin* node = NULL, *tmpnode = NULL;;
     
    714680                drawscreen(screen, screencalc, flag);
    715681        }
    716 
    717         debug(1000, "out");
    718682}
    719683
    720684void gridleft(struct skin* screen, struct skin* grid, int screencalc, int filelistview, int flag)
    721685{
    722         debug(1000, "in");
    723686        struct skin* node = NULL;
    724687
     
    753716                        grid->gridcol = grid->select->posx + (grid->select->width / 2);
    754717        }
    755         debug(1000, "out");
    756718}
    757719
    758720void gridright(struct skin* screen, struct skin* grid, int screencalc, int filelistview, int flag)
    759721{
    760         debug(1000, "in");
    761722        struct skin* node = NULL;
    762723
     
    793754                        grid->gridcol = grid->select->posx + (grid->select->width / 2);
    794755        }
    795         debug(1000, "out");
    796756}
    797757
    798758void gridchup(struct skin* screen, struct skin* grid, int screencalc, int filelistview, int flag)
    799759{
    800         debug(1000, "in");
    801 
    802760        if(grid != NULL)
    803761        {
     
    811769                        grid->gridcol = grid->select->posx + (grid->select->width / 2);
    812770        }
    813 
    814         debug(1000, "out");
    815771}
    816772
    817773void gridchdown(struct skin* screen, struct skin* grid, int screencalc, int filelistview, int flag)
    818774{
    819         debug(1000, "in");
    820 
    821775        if(grid != NULL)
    822776        {
     
    833787                        grid->gridcol = grid->select->posx + (grid->select->width / 2);
    834788        }
    835 
    836         debug(1000, "out");
    837789}
    838790
     
    840792void listboxleft(struct skin* screen, struct skin* listbox, int screencalc, int filelistview, int flag)
    841793{
    842         debug(1000, "in");
    843 
    844794        if(listbox != NULL)
    845795        {
     
    852802                drawscreen(screen, screencalc, flag);
    853803        }
    854 
    855         debug(1000, "out");
    856804}
    857805
    858806void listboxright(struct skin* screen, struct skin* listbox, int screencalc, int filelistview, int flag)
    859807{
    860         debug(1000, "in");
    861 
    862808        if(listbox != NULL)
    863809        {
     
    873819                drawscreen(screen, screencalc, flag);
    874820        }
    875 
    876         debug(1000, "out");
    877821}
    878822
    879823void listboxup(struct skin* screen, struct skin* listbox, int screencalc, int filelistview, int flag)
    880824{
    881         debug(1000, "in");
    882 
    883825        if(listbox != NULL)
    884826        {
     
    891833                drawscreen(screen, screencalc, flag);
    892834        }
    893         debug(1000, "out");
    894835}
    895836
    896837void listboxdown(struct skin* screen, struct skin* listbox, int screencalc, int filelistview, int flag)
    897838{
    898         debug(1000, "in");
    899 
    900839        if(listbox != NULL)
    901840        {
     
    909848                drawscreen(screen, screencalc, flag);
    910849        }
    911         debug(1000, "out");
    912850}
    913851
    914852void textboxup(struct skin* screen, struct skin* textbox, int screencalc, int filelistview, int flag)
    915853{
    916         debug(1000, "in");
    917854        if(textbox != NULL)
    918855        {
     
    923860                }
    924861        }
    925         debug(1000, "out");
    926862}
    927863
    928864void textboxdown(struct skin* screen, struct skin* textbox, int screencalc, int filelistview, int flag)
    929865{
    930         debug(1000, "in");
    931866        if(textbox != NULL)
    932867        {
     
    937872                }
    938873        }
    939         debug(1000, "out");
    940874}
    941875
    942876int addscreenrc(struct skin* screen, struct skin* node)
    943877{
    944         debug(1000, "in");
    945 
    946878        if(node == NULL)
    947879        {
    948                 debug(1000, "out -> NULL detect");
     880                err("NULL detect");
    949881                return 1;
    950882        }
     
    1023955        }
    1024956
    1025         debug(1000, "out");
    1026957        return 0;
    1027958}
     
    1029960int delscreenrc(struct skin* screen, struct skin* node)
    1030961{
    1031         debug(1000, "in");
    1032 
    1033962        if(node == NULL)
    1034963        {
    1035                 debug(1000, "out -> NULL detect");
     964                err("NULL detect");
    1036965                return 1;
    1037966        }
     
    11101039        }
    11111040
    1112         debug(1000, "out");
    11131041        return 0;
    11141042}
  • titan/titan/rcmap.h

    r19467 r23286  
    44struct rcmap* addrcmap(char *line, int count, struct rcmap* last)
    55{
    6         debug(1000, "in");
    76        struct rcmap *newnode = NULL, *prev = NULL, *node = rcmap;
    87        char *name = NULL, *key = NULL, *newkey = NULL;
     
    8786        newnode->next = node;
    8887
    89         debug(1000, "out");
    9088        return newnode;
    9189}
     
    9391int readrcmap(const char* filename)
    9492{
    95         debug(1000, "in");
    9693        FILE *fd = NULL;
    9794        char *fileline = NULL;
     
    139136void delrcmap(char* name)
    140137{
    141         debug(1000, "in");
    142138        struct rcmap *node = rcmap, *prev = rcmap;
    143139
     
    162158                node = node->next;
    163159        }
    164         debug(1000, "out");
    165160}
    166161
    167162struct rcmap* getrcmap(char* name, int key)
    168163{
    169         debug(1000, "in");
    170164        struct rcmap *node = rcmap;
    171165
     
    173167        {
    174168                if(ostrcmp(node->name, name) == 0 && node->key == key)
    175                 {
    176                         debug(1000, "out");
    177169                        return node;
    178                 }
    179170
    180171                node = node->next;
     
    186177void freercmap()
    187178{
    188         debug(1000, "in");
    189179        struct rcmap *node = rcmap, *prev = rcmap;
    190180
     
    196186                        delrcmap(prev->name);
    197187        }
    198         debug(1000, "out");
    199188}
    200189
  • titan/titan/record.h

    r23163 r23286  
    209209void recordstop(struct service* node, int ret)
    210210{
    211         debug(1000, "in");
    212211        struct stimerthread *recthumbthread = NULL;
    213212        struct rectimer* rectimernode = NULL;
     
    294293                }
    295294        }
    296 
    297         debug(1000, "out");
    298295}
    299296
     
    755752        tmpstr = ostrcat(tmpstr, ".ts", 1, 0);
    756753
    757         debug(1000, "out");
    758754        return tmpstr;
    759755}
     
    11021098struct service* getrecordbyname(char* recname, int type)
    11031099{
    1104         debug(1000, "in");
    11051100        struct service* servicenode = service;
    11061101
    11071102        if(recname == NULL)
    11081103        {
    1109                 debug(1000, "out -> NULL detect");
     1104                err("NULL detect");
    11101105                return NULL;
    11111106        }
     
    11251120
    11261121        return NULL;
    1127         debug(1000, "out");
    11281122}
    11291123
  • titan/titan/rectimer.h

    r20827 r23286  
    262262struct rectimer* addrectimernode(char* line, struct rectimer* last)
    263263{
    264         debug(1000, "in");
    265264        char *ret = NULL;
    266265        struct rectimer *newnode = NULL, *prev = NULL, *node = rectimer;
     
    393392        if(node != NULL) node->prev = newnode;
    394393
    395         debug(1000, "out");
    396394        return newnode;
    397395}
     
    587585int addrectimer(char *buf)
    588586{
    589         debug(1000, "in");
    590587        struct rectimer* node = NULL;
    591588        char* buf1 = buf;
     
    618615        }
    619616        free(line);
    620         debug(1000, "out");
    621617        return 0;
    622618}
     
    624620int readrectimer(char *filename)
    625621{
    626         debug(1000, "in");
    627622        char *buf = NULL;
    628623
     
    636631                free(buf);
    637632        }
    638         debug(1000, "out");
    639633        return 0;
    640634}
     
    644638void delrectimer(struct rectimer* rectimernode, int write, int flag)
    645639{
    646         debug(1000, "in");
    647 
    648640        if(flag == 0) m_lock(&status.rectimermutex, 1);
    649641        struct rectimer *node = rectimer, *prev = rectimer;
     
    713705        if(flag == 0)
    714706                m_unlock(&status.rectimermutex, 1);
    715         debug(1000, "out");
    716707}
    717708
    718709void deloldrectimer()
    719710{
    720         debug(1000, "in");
    721711        struct rectimer *node = rectimer, *prev = rectimer;
    722712
     
    728718                        delrectimer(prev, 1, 0);
    729719        }
    730         debug(1000, "out");
    731720}
    732721
    733722void freerectimer()
    734723{
    735         debug(1000, "in");
    736724        struct rectimer *node = rectimer, *prev = rectimer;
    737725
     
    743731                        delrectimer(prev, 0, 0);
    744732        }
    745         debug(1000, "out");
    746733}
    747734
     
    750737int writerectimer(const char *filename, int flag)
    751738{
    752         debug(1000, "in");
    753739        FILE *fd = NULL;
    754740        struct rectimer *node = NULL;
     
    823809
    824810        status.writerectimer = 0;
    825         debug(1000, "out");
    826811        return 0;
    827812}
  • titan/titan/sat.h

    r19467 r23286  
    1515struct sat* getsatbyorbitalpos(int orbitalpos)
    1616{
    17         debug(1000, "in");
    1817        struct sat *node = sat;
    1918
     
    2120        {
    2221                if(node->orbitalpos == orbitalpos)
    23                 {
    24                         debug(1000, "out");
    2522                        return node;
    26                 }
    2723
    2824                node = node->next;
     
    118114struct sat* getlastsat(struct sat* node)
    119115{
    120         debug(1000, "in");
    121116        struct sat *prev = NULL;
    122117
     
    127122        }
    128123
    129         debug(1000, "out");
    130124        return prev;
    131125}
     
    138132        if(node == NULL)
    139133        {
    140                 debug(1000, "NULL detect");
     134                err("NULL detect");
    141135                return 1;
    142136        }
     
    165159        if(node == NULL || sat == NULL)
    166160        {
    167                 debug(1000, "NULL detect");
     161                err("NULL detect");
    168162                return 1;
    169163        }
     
    215209        if(node == NULL)
    216210        {
    217                 debug(1000, "NULL detect");
     211                err("NULL detect");
    218212                return 1;
    219213        }
     
    236230        if(node == NULL)
    237231        {
    238                 debug(1000, "NULL detect");
     232                err("NULL detect");
    239233                return 1;
    240234        }
     
    283277struct sat* addsat(char *line, int count, struct sat* last)
    284278{
    285         debug(1000, "in");
    286279        struct sat *newnode = NULL, *prev = NULL, *node = sat;
    287280        char *name = NULL;
     
    347340        if(node != NULL) node->prev = newnode;
    348341
    349         debug(1000, "out");
    350342        return newnode;
    351343}
     
    353345int readsat(const char* filename)
    354346{
    355         debug(1000, "in");
    356347        FILE *fd = NULL;
    357348        char *fileline = NULL, *tmpstr = NULL, *tmpstr0 = NULL, *tmpstr1 = NULL;
     
    418409void delsat(char *name)
    419410{
    420         debug(1000, "in");
    421411        struct sat *node = sat, *prev = sat;
    422412
     
    452442                node = node->next;
    453443        }
    454         debug(1000, "out");
    455444}
    456445
    457446struct sat* getsat(char *name)
    458447{
    459         debug(1000, "in");
    460448        struct sat *node = sat;
    461449
     
    463451        {
    464452                if(ostrstr(node->name, name) != NULL)
    465                 {
    466                         debug(1000, "out");
    467453                        return node;
    468                 }
    469454
    470455                node = node->next;
     
    476461void freesat()
    477462{
    478         debug(1000, "in");
    479463        struct sat *node = sat, *prev = sat;
    480464
     
    486470                        delsat(prev->name);
    487471        }
    488         debug(1000, "out");
    489472}
    490473
    491474int writesat(const char *filename)
    492475{
    493         debug(1000, "in");
    494476        FILE *fd = NULL;
    495477        struct sat *node = sat;
     
    515497
    516498        fclose(fd);
    517         debug(1000, "out");
    518499        return 0;
    519500}
  • titan/titan/scart.h

    r12501 r23286  
    44void screenscart()
    55{
    6         debug(1000, "in");
    76        int rcret = 0;
    87        char* tmpstr = NULL;
     
    2625                textbox(_("Message"), _("Videomode must be 576i for Scart"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 5, 0);
    2726        free(tmpstr); tmpstr = NULL;
    28         debug(1000, "out");
    2927        return;
    3028}
  • titan/titan/scdev.h

    r22550 r23286  
    6464struct dvbdev* scopen()
    6565{
    66         debug(1000, "in");
    6766        int fd = -1;
    6867        struct dvbdev* node = dvbdev;
     
    8988        }
    9089
    91         debug(1000, "out");
    9290        return node;
    9391}
     
    9593int scopendirect(char *scdev)
    9694{
    97         debug(1000, "in");
    9895        int fd = -1;
    9996
     
    104101
    105102        closeonexec(fd);
    106         debug(1000, "out");
    107103        return fd;
    108104}
     
    123119        if(node == NULL)
    124120        {
    125                 debug(1000, "out-> NULL detect");
     121                err("NULL detect");
    126122                return 1;
    127123        }
     
    141137        if(node == NULL || modes == NULL)
    142138        {
    143                 debug(1000, "out-> NULL detect");
     139                err("NULL detect");
    144140                return 1;
    145141        }
     
    159155        if(node == NULL || modes == NULL)
    160156        {
    161                 debug(1000, "out-> NULL detect");
     157                err("NULL detect");
    162158                return 1;
    163159        }
     
    177173        if(node == NULL || parameters == NULL)
    178174        {
    179                 debug(1000, "out-> NULL detect");
     175                err("NULL detect");
    180176                return 1;
    181177        }
     
    195191        if(node == NULL || parameters == NULL)
    196192        {
    197                 debug(1000, "out-> NULL detect");
     193                err("NULL detect");
    198194                return 1;
    199195        }
     
    213209        if(node == NULL)
    214210        {
    215                 debug(1000, "out-> NULL detect");
     211                err("NULL detect");
    216212                return 1;
    217213        }
     
    231227        if(node == NULL)
    232228        {
    233                 debug(1000, "out-> NULL detect");
     229                err("NULL detect");
    234230                return 1;
    235231        }
     
    249245        if(node == NULL)
    250246        {
    251                 debug(1000, "out-> NULL detect");
     247                err("NULL detect");
    252248                return 1;
    253249        }
     
    267263        if(node == NULL)
    268264        {
    269                 debug(1000, "out-> NULL detect");
     265                err("NULL detect");
    270266                return 1;
    271267        }
     
    285281        if(node == NULL)
    286282        {
    287                 debug(1000, "out-> NULL detect");
     283                err("NULL detect");
    288284                return 1;
    289285        }
     
    303299        if(node == NULL)
    304300        {
    305                 debug(1000, "out-> NULL detect");
     301                err("NULL detect");
    306302                return 1;
    307303        }
     
    321317        if(node == NULL)
    322318        {
    323                 debug(1000, "out-> NULL detect");
     319                err("NULL detect");
    324320                return 1;
    325321        }
     
    339335        if(node == NULL)
    340336        {
    341                 debug(1000, "out-> NULL detect");
     337                err("NULL detect");
    342338                return 1;
    343339        }
     
    357353        if(node == NULL)
    358354        {
    359                 debug(1000, "out-> NULL detect");
     355                err("NULL detect");
    360356                return 1;
    361357        }
     
    373369int scgetdev()
    374370{
    375         debug(1000, "in");
    376371        int y, fd = -1, count = 0;
    377372        char *buf = NULL, *scdev = NULL;
     
    380375        if(scdev == NULL)
    381376        {
    382                 debug(1000, "out -> NULL detect");
     377                err("NULL detect");
    383378                return count;
    384379        }
     
    404399
    405400        free(buf);
    406         debug(1000, "out");
    407401        return count;
    408402}
  • titan/titan/service.h

    r22502 r23286  
    6464int servicestartreal(struct channel* chnode, char* channellist, char* pin, int flag)
    6565{
    66         debug(1000, "in");
    6766        struct transponder* tpnode = NULL;
    6867        struct dvbdev *fenode = NULL;
     
    581580        }
    582581       
    583         debug(1000, "out");
    584582        return 0;
    585583}
     
    773771        if(chnode == NULL || tracknode == NULL)
    774772        {
    775                 debug(1000, "out -> NULL detect");
     773                err("NULL detect");
    776774                return;
    777775        }
     
    799797struct service* addservice(struct service* last)
    800798{
    801         debug(1000, "in");
    802799        struct service *newnode = NULL, *node = NULL;
    803800
     
    829826                service = newnode;
    830827
    831         debug(1000, "out");
    832828        m_unlock(&status.servicemutex, 2);
    833829        return newnode;
     
    851847void delservice(struct service* snode, int flag)
    852848{
    853         debug(1000, "in");
    854849        m_lock(&status.servicemutex, 2);
    855850        struct service *node = service, *prev = service;
     
    918913        }
    919914        m_unlock(&status.servicemutex, 2);
    920         debug(1000, "out");
    921915}
    922916
    923917void freeservice()
    924918{
    925         debug(1000, "in");
    926919        struct service *node = service, *prev = service;
    927920
     
    933926                        delservice(prev, 0);
    934927        }
    935         debug(1000, "out");
    936928}
    937929
  • titan/titan/settings_bluebutton.h

    r20934 r23286  
    44void screensettings_bluebutton()
    55{
    6         debug(1000, "in");
    76        char* skintitle = "Blue Key Action - Setup";
    87        struct skin* plugin = getscreen("plugin");
     
    4948        freemenulist(mlist, 1); mlist = NULL;
    5049        free(tmpstr); tmpstr = NULL;
    51         debug(1000, "out");
    5250        return;
    5351}
  • titan/titan/settings_redbutton.h

    r20934 r23286  
    44void screensettings_redbutton()
    55{
    6         debug(1000, "in");
    76        char* skintitle = "Red Key Action - Setup";
    87        struct skin* plugin = getscreen("plugin");
     
    5049        freemenulist(mlist, 1); mlist = NULL;
    5150        free(tmpstr); tmpstr = NULL;
    52         debug(1000, "out");
    5351        return;
    5452}
  • titan/titan/sh4port.h

    r23224 r23286  
    2424        if(node == NULL)
    2525        {
    26                 debug(1000, "out-> NULL detect");
     26                err("NULL detect");
    2727                return 1;
    2828        }
     
    660660void sighandler(int sig, struct sigcontext ctx)
    661661{
    662         debug(1000, "in");
    663662        switch(sig)
    664663        {
     
    710709                }
    711710        }
    712         debug(1000, "out");
    713711}
    714712
  • titan/titan/showiframe.h

    r22609 r23286  
    66int singlepicstart(const char *filename, int flag)
    77{
    8         debug(1000, "in -> %s", filename);
    98        int ret = 0;
    109
     
    7473                return 1;
    7574        }
    76         debug(1000, "out");
    7775        return 0;
    7876}
  • titan/titan/skin.h

    r23176 r23286  
    2727void* convertfunc(char *value, uint8_t *rettype)
    2828{
    29         debug(1000, "in");
    3029        *rettype = FUNCTEXT;
    3130
     
    221220                return &getpowerofftime;
    222221
    223         debug(1000, "out");
    224222        return 0;
    225223}
     
    227225long convertcol(char *value)
    228226{
    229 //      debug(1000, "in");
    230227        char *ret;
    231228        long col = 0;
     
    247244        }
    248245
    249 //      debug(1000, "out");
    250246        return col;
    251247}
     
    253249int convertxmlentry(char *value, uint8_t *proz)
    254250{
    255 //      debug(1000, "in");
    256251        int ret = -1;
    257252        char *buf = NULL;
     
    338333        }
    339334
    340 //      debug(1000, "out");
    341335        return ret;
    342336}
     
    344338struct skin* checkscreen(char* screenname)
    345339{
    346         //debug(1000, "in");
    347340        struct skin* node = skin;
    348341
     
    350343        {
    351344                if(ostrcmp(node->name, screenname) == 0)
    352                 {
    353                         //debug(1000, "out");
    354345                        return node;
    355                 }
     346
    356347                node = node->next;
    357348        }
     
    361352struct skin* getscreen(char* screenname)
    362353{
    363         debug(1000, "in");
    364354        struct skin* node = skin;
    365355
     
    367357        {
    368358                if(ostrcmp(node->name, screenname) == 0)
    369                 {
    370                         debug(1000, "out");
    371359                        return node;
    372                 }
     360
    373361                node = node->next;
    374362        }
     
    379367struct skin* sortscreen(struct skin* node)
    380368{
    381         debug(1000, "in");
    382369        struct skin *nodea = NULL, *nodeb = NULL, *nodec = NULL, *noded = NULL;
    383370        struct skin *nodetmp = NULL;
     
    386373        if(node == NULL || node == status.skinerr)
    387374        {
    388                 debug(1000, "out -> NULL detect");
     375                err("NULL detect");
    389376                return NULL;
    390377        }
     
    451438        }
    452439
    453         debug(1000, "out");
    454440        return node;
    455441}
     
    457443struct skin* sortscreenbyname(char *screenname)
    458444{
    459         debug(1000, "in");
    460445        struct skin* node = NULL;
    461446
     
    465450                node = getscreen(screenname);
    466451
    467         debug(1000, "out");
    468452        return sortscreen(node);
    469453}
     
    471455struct skin* getlastscreennode(struct skin* node)
    472456{
    473         debug(1000, "in");
    474457        struct skin *prev = NULL;
    475458
     
    482465        }
    483466
    484         debug(1000, "out");
    485467        return prev;
    486468}
     
    510492struct skin* addscreennode(struct skin* node, char* line, struct skin* last)
    511493{
    512 //      debug(1000, "in");
    513494        char *ret = NULL;
    514495        struct skin *newnode = NULL, *prev = NULL, *tmpnode = node;
     
    938919                createfilelist(tmpnode, newnode, 0);
    939920
    940         //debug(1000, "out");
    941921        return newnode;
    942922}
     
    944924struct skin* addscreennodebyname(char* screenname, char* line)
    945925{
    946         debug(1000, "in");
    947926        struct skin *node = NULL;
    948927
     
    952931                node = getscreen(screenname);
    953932
    954         debug(1000, "out");
    955933        return addscreennode(node, line, NULL);
    956934}
     
    960938int addscreen(char *buf, int del, int flag)
    961939{
    962         debug(1000, "in");
    963940        struct skin* node = NULL, *tmpnode = NULL;
    964941        char* buf1 = buf, *tmpstr = NULL;
     
    1000977                }
    1001978        }
    1002         debug(1000, "out");
    1003979        return 0;
    1004980}
     
    1008984int readscreen(char *filename, int del, int flag)
    1009985{
    1010         debug(1000, "in");
    1011986        char *buf = NULL;
    1012987
     
    10291004                free(buf);
    10301005        }
    1031         debug(1000, "out");
    10321006        return 0;
    10331007}
     
    10351009struct skin* checkscreennode(struct skin *node, char* nodename)
    10361010{
    1037         debug(1000, "in");
    1038 
    10391011        if(node != NULL) node = node->child;
    10401012
     
    10421014        {
    10431015                if(ostrcmp(node->name, nodename) == 0)
    1044                 {
    1045                         debug(1000, "out");
    10461016                        return node;
    1047                 }
     1017
    10481018                node = node->next;
    10491019        }
     
    10541024struct skin* getscreennode(struct skin *node, char* nodename)
    10551025{
    1056         debug(1000, "in");
    1057 
    10581026        if(node != NULL) node = node->child;
    10591027
     
    10611029        {
    10621030                if(ostrcmp(node->name, nodename) == 0)
    1063                 {
    1064                         debug(1000, "out");
    10651031                        return node;
    1066                 }
     1032
    10671033                node = node->next;
    10681034        }
     
    10741040struct skin* getscreennodebyname(char* screenname, char* nodename)
    10751041{
    1076         debug(1000, "in");
    10771042        struct skin *node = NULL;
    10781043
    10791044        node = getscreen(screenname);
    1080 
    1081         debug(1000, "out");
    10821045        return getscreennode(node, nodename);
    10831046}
     
    10851048void freenodecontent(struct skin* node)
    10861049{
    1087         debug(1000, "in");
    1088 
    10891050        if(node->pluginhandle != NULL)
    10901051                dlclose(node->pluginhandle);
     
    11411102        node->handle1 = NULL;
    11421103        node->pluginhandle = NULL;
    1143 
    1144         debug(1000, "out");
    11451104}
    11461105
    11471106void delmarkedscreennodes(struct skin* node, int mark)
    11481107{
    1149         debug(1000, "in");
    11501108        struct skin *prev = NULL, *screen = node;
    11511109        struct skin* sel = NULL, *tmp = NULL;
     
    12151173                node = node->next;
    12161174        }
    1217 
    1218 
    1219         debug(1000, "out");
    12201175}
    12211176
    12221177void delscreennode(struct skin *node, char* nodename)
    12231178{
    1224         debug(1000, "in");
    12251179        struct skin *prev = NULL;
    12261180        struct skin **nodeaddr;
    12271181
    12281182        if(node == NULL || node == status.skinerr)
    1229         {
    1230                 debug(1000, "out -> NULL detect");
    12311183                return;
    1232         }
    12331184
    12341185        if(node == skin && node->child == NULL)
     
    12651216                node = NULL;
    12661217        }
    1267 
    1268         debug(1000, "out");
    12691218}
    12701219
     
    12791228
    12801229        delscreennode(node, nodename);
    1281         debug(1000, "out");
    12821230}
    12831231
    12841232void delscreen(struct skin *node)
    12851233{
    1286         debug(1000, "in");
    12871234        struct skin *prev = NULL, *child = NULL;
    12881235
     
    13001247        if(node != NULL)
    13011248                delscreennode(skin, node->name);
    1302 
    1303         debug(1000, "out");
    13041249}
    13051250
    13061251void delscreenbyname(char *screenname)
    13071252{
    1308         debug(1000, "in");
    13091253        struct skin *node = NULL;
    13101254        node = getscreen(screenname);
    13111255        delscreen(node);
    1312         debug(1000, "out");
    13131256}
    13141257
    13151258void delmarkedscreen(int del)
    13161259{
    1317         debug(1000, "in");
    13181260        struct skin *node = skin, *prev = skin;
    13191261
     
    13251267                        delscreen(prev);
    13261268        }
    1327         debug(1000, "out");
    13281269}
    13291270
    13301271void freescreen()
    13311272{
    1332         debug(1000, "in");
    13331273        struct skin *node = skin, *prev = skin;
    13341274
     
    13401280                        delscreen(prev);
    13411281        }
    1342         debug(1000, "out");
    13431282}
    13441283
     
    13781317unsigned char* scale(unsigned char* buf, int width, int height, int channels, int newwidth, int newheight, int free1)
    13791318{
    1380         debug(1000, "out");
    13811319        int h, w, pixel, nmatch;
    13821320
     
    14151353
    14161354        if(free1 == 1) free(buf);
    1417         debug(1000, "out");
    14181355        return newbuf;
    14191356}
     
    18421779unsigned char* readpng(const char* filename, unsigned long* width, unsigned long* height, unsigned long* rowbytes, int* channels, int posx, int posy, int mwidth, int mheight, int halign, int valign)
    18431780{
    1844         debug(1000, "in");
    18451781        FILE *fd = NULL;
    18461782        int ret, bit_depth, color_type;
     
    19731909        debug(100, "png width=%ld height=%ld channels=%d rowbytes=%ld", *width, *height, *channels, *rowbytes);
    19741910
    1975         debug(1000, "out");
    19761911        return buf;
    19771912}
     
    19791914void drawpic(const char* filename, int posx, int posy, int scalewidth, int scaleheight, int mwidth, int mheight, int halign, int valign, int transparent, int quality, int add)
    19801915{
    1981         debug(1000, "in");
    19821916        unsigned char *buf = NULL, *scalebuf = NULL;
    19831917        int memfd = -1, py = 0, pyh = 0, pxw = 0, diff = 0;
     
    21432077                        freebpamem(memfd, buf, width * height * 3);
    21442078        }
    2145        
    2146         debug(1000, "out");
    21472079}
    21482080
     
    22872219int drawchar(struct font* font, FT_ULong currentchar, int posx, int posy, int mwidth, int height, long color, int transparent, int charspace, int test)
    22882220{
    2289 //      debug(1000, "in");
    22902221        int space = 0, y = 0, x = 0, py = 0, pxw = 0, pyh = 0, max = 220, min = 35;
    22912222        FT_UInt glyphindex;
     
    23252256                kerning.x = 0;
    23262257
    2327         if (test == 1 || space == 1)
    2328         {
    2329                 //debug(1000, "out -> test or space");
     2258        if(test == 1 || space == 1)
    23302259                return sbit->xadvance + kerning.x + charspace;
    2331         }
     2260
    23322261        if(posx + sbit->xadvance > mwidth)
    2333         {
    2334                 //debug(1000, "out -> text to long");
    23352262                return -1;
    2336         }
    23372263
    23382264        if(status.fasttextrender == 1)
     
    23782304        }
    23792305
    2380 //      debug(1000, "out");
    23812306        return sbit->xadvance + kerning.x + charspace;
    23822307}
     
    23842309void getstringwh(struct font* font, char *string, int *stringwidth, int *stringheight, int charspace)
    23852310{
    2386         debug(1000, "in");
    23872311        FT_ULong cret = 0;
    23882312        if(string == NULL) return;
     
    23942318                string++;
    23952319        }
    2396         debug(1000, "out");
    23972320}
    23982321
     
    25022425int drawstring(char* string, unsigned long linecount, unsigned int poscount, unsigned int markpos, int posx, int posy, int mwidth, int mheight, int halign, int valign, char* fontname, int fontsize, long color, int transparent, int wrap, int* lastposx, int* lastposy, int* len, int charspace, int flag)
    25032426{
    2504         debug(1000, "in");
    25052427        int charwidth = 0, lineend = 0;
    25062428        int charcount = 0;
     
    25322454        if(fontsize < 5)
    25332455        {
    2534                 debug(1000, "out -> fontsize to small");
     2456                err("fontsize to small");
    25352457                if(flag == 1) free(tmpstr);
    25362458                return 1;
     
    25442466        if(aktheight > mheight)
    25452467        {
    2546                 debug(1000, "out -> to many textlines");
     2468                err("to many textlines");
    25472469                if(flag == 1) free(tmpstr);
    25482470                return 1;
     
    25932515       
    25942516        if(flag == 1) free(tmpstr);
    2595         debug(1000, "out");
    25962517        return ret;
    25972518}
     
    25992520char* saverect(int posx, int posy, int width, int height)
    26002521{
    2601         debug(1000, "in");
    26022522        char* buf;
    26032523        int y = 0, len = width * skinfb->colbytes, px = posx * skinfb->colbytes;
     
    26132533                memcpy(buf + len * y, skinfb->fb + ((y + posy) * skinfb->pitch) + px, len);
    26142534
    2615         debug(1000, "out");
    26162535        return buf;
    26172536}
     
    26262545void restorerectcheck(char* buf, int posx, int posy, int width, int height, int flag)
    26272546{
    2628         debug(1000, "in");
    26292547        int y = 0, len = width * skinfb->colbytes, px = posx * skinfb->colbytes;
    26302548
     
    26402558                }
    26412559        }
    2642         debug(1000, "out");
    26432560}
    26442561
     
    26612578void lcd_fillrect(int posx, int posy, int width, int height, long color, int transparent)
    26622579{
    2663         //debug(1000, "in");
    26642580        int y, x;
    26652581        unsigned long tmpcol;
     
    26802596                for(x = 0; x < width; x++)
    26812597                        drawpixel(posx + x, posy + y, tmpcol);
    2682 
    2683         //debug(1000, "out");
    26842598}
    26852599
    26862600void lcd_drawrect(int posx, int posy, int width, int height, long color, int transparent)
    26872601{
    2688         //debug(1000, "in");
    26892602        fillrect(posx, posy, width, 1, color, transparent);
    26902603        fillrect(posx, posy + height - 1, width, 1, color, transparent);
    26912604        fillrect(posx, posy, 1, height, color, transparent);
    26922605        fillrect(posx + width - 1, posy, 1, height, color, transparent);
    2693         //debug(1000, "out");
    26942606}
    26952607//*************** GOST LCD
     
    28772789void drawtitlebggradient(struct skin* node)
    28782790{
    2879         debug(1000, "in");
    28802791        if(status.picbordersize > 0)
    28812792                drawgradient(node->rposx + status.picbordersize, node->rposy + status.picbordersize, node->rwidth - (status.picbordersize * 2), node->rheight - (node->rheight - node->titlesize), node->titlebgcol, node->titlebgcol2, node->transparent, node->titlegradient);
    28822793        else
    28832794                drawgradient(node->rposx, node->rposy, node->rwidth, node->rheight - (node->rheight - node->titlesize), node->titlebgcol, node->titlebgcol2, node->transparent, node->titlegradient);
    2884         debug(1000, "out");
    28852795}
    28862796
    28872797void drawbggradient(struct skin* node)
    28882798{
    2889         debug(1000, "in");
    28902799        drawgradient(node->rposx, node->rposy, node->rwidth, node->rheight, node->bgcol, node->bgcol2, node->transparent, node->gradient);
    2891         debug(1000, "out");
    28922800}
    28932801
    28942802void drawtitlebgcol(struct skin* node)
    28952803{
    2896         debug(1000, "in");
    28972804        if(status.picbordersize > 0)
    28982805                fillrect(node->rposx + status.picbordersize, node->rposy + status.picbordersize, node->rwidth - (status.picbordersize * 2), node->rheight - (node->rheight - node->titlesize), node->titlebgcol, node->transparent);
    28992806        else
    29002807                fillrect(node->rposx, node->rposy, node->rwidth, node->rheight - (node->rheight - node->titlesize), node->titlebgcol, node->transparent);
    2901         debug(1000, "out");
    29022808}
    29032809
    29042810void drawbginnercol(struct skin* node)
    29052811{
    2906         debug(1000, "in");
    29072812        fillrect(node->rposx + node->bordersize, node->rposy + node->bordersize, node->rwidth - node->bordersize * 2, node->rheight - node->bordersize * 2, node->bgcol, node->transparent);
    2908         debug(1000, "out");
    29092813}
    29102814
    29112815void drawbgcol(struct skin* node)
    29122816{
    2913         debug(1000, "in");
    29142817        fillrect(node->rposx + node->bgspace, node->rposy + node->bgspace, node->rwidth - (node->bgspace * 2), node->rheight - (node->bgspace * 2), node->bgcol, node->transparent);
    2915         debug(1000, "out");
    29162818}
    29172819
    29182820void drawtitle(struct skin* node)
    29192821{
    2920         debug(1000, "in");
    29212822        if(status.titlelinesize > 0)
    29222823                drawstring(node->title, 1, 0, -1, node->iposx, node->rposy + node->bordersize, node->iwidth, node->titlesize - status.titlelinesize, node->titlealign, MIDDLE, node->font, node->fontsize, node->fontcol, node->transparent, 0, NULL, NULL, NULL, node->charspace, 0);
     
    29272828        else if(node->bordersize > 0)
    29282829                fillrect(node->rposx, node->rposy + node->titlesize, node->rwidth, node->bordersize, node->bordercol, node->transparent);
    2929         debug(1000, "out");
    29302830}
    29312831
    29322832void drawprogressbar(struct skin* node)
    29332833{
    2934         debug(1000, "in");
    29352834        int val = 0;
    29362835
     
    29382837        val = ((float)node->iwidth / 100) * node->progresssize;
    29392838        fillrect(node->rposx + node->bordersize, node->rposy + node->bordersize, val, node->iheight, node->progresscol, node->transparent);
    2940         debug(1000, "out");
    29412839}
    29422840
    29432841void drawmultiprogressbar(struct skin* node)
    29442842{
    2945         debug(1000, "in");
    29462843        struct epgrecord* epgrecord = node->epgrecord;
    29472844        int val1 = 0, val2 = 0;
     
    29592856                epgrecord = epgrecord->next;
    29602857        }
    2961         debug(1000, "out");
    29622858}
    29632859
     
    29872883void drawpicborder(struct skin* node)
    29882884{
    2989         debug(1000, "in");
    29902885        int borderwidth = status.picbordersize;
    29912886        int borderheight = status.picbordersize;
     
    30162911        //drawpic("/home/nit/titan/skin/bs_r.png", node->rposx - node->bordersize + node->rwidth, node->rposy + node->bordersize, 0, node->rheight - (node->bordersize * 2), borderwidth, node->rheight - (node->bordersize * 2), LEFT, TOP, node->transparent, node->picquality, node->picmem);
    30172912        drawpic("/home/nit/titan/skin/bs_r.png", node->rposx + node->rwidth - borderwidth, node->rposy + borderheight, 0, node->rheight - (borderheight * 2), borderwidth, node->rheight - (borderheight * 2), LEFT, TOP, node->transparent, node->picquality, node->picmem);
    3018         debug(1000, "out");
    30192913}
    30202914
    30212915void drawborder(struct skin* node)
    30222916{
    3023         debug(1000, "in");
    30242917        if(node->bordersize == 1 && node->rheight > 2 && node->bordertype == 0)
    30252918                drawrect(node->rposx, node->rposy, node->rwidth, node->rheight, node->bordercol, node->transparent);
     
    30372930                        fillrect(node->rposx + node->rwidth - node->bordersize, node->rposy, node->bordersize, node->rheight, node->bordercol, node->transparent);
    30382931        }
    3039         debug(1000, "out");
    30402932}
    30412933
    30422934void drawscrollbar(struct skin* node)
    30432935{
    3044         debug(1000, "in");
    30452936        if(node->bordersize == 0)
    30462937                drawrect(node->rposx + node->rwidth - node->bordersize - node->scrollbarwidth, node->iposy, node->scrollbarwidth, node->iheight, node->bordercol, node->transparent);
     
    30492940
    30502941        fillrect(node->rposx + node->rwidth - node->bordersize - node->scrollbarwidth, node->iposy + node->scrollbarpos, node->scrollbarwidth, node->scrollbarheight, node->bordercol, node->transparent);
    3051         debug(1000, "out");
    30522942}
    30532943
    30542944void clearshadow(struct skin* node)
    30552945{
    3056         debug(1000, "in");
    3057 
    30582946        if(node->shadowsize < 1) return;
    30592947        switch(node->shadowpos)
     
    30762964                break;
    30772965        }
    3078         debug(1000, "out");
    30792966}
    30802967
    30812968void drawshadow(struct skin* node)
    30822969{
    3083         debug(1000, "in");
    30842970        switch(node->shadowpos)
    30852971        {
     
    31012987                break;
    31022988        }
    3103         debug(1000, "out");
    31042989}
    31052990
     
    31112996        int len = 0;
    31122997        char* bglt = NULL, *bglb = NULL, *bgrt = NULL, *bgrb = NULL;
    3113 
    3114         debug(1000, "in");
    31152998       
    31162999        node->flag = setbit(node->flag, 0);
     
    32703153
    32713154        free(bglt); free(bglb); free(bgrt); free(bgrb);
    3272         debug(1000, "out");
    32733155}
    32743156
    32753157void calcscrollbar(struct skin* node)
    32763158{
    3277         debug(1000, "in");
    3278 
    32793159        node->scrollbarheight = node->iheight;
    32803160
     
    32983178                if(node->scrollbarheight < 1) node->scrollbarheight = 1;
    32993179        }
    3300         debug(1000, "out");
    33013180}
    33023181
     
    33163195int calclistbox(struct skin* node)
    33173196{
    3318         debug(1000, "in");
    33193197        struct skin* child = NULL, *last = NULL, *found = NULL;
    33203198        int selcol = 0;
     
    35323410        }
    35333411        node->poscount = 0;
    3534         debug(1000, "out");
    35353412        return 0;
    35363413}
     
    36193496                if(node->pagecount != parent->aktpage) return 1;
    36203497
    3621         debug(1000, "in");
    36223498        int shadowlx = 0, shadowrx = 0, shadowoy = 0, shadowuy = 0;
    36233499        unsigned int linecount = 0, pagecount = 0, poscount = 0;
     
    38013677                //node->transparent = parent->transparent;
    38023678
    3803         debug(1000, "out");
    38043679        return 0;
    38053680}
     
    38073682int clearscreenalways()
    38083683{
    3809         debug(1000, "in");
    38103684        int i, ret = 0;
    38113685
     
    38183692        }
    38193693
    3820         debug(1000, "out");
    38213694        return ret;
    38223695}
     
    38243697int drawscreenalways(struct skin* node, int screencalc)
    38253698{
    3826         debug(1000, "in");
    38273699        int i, ret = 0;
    38283700
     
    38413713        }
    38423714
    3843         debug(1000, "out");
    38443715        return ret;
    38453716}
     
    38473718int drawscreennode(struct skin *node, char* nodename, int screencalc)
    38483719{
    3849         debug(1000, "in");
    3850 
    38513720        node = getscreennode(node, nodename);
    38523721        m_lock(&status.drawingmutex, 0);
     
    38583727        m_unlock(&status.drawingmutex, 0);
    38593728
    3860         debug(1000, "out");
    38613729        return 0;
    38623730}
     
    38643732int drawscreennodebyname(char* screenname, char* nodename, int screencalc)
    38653733{
    3866         debug(1000, "in");
    38673734        struct skin *node;
    38683735
     
    38763743        m_unlock(&status.drawingmutex, 0);
    38773744
    3878         debug(1000, "out");
    38793745        return 0;
    38803746}
     
    38913757{
    38923758        struct fb* merkskinfb = NULL;
    3893 
    3894         debug(1000, "in");
    38953759        int ret;
    38963760        struct skin *child = NULL, *parent = NULL, *oldparent = NULL;
     
    39123776                if(flag == 0 || flag == 4)
    39133777                        m_unlock(&status.drawingmutex, 0);
    3914                 debug(1000, "out -> setnodeattr ret = 1");
     3778                err("setnodeattr ret = 1");
    39153779                return 1;
    39163780        }
     
    40703934        if(flag == 0 || flag == 4)
    40713935                m_unlock(&status.drawingmutex, 0);
    4072         debug(1000, "out");
    40733936        return 0;
    40743937}
     
    40763939int drawscreenbyname(char* screenname, int screencalc, int flag)
    40773940{
    4078         debug(1000, "in");
    40793941        int ret;
    40803942        struct skin* node = NULL;
     
    40883950
    40893951        ret = drawscreen(node, screencalc, flag);
    4090         debug(1000, "out");
    40913952        return ret;
    40923953}
     
    40943955int changeinput(struct skin* node, char* text)
    40953956{
    4096         debug(1000, "in");
    40973957        int ret = 1;
    40983958
     
    41163976                ret = 0;
    41173977        }
    4118         debug(1000, "out");
    41193978
    41203979        return ret;
     
    41233982int changetext(struct skin* node, char* text)
    41243983{
    4125         debug(1000, "in");
    41263984        int ret = 1;
    41273985
     
    41353993                ret = 0;
    41363994        }
    4137         debug(1000, "out");
    41383995
    41393996        return ret;
     
    41423999int changetext2(struct skin* node, char* text)
    41434000{
    4144         debug(1000, "in");
    41454001        int ret = 1;
    41464002
     
    41544010                ret = 0;
    41554011        }
    4156         debug(1000, "out");
    41574012
    41584013        return ret;
     
    41624017int changename(struct skin* node, char* text)
    41634018{
    4164         debug(1000, "in");
    41654019        int ret = 1;
    41664020
     
    41744028                ret = 0;
    41754029        }
    4176         debug(1000, "out");
    41774030
    41784031        return ret;
     
    41814034int changepicmem(struct skin* node, char* text, int timeout, int del)
    41824035{
    4183         debug(1000, "in");
    41844036        unsigned long width = 0, height = 0, rowbytes = 0;
    41854037        int ret = 1, channels = 0, memfd = -1, length = 0;
     
    42104062                ret = 0;
    42114063        }
    4212         debug(1000, "out");
    42134064
    42144065        return ret;
     
    42174068int changepic(struct skin* node, char* text)
    42184069{
    4219         debug(1000, "in");
    42204070        int ret = 1;
    42214071
     
    42304080                ret = 0;
    42314081        }
    4232         debug(1000, "out");
    42334082
    42344083        return ret;
     
    42374086int changeselectpic(struct skin* node, char* text)
    42384087{
    4239         debug(1000, "in");
    42404088        int ret = 1;
    42414089
     
    42494097                ret = 0;
    42504098        }
    4251         debug(1000, "out");
    42524099
    42534100        return ret;
     
    42564103int changetitle(struct skin* node, char* text)
    42574104{
    4258         debug(1000, "in");
    42594105        int ret = 1;
    42604106
     
    42744120                ret = 0;
    42754121        }
    4276         debug(1000, "out");
    42774122
    42784123        return ret;
     
    42814126int changemask(struct skin* node, char* text)
    42824127{
    4283         debug(1000, "in");
    42844128        int ret = 1;
    42854129
     
    43024146                ret = 0;
    43034147        }
    4304         debug(1000, "out");
    43054148
    43064149        return ret;
     
    43094152int changeret(struct skin* node, char* text)
    43104153{
    4311         debug(1000, "in");
    43124154        int ret = 1;
    43134155
     
    43214163                ret = 0;
    43224164        }
    4323         debug(1000, "out");
    43244165
    43254166        return ret;
     
    43284169int changeparent(struct skin* node, char* text)
    43294170{
    4330         debug(1000, "in");
    43314171        int ret = 1;
    43324172
     
    43404180                ret = 0;
    43414181        }
    4342         debug(1000, "out");
    43434182
    43444183        return ret;
     
    43474186int changefont(struct skin* node, char* text)
    43484187{
    4349         debug(1000, "in");
    43504188        int ret = 1;
    43514189
     
    43594197                ret = 0;
    43604198        }
    4361         debug(1000, "out");
    43624199
    43634200        return ret;
     
    43664203int changeparam1(struct skin* node, char* text)
    43674204{
    4368         debug(1000, "in");
    43694205        int ret = 1;
    43704206
     
    43784214                ret = 0;
    43794215        }
    4380         debug(1000, "out");
    43814216
    43824217        return ret;
     
    43854220int changeparam2(struct skin* node, char* text)
    43864221{
    4387         debug(1000, "in");
    43884222        int ret = 1;
    43894223
     
    43974231                ret = 0;
    43984232        }
    4399         debug(1000, "out");
    44004233
    44014234        return ret;
     
    44044237int changechoiceboxvalue(struct skin* node, char* text)
    44054238{
    4406         debug(1000, "in");
    44074239        int ret = 1;
    44084240
     
    44164248                ret = 0;
    44174249        }
    4418         debug(1000, "out");
    44194250
    44204251        return ret;
  • titan/titan/skinconfig.h

    r16367 r23286  
    6969struct clist* addskinconfigint(char *key, int value)
    7070{
    71         debug(1000, "in");
    7271        char* fileline = NULL;
    7372        struct clist* ret = NULL;
     
    7776
    7877        free(fileline);
    79         debug(1000, "out");
    8078        return ret;
    8179}
     
    8381int readskinconfig(const char *filename, struct clist** tmpskinconfig)
    8482{
    85         debug(1000, "in");
    8683        FILE *fd = NULL;
    8784        char *fileline = NULL, *pos;
     
    124121        fclose(fd);
    125122        free(fileline);
    126         debug(1000, "out");
    127123        return 0;
    128124}
     
    176172int reloadskinconfig(char *filename)
    177173{
    178         debug(1000, "in");
    179174        int ret = 0;
    180175
     
    183178        if(ret != 0)
    184179        {
    185                 debug(1000, "out -> readskinconfig fail");
     180                err("readskinconfig fail");
    186181                return 1;
    187182        }
    188183
    189         debug(1000, "out");
    190184        return 0;
    191185}
  • titan/titan/skinfunc.h

    r22999 r23286  
    452452        // type 2 = remainingtime
    453453
    454         debug(1000, "in");
    455454        struct epg* epgnode = NULL;
    456455        struct tm *loctime = NULL;
     
    461460        if(format == NULL)
    462461        {
    463                 debug(1000, "out -> NULL detect");
     462                err("NULL detect");
    464463                return NULL;
    465464        }
     
    508507
    509508                        free(loctime); loctime = NULL;
    510                         debug(1000, "out");
    511509                        return buf1;
    512510                }
    513511        }
    514         debug(1000, "out");
    515512        return NULL;
    516513}
     
    698695char* gettime(struct skin* node, char* format)
    699696{