Changeset 23267


Ignore:
Timestamp:
09/04/13 23:28:54 (10 years ago)
Author:
nit
Message:

[titan] cleanup

Location:
titan/titan
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • titan/titan/eit.h

    r22265 r23267  
    124124int writeepgfast(const char* filename, char* buf, int buflen)
    125125{
    126         debug(1000, "in");
    127126        FILE *fd = NULL;
    128127        int ret;
    … …  
    157156
    158157        fclose(fd);
    159         debug(1000, "out");
    160158        return 0;
    161159}
    … …  
    163161int writeepgslow(const char* filename)
    164162{
    165         debug(1000, "in");
    166163        FILE *fd = NULL;
    167164        struct channel *chnode = channel;
    … …  
    280277        fclose(fd);
    281278        if(err == 1) unlink(filename);
    282         debug(1000, "out");
    283279        m_unlock(&status.epgmutex, 4);
    284280        return 0;
    … …  
    311307        if(epgnode == NULL)
    312308        {
    313                 debug(1000, "out -> NULL detect");
     309                err("NULL detect");
    314310                return NULL;
    315311        }
    … …  
    327323struct epg* getepgbytime(struct channel* chnode, time_t akttime)
    328324{
    329         debug(1000, "in");
    330 
    331325        m_lock(&status.epgmutex, 4);
    332326
    333327        if(chnode == NULL || chnode->epg == NULL)
    334328        {
    335                 debug(1000, "out-> NULL detect");
    336329                m_unlock(&status.epgmutex, 4);
    337330                return NULL;
    … …  
    339332
    340333        struct epg *node = chnode->epg;
    341 
    342334        while(node != NULL)
    343335        {
    344336                if(node->starttime <= akttime && node->endtime > akttime)
    345337                {
    346                         debug(1000, "out");
    347                         m_unlock(&status.epgmutex, 4);
     338                        m_unlock(&status.epgmutex, 4);
    348339                        return node;
    349340                }
    … …  
    358349struct epg* getepgnext(struct channel* chnode)
    359350{
    360         debug(1000, "in");
    361351        time_t akttime = time(NULL);
    362352
    … …  
    365355        if(chnode == NULL || chnode->epg == NULL)
    366356        {
    367                 debug(1000, "out-> NULL detect");
    368357                m_unlock(&status.epgmutex, 4);
    369358                return NULL;
    … …  
    371360
    372361        struct epg *node = chnode->epg;
    373 
    374362        while(node != NULL)
    375363        {
    376364                if(node->starttime >= akttime)
    377365                {
    378                         debug(1000, "out");
    379                         m_unlock(&status.epgmutex, 4);
     366                        m_unlock(&status.epgmutex, 4);
    380367                        return node;
    381368                }
    … …  
    405392struct epg* getepg(struct channel* chnode, int eventid, int flag)
    406393{
    407         if(chnode == NULL)
    408         {
    409                 debug(1000, "out-> NULL detect");
    410                 return NULL;
    411         }
     394        if(chnode == NULL) return NULL;
    412395
    413396        if(flag == 0) m_lock(&status.epgmutex, 4);
    … …  
    436419        int changetime = 0;
    437420
    438         if(chnode == NULL || epgnode == NULL)
    439         {
    440                 debug(1000, "out-> NULL detect");
    441                 return NULL;
    442         }
     421        if(chnode == NULL || epgnode == NULL) return NULL;
    443422
    444423        //if(epgnode->version >= version) return epgnode;
    … …  
    504483
    505484        if(flag == 0) m_unlock(&status.epgmutex, 4);
    506 //      debug(1000, "out");
    507485        return epgnode;
    508486}
    … …  
    512490struct epg* addoldentryepg(struct channel* chnode, struct epg* newnode, int flag)
    513491{
    514 //      debug(1000, "in");
    515 
    516         if(newnode == NULL)
    517         {
    518                 debug(1000, "out-> NULL detect");
    519                 return NULL;
    520         }
     492        if(newnode == NULL) return NULL;
    521493
    522494        if(flag == 0) m_lock(&status.epgmutex, 4);
    … …  
    544516        addoldentry((void*)newnode, 0, time(NULL) + 3600, NULL);
    545517
    546 //      debug(1000, "out");
    547518        return newnode;
    548519}
    … …  
    552523struct epg* addepg(struct channel* chnode, int eventid, int version, time_t starttime, time_t endtime, struct epg* last, int flag)
    553524{
    554 //      debug(1000, "in");
    555 
    556         if(chnode == NULL)
    557         {
    558                 debug(1000, "out-> NULL detect");
    559                 return NULL;
    560         }
     525        if(chnode == NULL) return NULL;
    561526
    562527        if(flag == 0) m_lock(&status.epgmutex, 4);
    … …  
    626591
    627592        if(flag == 0) m_unlock(&status.epgmutex, 4);
    628 //      debug(1000, "out");
    629593        return newnode;
    630594}
    … …  
    632596void deloldentryepg(struct epg* node)
    633597{
    634         debug(1000, "in");
    635 
    636         if(node == NULL)
    637         {
    638                 debug(1000, "out-> NULL detect");
    639                 return;
    640         }
     598        if(node == NULL) return;
    641599
    642600        clearepgentry(node);
    … …  
    644602        free(node);
    645603        node = NULL;
    646 
    647         debug(1000, "out");
    648604}
    649605
    … …  
    666622void delepg(struct channel* chnode, struct epg* epgnode, int flag)
    667623{
    668         debug(1000, "in");
    669 
    670         if(chnode == NULL)
    671         {
    672                 debug(1000, "out-> NULL detect");
    673                 return;
    674         }
     624        if(chnode == NULL) return;
    675625
    676626        if(flag == 0) m_lock(&status.epgmutex, 4);
    … …  
    706656        }
    707657        if(flag == 0) m_unlock(&status.epgmutex, 4);
    708         debug(1000, "out");
    709658}
    710659
    711660void freeepg(struct channel* chnode)
    712661{
    713         debug(1000, "in");
    714 
    715         if(chnode == NULL)
    716         {
    717                 debug(1000, "out-> NULL detect");
    718                 return;
    719         }
     662        if(chnode == NULL) return;
    720663
    721664        m_lock(&status.epgmutex, 4);
    … …  
    730673        }
    731674        m_unlock(&status.epgmutex, 4);
    732         debug(1000, "out");
    733675}
    734676
    … …  
    12601202                if(epgnode == NULL)
    12611203                {
    1262                         debug(1000, "out -> NULL detect");
    12631204                        m_unlock(&status.epgmutex, 4);
    12641205                        continue;
    … …  
    12861227int readepg(const char* filename)
    12871228{
    1288         debug(1000, "in");
    12891229        FILE *fd = NULL;
    12901230        struct channel *chnode = channel, *oldchnode = NULL;
    … …  
    14171357                        if(chnode == NULL)
    14181358                        {
    1419                                 debug(1000, "out -> NULL detect");
    14201359                                free(title); title = NULL;
    14211360                                free(subtitle); subtitle = NULL;
    … …  
    14401379                if(epgnode == NULL)
    14411380                {
    1442                         debug(1000, "out -> NULL detect");
    14431381                        free(title); title = NULL;
    14441382                        free(subtitle); subtitle = NULL;
    … …  
    14641402        if(count > 50) unlink(filename);
    14651403
    1466         debug(1000, "out");
    14671404        return 0;
    14681405}
    … …  
    16511588void epgthreadfunc(struct stimerthread* self)
    16521589{
    1653         debug(1000, "in");
    16541590        char* tmpstr = NULL;
    16551591        time_t akttime = 0;
    … …  
    17421678end:
    17431679        debug(400, "end epg thread on aktiv channel");
    1744         debug(1000, "out");
    17451680}
    17461681

  • titan/titan/epgrecord.h

    r12803 r23267  
    1515struct epgrecord* addepgrecord(time_t epgbegin, time_t epgend, time_t begin, time_t end, struct epgrecord** first, struct epgrecord* last)
    1616{
    17         //debug(1000, "in");
    1817        struct epgrecord *newnode = NULL, *prev = NULL, *node = *first;
    1918
    … …  
    6059        if(node != NULL) node->prev = newnode;
    6160
    62         //debug(1000, "out");
    6361        return newnode;
    6462}
    … …  
    6664void delepgrecord(struct epgrecord* epgrecordnode, struct epgrecord** first)
    6765{
    68         debug(1000, "in");
    6966        struct epgrecord *node = *first, *prev = *first;
    7067
    … …  
    9491                node = node->next;
    9592        }
    96         debug(1000, "out");
    9793}
    9894
    9995void freeepgrecord(struct epgrecord** first)
    10096{
    101         debug(1000, "in");
    10297        struct epgrecord *node = *first, *prev = *first;
    10398
    … …  
    109104                        delepgrecord(prev, first);
    110105        }
    111         debug(1000, "out");
    112106}
    113107

  • titan/titan/epgscan.h

    r20984 r23267  
    112112struct epgscanlist* getepgscanlistbytransponder(uint64_t transponderid)
    113113{
    114         //debug(1000, "in");
    115114        struct epgscanlist *node = epgscanlist;
    116115
    … …  
    118117        {
    119118                if(node->transponderid == transponderid)
    120                 {
    121                         //debug(1000, "out");
    122119                        return node;
    123                 }
    124120
    125121                node = node->next;
    … …  
    374370int readepgscanlist(const char* filename)
    375371{
    376         debug(1000, "in");
    377372        FILE *fd = NULL;
    378373        char *fileline = NULL;
    … …  
    421416int delepgscanlist(int serviceid, uint64_t transponderid)
    422417{
    423         debug(1000, "in");
    424418        int ret = 1;
    425419        struct epgscanlist *node = epgscanlist, *prev = epgscanlist;
    … …  
    452446                node = node->next;
    453447        }
    454         debug(1000, "out");
    455448        return ret;
    456449}
    … …  
    458451struct epgscanlist* getepgscanlist(int serviceid, uint64_t transponderid)
    459452{
    460         //debug(1000, "in");
    461453        struct epgscanlist *node = epgscanlist;
    462454
    … …  
    464456        {
    465457                if(node->serviceid == serviceid && node->transponderid == transponderid)
    466                 {
    467                         //debug(1000, "out");
    468458                        return node;
    469                 }
    470459
    471460                node = node->next;
    … …  
    477466void freeepgscanlist()
    478467{
    479         debug(1000, "in");
    480468        struct epgscanlist *node = epgscanlist, *prev = epgscanlist;
    481469
    … …  
    487475                        delepgscanlist(prev->serviceid, prev->transponderid);
    488476        }
    489         debug(1000, "out");
    490477}
    491478
    492479int writeepgscanlist(const char *filename)
    493480{
    494         debug(1000, "in");
    495481        FILE *fd = NULL;
    496482        struct epgscanlist *node = epgscanlist;
    … …  
    515501
    516502        fclose(fd);
    517         debug(1000, "out");
    518503        return 0;
    519504}

  • titan/titan/extepg.h

    r20834 r23267  
    444444struct extepgcache* addextepgcache(int id, struct epg* epgnode, struct extepgcache* last)
    445445{
    446         //debug(1000, "in");
    447446        struct extepgcache *newnode = NULL, *prev = NULL, *node = extepgcache;
    448447
    … …  
    477476        newnode->next = node;
    478477
    479         //debug(1000, "out");
    480478        return newnode;
    481479}
    … …  
    483481void delextepgcache(struct extepgcache* cache)
    484482{
    485         //debug(1000, "in");
    486483        struct extepgcache *node = extepgcache, *prev = extepgcache;
    487484
    … …  
    503500                node = node->next;
    504501        }
    505         //debug(1000, "out");
    506502}
    507503
    508504void freeextepgcache()
    509505{
    510         //debug(1000, "in");
    511506        struct extepgcache *node = extepgcache, *prev = extepgcache;
    512507
    … …  
    518513                        delextepgcache(prev);
    519514        }
    520         //debug(1000, "out");
    521515}
    522516
    523517struct extepgcache* getextepgcache(int id)
    524518{
    525         //debug(1000, "in");
    526519        struct extepgcache *node = extepgcache;
    527520
    … …  
    529522        {
    530523                if(node->id == id)
    531                 {
    532                         //debug(1000, "out");
    533524                        return node;
    534                 }
    535525
    536526                node = node->next;
    … …  
    542532struct extepgchannel* addextepgchannel(int id, int serviceid, off64_t transponderid, struct extepgchannel* last)
    543533{
    544         //debug(1000, "in");
    545534        struct extepgchannel *newnode = NULL, *prev = NULL, *node = extepgchannel;
    546535
    … …  
    576565        newnode->next = node;
    577566
    578         //debug(1000, "out");
    579567        return newnode;
    580568}
    … …  
    582570void delextepgchannel(struct extepgchannel* channel)
    583571{
    584         //debug(1000, "in");
    585572        struct extepgchannel *node = extepgchannel, *prev = extepgchannel;
    586573
    … …  
    602589                node = node->next;
    603590        }
    604         //debug(1000, "out");
    605591}
    606592
    607593void freeextepgchannel()
    608594{
    609         //debug(1000, "in");
    610595        struct extepgchannel *node = extepgchannel, *prev = extepgchannel;
    611596
    … …  
    617602                        delextepgchannel(prev);
    618603        }
    619         //debug(1000, "out");
    620604}
    621605
    622606struct extepgchannel* getextepgchannel(int id)
    623607{
    624         //debug(1000, "in");
    625608        struct extepgchannel *node = extepgchannel;
    626609
    … …  
    628611        {
    629612                if(node->id == id)
    630                 {
    631                         //debug(1000, "out");
    632613                        return node;
    633                 }
    634614
    635615                node = node->next;
    … …  
    641621struct extepgconfig* addextepgconfig(char *line, int count, struct extepgconfig* last)
    642622{
    643         //debug(1000, "in");
    644623        struct extepgconfig *newnode = NULL, *prev = NULL, *node = extepgconfig;
    645624        char *file = NULL;
    … …  
    705684        newnode->next = node;
    706685
    707         //debug(1000, "out");
    708686        return newnode;
    709687}
    … …  
    711689int readextepgconfig(char* filename)
    712690{
    713         debug(1000, "in");
    714691        FILE *fd = NULL;
    715692        char *fileline = NULL;
    … …  
    757734void delextepgconfig(struct extepgconfig* config)
    758735{
    759         //debug(1000, "in");
    760736        struct extepgconfig *node = extepgconfig, *prev = extepgconfig;
    761737
    … …  
    780756                node = node->next;
    781757        }
    782         //debug(1000, "out");
    783758}
    784759
    785760void freeextepgconfig()
    786761{
    787         //debug(1000, "in");
    788762        struct extepgconfig *node = extepgconfig, *prev = extepgconfig;
    789763
    … …  
    795769                        delextepgconfig(prev);
    796770        }
    797         //debug(1000, "out");
    798771}
    799772
    800773struct extepgconfig* getextepgconfig(uint64_t transponderid, int type)
    801774{
    802         //debug(1000, "in");
    803775        struct extepgconfig *node = extepgconfig;
    804776
    … …  
    806778        {
    807779                if(node->transponderid == transponderid && node->type == type)
    808                 {
    809                         //debug(1000, "out");
    810780                        return node;
    811                 }
    812781
    813782                node = node->next;
    … …  
    1018987                        tmpchnode = getchannel(serviceid, transponderid);
    1019988                        if(tmpchnode == NULL)
    1020                         {
    1021                                 debug(1000, "NULL detect");
    1022989                                continue;
    1023                         }
    1024990
    1025991                        //look in epglist if channel exists
    … …  
    10651031                        if(epgnode == NULL)
    10661032                        {
    1067                                 debug(1000, "NULL detect");
    10681033                                m_unlock(&status.epgmutex, 4);
    10691034                                continue;
    … …  
    15031468                                if(tmpchnode == NULL)
    15041469                                {
    1505                                         debug(1000, "NULL detect");
    15061470                                        pos += 3;
    15071471                                        continue;
    … …  
    15391503                                if(epgnode == NULL)
    15401504                                {
    1541                                         debug(1000, "NULL detect");
    15421505                                        m_unlock(&status.epgmutex, 4);
    15431506                                        pos += 3;
    … …  
    20912054                                                if(tmpchnode == NULL)
    20922055                                                {
    2093                                                         debug(1000, "NULL detect");
    20942056                                                        p += packetlen;
    20952057                                                        continue;
    … …  
    21272089                                                if(epgnode == NULL)
    21282090                                                {
    2129                                                         debug(1000, "NULL detect");
    21302091                                                        m_unlock(&status.epgmutex, 4);
    21312092                                                        p += packetlen;

  • titan/titan/fb.h

    r20751 r23267  
    44struct fb* getfb(char *name)
    55{
    6         debug(1000, "in");
    76        struct fb *node = fb;
    87
    … …  
    109        {
    1110                if(ostrstr(node->name, name) != NULL)
    12                 {
    13                         debug(1000, "out");
    1411                        return node;
    15                 }
    1612
    1713                node = node->next;
    … …  
    2319long getfbsize(int dev)
    2420{
    25         debug(1000, "in");
    2621        struct fb* node = fb;
    2722        unsigned long fbmemcount = 0;
    … …  
    3025        if(fb == NULL)
    3126        {
    32                 debug(1000, "out -> NULL dedect");
     27                err("NULL dedect");
    3328                return 0;
    3429        }
    … …  
    5146        }
    5247
    53         debug(1000, "out");
    5448        return fix_screeninfo.smem_len - fbmemcount;
    5549}
    … …  
    5751struct fb* addfb(char *fbname, int dev, int width, int height, int colbytes, int fd, unsigned char* mmapfb, unsigned long fixfbsize)
    5852{
    59         debug(1000, "in");
    6053        struct fb *newnode = NULL, *node = fb;
    6154        char *name = NULL;
    … …  
    120113
    121114        debug(100, "fbname=%s, fbwidth=%d, fbheight=%d, fbcol=%d, fbsize=%ld", newnode->name, newnode->width, newnode->height, newnode->colbytes, newnode->varfbsize);
    122         debug(1000, "out");
    123115        return newnode;
    124116}
    … …  
    147139void delfb(char *name)
    148140{
    149         debug(1000, "in");
    150141        struct fb *node = fb, *prev = fb;
    151142
    … …  
    170161                node = node->next;
    171162        }
    172         debug(1000, "out");
    173163}
    174164
    175165void freefb()
    176166{
    177         debug(1000, "in");
    178167        struct fb *node = fb, *prev = fb;
    179168
    … …  
    185174                        delfb(prev->name);
    186175        }
    187         debug(1000, "out");
    188176}
    189177
    190178struct fb* openfb(char *fbdev, int devnr)
    191179{
    192         debug(1000, "in");
    193180        int fd = -1;
    194181        unsigned char *mmapfb = NULL;
    … …  
    248235#endif
    249236
    250         debug(1000, "out");
    251237        return node;
    252238}

  • titan/titan/filelist.h

    r23185 r23267  
    195195int createfilelist(struct skin* screen, struct skin* node, int view)
    196196{
    197         debug(1000, "in");
    198197        struct dirent64 **filelist = NULL;
    199198
    … …  
    207206        if(node->input == NULL)
    208207        {
    209                 debug(1000, "out -> NULL detect");
     208                err("NULL detect");
    210209                return 1;
    211210        }
    … …  
    755754*/
    756755        free(filelist);
    757         debug(1000, "out");
    758756        return 0;
    759757}
    … …  
    761759void getfilelist(struct skin* input, struct skin* filelistpath, struct skin* filelist, char* path, char* filemask, int tmpview, char* selection)
    762760{
    763         debug(1000, "in");
    764761        char* tmpstr = NULL;
    765762
    … …  
    795792
    796793        drawscreen(input, 0, 0);
    797         debug(1000, "out");
    798794}
    799795

  • titan/titan/font.h

    r16471 r23267  
    66FT_Error MyFaceRequester(FTC_FaceID face_id, FT_Library library, FT_Pointer request_data, FT_Face *aface)
    77{
    8         debug(1000, "in");
    98        FT_Error ret;
    109
    … …  
    1413
    1514        FT_Select_Charmap(*aface, ft_encoding_unicode);
    16         debug(1000, "out");
    1715        return ret;
    1816}
    … …  
    2018struct font* addfont(char *fontname)
    2119{
    22         debug(1000, "in");
    2320        struct font *newnode = NULL, *node = font;
    2421        char *name = NULL;
    … …  
    5148                font = newnode;
    5249
    53         debug(1000, "out");
    5450        return newnode;
    5551}
    … …  
    5753void delfont(char *name)
    5854{
    59         debug(1000, "in");
    6055        struct font *node = font, *prev = font;
    6156
    … …  
    8479                node = node->next;
    8580        }
    86         debug(1000, "out");
    8781}
    8882
    8983int initfont()
    9084{
    91         debug(1000, "in");
    9285        int ret;
    9386
    … …  
    9992        }
    10093
    101         debug(1000, "out");
    10294        return 0;
    10395}
    … …  
    10597void deinitfont()
    10698{
    107         debug(1000, "in");
    10899        FT_Done_FreeType(library);
    109         debug(1000, "out");
    110100}
    111101
    112102int openfont(char *filename)
    113103{
    114         debug(1000, "in");
    115104        int ret;
    116105        struct font* node = font;
    … …  
    153142        node->use_kerning = FT_HAS_KERNING(node->face);
    154143
    155         debug(1000, "out");
    156144        return 0;
    157145}
    … …  
    159147struct font* getfont(char *name)
    160148{
    161         debug(1000, "in");
    162149        struct font *node = font;
    163150
    … …  
    165152        {
    166153                if(ostrstr(node->name, name) != NULL)
    167                 {
    168                         debug(1000, "out");
    169154                        return node;
    170                 }
    171155
    172156                node = node->next;
    … …  
    178162void freefont()
    179163{
    180         debug(1000, "in");
    181164        struct font *node = font, *prev = font;
    182165
    … …  
    188171                        delfont(prev->name);
    189172        }
    190         debug(1000, "out");
    191173}
    192174

  • titan/titan/frontenddev.h

    r22885 r23267  
    44int calclof(struct dvbdev* node, struct transponder* tpnode, char* feaktnr, int flag)
    55{
    6         debug(1000, "in");
    76        int loftype = 0;
    87        int lofl, lofh, lofthreshold;
    … …  
    1211        if(node == NULL || tpnode == NULL)
    1312        {
    14                 debug(1000, "out-> NULL detect");
     13                err("NULL detect");
    1514                return -1;
    1615        }
    … …  
    110109        if(dvbnode == NULL)
    111110        {
    112                 debug(1000, "out -> NULL detect");
     111                err("NULL detect");
    113112                return NULL;
    114113        }
    … …  
    144143        if(dvbnode == NULL || tpnode == NULL)
    145144        {
    146                 debug(1000, "out-> NULL detect");
     145                err("NULL detect");
    147146                return;
    148147        }
    … …  
    191190struct dvbdev* fegetfree(struct transponder* tpnode, int flag, struct dvbdev* dvbfirst)
    192191{
    193         debug(1000, "in");
    194192        struct dvbdev* dvbnode = NULL;
    195193        struct dvbdev* tmpdvbnode = NULL;
    … …  
    204202        if(tpnode == NULL)
    205203        {
    206                 debug(1000, "out -> NULL detect");
     204                err("NULL detect");
    207205                return NULL;
    208206        }
    … …  
    419417        }
    420418
    421         debug(1000, "out");
    422419        return NULL;
    423420}
    … …  
    425422int feopen(struct dvbdev* node, char *fedev)
    426423{
    427         debug(1000, "in");
    428424        int fd = -1;
    429425
    … …  
    441437
    442438        closeonexec(fd);
    443         debug(1000, "out");
    444439        return fd;
    445440}
    … …  
    447442void feclose(struct dvbdev* node, int fd)
    448443{
    449         debug(1000, "in");
    450 
    451444        if(node != NULL)
    452445        {
    … …  
    456449        else
    457450                close(fd);
    458 
    459         debug(1000, "out");
    460451}
    461452
    462453int fegetunlock(struct dvbdev* node)
    463454{
    464         debug(1000, "in");
    465455        fe_status_t status;
    466456
    467457        if(node == NULL)
    468458        {
    469                 debug(1000, "out-> NULL detect");
     459                err("NULL detect");
    470460                return 1;
    471461        }
    … …  
    478468                perr("FE_READ_STATUS");
    479469
    480         debug(1000, "out");
    481         if(status & FE_HAS_LOCK)
     470        if(status & FE_HAS_LOCK)
    482471                return 0;
    483472        else
    … …  
    487476int fewait(struct dvbdev* node)
    488477{
    489         debug(1000, "in");
    490478        //struct dvb_frontend_event ev;
    491479        fe_status_t status;
    … …  
    495483        if(node == NULL)
    496484        {
    497                 debug(1000, "out-> NULL detect");
     485                err("NULL detect");
    498486                return 1;
    499487        }
    … …  
    517505        }
    518506
    519         debug(1000, "out");
    520507        //if(ev.status & FE_HAS_LOCK)
    521508        //      return 0;
    … …  
    528515void fegetfrontend(struct dvbdev* node)
    529516{
    530         debug(1000, "in");
    531 
    532         if(node == NULL)
    533         {
    534                 debug(1000, "out-> NULL detect");
     517        if(node == NULL)
     518        {
     519                err(""NULL detect");
    535520                return;
    536521        }
    … …  
    584569        }
    585570#endif
    586 
    587         debug(1000, "out");
    588571}
    589572
    … …  
    594577        if(node == NULL)
    595578        {
    596                 debug(1000, "out-> NULL detect");
     579                err("NULL detect");
    597580                return 1;
    598581        }
    … …  
    609592                usleep(wait * 1000);
    610593        }
    611         debug(1000, "out");
    612594       
    613595        return ret;
    … …  
    618600int fesetvoltage(struct dvbdev* node, fe_sec_voltage_t volt, int wait)
    619601{
    620         debug(1000, "in");
    621602        int ret = 0;
    622603       
    623604        if(node == NULL)
    624605        {
    625                 debug(1000, "out-> NULL detect");
     606                err("NULL detect");
    626607                return 1;
    627608        }
    … …  
    649630                }
    650631        }
    651         debug(1000, "out");
    652        
     632
    653633        return ret;
    654634}
    … …  
    656636void fediseqcsendburst(struct dvbdev* node, fe_sec_mini_cmd_t burst, int wait)
    657637{
    658         debug(1000, "in");
    659         if(node == NULL)
    660         {
    661                 debug(1000, "out-> NULL detect");
     638        if(node == NULL)
     639        {
     640                err("NULL detect");
    662641                return;
    663642        }
    … …  
    667646                perr("FE_DISEQC_SEND_BURST");
    668647        usleep(wait * 1000);
    669         debug(1000, "out");
    670648}
    671649
    672650void fediseqcsendmastercmd(struct dvbdev* node, struct dvb_diseqc_master_cmd *cmd, int wait)
    673651{
    674         debug(1000, "in");
    675652        int i, repeat = 0, imsg = 0;
    676653        char* tmpstr = NULL;
    … …  
    678655        if(node == NULL)
    679656        {
    680                 debug(1000, "out-> NULL detect");
     657                err("NULL detect");
    681658                return;
    682659        }
    … …  
    700677        imsg = (cmd->msg[0] << 24) | (cmd->msg[1] << 16) | (cmd->msg[2] << 8) | cmd->msg[3];
    701678        debug(200, "DISEQC Master cmd (%s -> %04X)", node->feshortname, imsg);
    702         debug(1000, "out");
    703679}
    704680
    705681void fesdiseqcpoweron(struct dvbdev* node)
    706682{
    707         debug(1000, "in");
    708683        struct dvb_diseqc_master_cmd cmd = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0};
    709684
    710685        if(node == NULL)
    711686        {
    712                 debug(1000, "out-> NULL detect");
     687                err("NULL detect");
    713688                return;
    714689        }
    … …  
    721696        debug(200, "DISEQC Power on (%s)", node->feshortname);
    722697        fediseqcsendmastercmd(node, &cmd, 100);
    723         debug(1000, "out");
    724698}
    725699
    726700void fesdiseqcreset(struct dvbdev* node)
    727701{
    728         debug(1000, "in");
    729702        struct dvb_diseqc_master_cmd cmd = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0};
    730703       
    731704        if(node == NULL)
    732705        {
    733                 debug(1000, "out-> NULL detect");
     706                err("NULL detect");
    734707                return;
    735708        }
    … …  
    742715        debug(200, "DISEQC Reset (%s)", node->feshortname);
    743716        fediseqcsendmastercmd(node, &cmd, 100);
    744         debug(1000, "out");
    745717}
    746718
    747719void fesdiseqcstandby(struct dvbdev* node)
    748720{
    749         debug(1000, "in");
    750721        struct dvb_diseqc_master_cmd cmd = {{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0};
    751722       
    752723        if(node == NULL)
    753724        {
    754                 debug(1000, "out-> NULL detect");
     725                err("NULL detect");
    755726                return;
    756727        }
    … …  
    763734        debug(200, "DISEQC Standby (%s)", node->feshortname);
    764735        fediseqcsendmastercmd(node, &cmd, 100);
    765         debug(1000, "out");
    766736}
    767737
    768738void fediseqcrotor(struct dvbdev* node, struct transponder* tpnode, int pos, int flag)
    769739{
    770         debug(1000, "in");
    771740        int orbitalpos = 0;
    772741        fe_sec_voltage_t oldvolt = 0;
    … …  
    776745        if(node == NULL)
    777746        {
    778                 debug(1000, "out-> NULL detect");
     747                err("NULL detect");
    779748                return;
    780749        }
    … …  
    880849        fesetvoltage(node, oldvolt, 15);
    881850        fesettone(node, oldtone, 15);
    882        
    883         debug(1000, "out");
    884851}
    885852
    … …  
    892859        if(node == NULL)
    893860        {
    894                 debug(1000, "out-> NULL detect");
     861                err("NULL detect");
    895862                return;
    896863        }
    … …  
    951918void fediseqcset(struct dvbdev* node, struct transponder* tpnode)
    952919{
    953         debug(1000, "in");
    954920        char* tmpstr = NULL;
    955921        int toneburst = 0, cmdorder = 0, input = 0, uinput = 0, diseqmode = 0, rotorpos = 0, latpos = 0, longpos = 0;
    … …  
    11161082                fediseqcrotor(node, tpnode, rotorpos, 11);
    11171083        }
    1118 
    1119         debug(1000, "out");
    11201084}
    11211085
    11221086void feset(struct dvbdev* node, struct transponder* tpnode)
    11231087{
    1124         debug(1000, "in");
    11251088        int voltagemode = 0, tonemode = 0;
    11261089        fe_sec_tone_mode_t tone;
    … …  
    11311094        if(node == NULL)
    11321095        {
    1133                 debug(1000, "out-> NULL detect");
     1096                err("NULL detect");
    11341097                return;
    11351098        }
    … …  
    11831146        }
    11841147        fesettone(node, tone, 15);
    1185         debug(1000, "out");
    11861148}
    11871149
    11881150void fediscard(struct dvbdev* node)
    11891151{
    1190         debug(1000, "in");
    11911152        struct dvb_frontend_event ev;
    11921153        int count = 0;
    … …  
    11941155        if(node == NULL)
    11951156        {
    1196                 debug(1000, "out-> NULL detect");
     1157                err("NULL detect");
    11971158                return;
    11981159        }
    … …  
    12051166                        break;
    12061167        }
    1207 
    1208         debug(1000, "out");
    12091168}
    12101169
    12111170uint16_t fereadsnr(struct dvbdev* node)
    12121171{
    1213         debug(1000, "in");
    12141172        uint16_t snr = 0;
    12151173
    12161174        if(node == NULL)
    12171175        {
    1218                 debug(1000, "out-> NULL detect");
     1176                err("NULL detect");
    12191177                return 0;
    12201178        }
    … …  
    12221180        ioctl(node->fd, FE_READ_SNR, &snr);
    12231181        debug(200, "frontend snr = %02x", (snr * 100) / 0xffff);
    1224         debug(1000, "out");
    12251182        return snr;
    12261183}
    … …  
    12281185uint16_t fereadsignalstrength(struct dvbdev* node)
    12291186{
    1230         debug(1000, "in");
    12311187        uint16_t signal = 0;
    12321188
    12331189        if(node == NULL)
    12341190        {
    1235                 debug(1000, "out-> NULL detect");
     1191                err("NULL detect");
    12361192                return 0;
    12371193        }
    … …  
    12391195        ioctl(node->fd, FE_READ_SIGNAL_STRENGTH, &signal);
    12401196        debug(200, "frontend signal = %02x", (signal * 100) / 0xffff);
    1241         debug(1000, "out");
    12421197        return signal;
    12431198}
    … …  
    12451200uint32_t fereadber(struct dvbdev* node)
    12461201{
    1247         debug(1000, "in");
    12481202        uint32_t ber = 0;
    12491203
    12501204        if(node == NULL)
    12511205        {
    1252                 debug(1000, "out-> NULL detect");
     1206                err("NULL detect");
    12531207                return 0;
    12541208        }
    … …  
    12561210        ioctl(node->fd, FE_READ_BER, &ber);
    12571211        debug(200, "frontend ber = %02x", ber);
    1258         debug(1000, "out");
    12591212        return ber;
    12601213}
    … …  
    12621215uint32_t fereaduncorrectedblocks(struct dvbdev* node)
    12631216{
    1264         debug(1000, "in");
    12651217        uint32_t unc = 0;
    12661218
    12671219        if(node == NULL)
    12681220        {
    1269                 debug(1000, "out-> NULL detect");
     1221                err("NULL detect");
    12701222                return 0;
    12711223        }
    … …  
    12731225        ioctl(node->fd, FE_READ_UNCORRECTED_BLOCKS, &unc);
    12741226        debug(200, "frontend unc = %02x", unc);
    1275         debug(1000, "out");
    12761227        return unc;
    12771228}
    … …  
    12791230fe_status_t fereadstatus(struct dvbdev* node)
    12801231{
    1281         debug(1000, "in");
    12821232        fe_status_t status;
    12831233
    12841234        if(node == NULL)
    12851235        {
    1286                 debug(1000, "out-> NULL detect");
     1236                err("NULL detect");
    12871237                return -1;
    12881238        }
    … …  
    13001250        if(status & FE_REINIT) debug(200, "frontend = FE_REINIT");
    13011251
    1302         debug(1000, "out");
    13031252        return status;
    13041253}
    … …  
    13061255void fetunedvbs(struct dvbdev* node, struct transponder* tpnode)
    13071256{
    1308         debug(1000, "in");
    13091257        if(node == NULL || tpnode == NULL)
    13101258        {
    1311                 debug(1000, "out-> NULL detect");
     1259                err("NULL detect");
    13121260                return;
    13131261        }
    … …  
    14371385        }
    14381386#endif
    1439         debug(1000, "out");
    14401387}
    14411388
    14421389void fetunedvbc(struct dvbdev* node, struct transponder* tpnode)
    14431390{
    1444         debug(1000, "in");
    1445 
    14461391        if(node == NULL || tpnode == NULL)
    14471392        {
    1448                 debug(1000, "out-> NULL detect");
     1393                err("NULL detect");
    14491394                return;
    14501395        }
    … …  
    15201465        }
    15211466#endif
    1522         debug(1000, "out");
    15231467}
    15241468
    15251469void fetunedvbt(struct dvbdev* node, struct transponder* tpnode)
    15261470{
    1527         debug(1000, "in");
    15281471        struct dvb_frontend_parameters tuneto;
    15291472
    15301473        if(node == NULL || tpnode == NULL)
    15311474        {
    1532                 debug(1000, "out-> NULL detect");
     1475                err("NULL detect");
    15331476                return;
    15341477        }
    … …  
    16251568                perr("FE_SET_FRONTEND");
    16261569        }
    1627         debug(1000, "out");
    16281570}
    16291571
    … …  
    16331575struct dvb_frontend_info* fegetinfo(struct dvbdev* node, int fd)
    16341576{
    1635         debug(1000, "in");
    16361577        struct dvb_frontend_info* feinfo = NULL;
    16371578        int tmpfd = -1;
    … …  
    16701611        }
    16711612#endif
    1672         debug(1000, "out");
    16731613        return feinfo;
    16741614}
    … …  
    16761616int fegetdev()
    16771617{
    1678         debug(1000, "in");
    16791618        int i, y, fd = -1, count = 0;
    16801619        char *buf = NULL, *frontenddev = NULL;
    … …  
    16851624        if(frontenddev == NULL)
    16861625        {
    1687                 debug(1000, "out -> NULL detect");
     1626                err("NULL detect");
    16881627                return count;
    16891628        }
    … …  
    17171656
    17181657        free(buf);
    1719         debug(1000, "out");
    17201658        return count;
    17211659}
    … …  
    17301668        if(frontenddev == NULL)
    17311669        {
    1732                 debug(1000, "out -> NULL detect");
     1670                err("NULL detect");
    17331671                return 1;
    17341672        }
Note: See TracChangeset for help on using the changeset viewer.