Changeset 102:56b64e332c99

Show
Ignore:
Timestamp:
11/24/06 11:37:07 (2 years ago)
Author:
emilie@TULEAR
Message:

new lib webcam with pixertool changes

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • .hgignore

    r24 r102  
    1414.lib$ 
    1515linux/debug/ 
     16win32/debug/ 
    1617sconsign 

  • libs/pixertool/SConscript

    r40 r102  
    55libs = [ 
    66        'owcutil', 
    7         'owutil', 
     7        #'owutil', 
    88        'avcodec', 
    9         'avutil' 
     9       #'avutil' 
    1010         
    1111] 
    …… 
    1818] 
    1919sources = [ 
    20         'src/pixertool.cpp', 
     20        'src/pixertool.c', 
    2121        'src/ffmpeg/ffmpeg-pixertool.c', 
    2222] 
    …… 
    3333 
    3434else: 
    35         sources += ['src/null-pixertool.cpp'] 
     35        sources += ['src/null-pixertool.c'] 
    3636 
    3737 
    …… 
    3939   pxl = BJ.Library(env, target = 'pixertool',  
    4040            source = sources,  
    41             uses = ["owutil", "owcutil", "avcodec", "avutil"], 
     41            uses = ["owcutil", "avcodec", "avutil"], 
    4242            includes = ["#/libs/pixertool/include"], 
    4343            CPPPATH = include_path, CPPDEFINES = defines 
    …… 
    5555   pxl = env.StaticLibrary('pixertool', source = pxo) 
    5656 
    57    BJ.Component('pixertool', uses = ["owutil", "owcutil", "avcodec", "avutil"], 
     57   BJ.Component('pixertool', uses = ["owcutil", "avcodec", "avutil"], 
    5858            includes = ["#/libs/pixertool/include"]) 
    5959 

  • libs/timer/SConscript

    r40 r99  
    2424 
    2525 
    26 env.Append(CCPDEFINES = defines, CPPPATH = include_path) 
     26env.Append(CPPDEFINES = defines, CPPPATH = include_path) 
    2727 
    2828if env['shared_phapi']: 

  • libs/webcam/SConscript

    r40 r102  
    33env = BJ.NewEnv() 
    44 
    5  
    6 libs = [ 
    7         'owutil', 
    8         'pixertool', 
     5libs = [  
     6          'pixertool' 
    97] 
    108 
    11 #if GlobalOSLinux() or GlobalOSMacOSX(): 
    12 if BJ.osxTarget: 
    13         libs.append('owthread') 
     9defines = {} 
    1410 
    1511include_path = [ 
    16         'include' 
     12        'include', 
    1713] 
    1814 
    1915headers = [ 
    20         'include/WebcamDriver.h', 
    21         'include/WebcamDriverFactory.h', 
     16        'include/webcamdriver.h', 
    2217        'include/webcam.h', 
    23         'include/IWebcamDriver.h', 
    24         'include/NullWebcamDriverFactory.h', 
    25         'include/DefaultWebcamDriverFactory.h', 
     18        'include/wbc_debug.h' 
    2619] 
    2720 
    2821sources = [ 
    29         'src/WebcamDriver.cpp', 
    30         'src/webcam.cpp', 
    31         'src/null/NullWebcamDriver.cpp', 
    3222] 
     23 
     24         
     25         
     26env.ParseConfig('sdl-config --cflags --libs') 
    3327 
    3428if BJ.msvc: 
    3529        headers += [ 
    36                 'include/DirectXWebcamDriverFactory.h', 
    37                 'include/DirectXWebcamDriver.h', 
    38                 'include/DirectXWebcamUtils.h' 
     30                'include/directx/directxwebcamdriver.h', 
     31                'include/directx/directxwebcamutils.h' 
    3932        ] 
    4033        sources += [ 
    41                 'src/directx/DirectXWebcamDriver.cpp', 
    42                 'src/directx/DirectXWebcamUtils.cpp' 
    43         ] 
     34                'src/directx/directxwebcamdriver.cpp', 
     35                'src/directx/directxwebcamutils.cpp', 
     36                'src/webcam.cpp' 
     37] 
    4438        libs += ["winmm", "strmiids", "comsupp"] 
     39         
     40        defines["CC_MSVC"] = 1 
     41 
     42 
    4543 
    4644if BJ.linuxTarget: 
     45        libs = [  
     46                        'pthread', 
     47                        'm' 
     48        ] 
    4749        headers += [ 
    48                 'include/V4LWebcamDriverFactory.h', 
    49                 'src/v4l/V4LWebcamDriver.h' 
     50                'src/v4l/v4lwebcamdriver.h', 
     51                'include/v4l/util.h', 
    5052        ] 
    5153        sources += [ 
    52                 'src/v4l/V4LWebcamDriver.cpp' 
     54                'src/v4l/v4lwebcamdriver.c', 
     55                'src/v4l/util.c', 
     56                'src/webcam.c' 
    5357        ] 
     58 
     59        defines["OS_LINUX"] = 1 
     60 
    5461 
    5562if BJ.osxTarget: 
    5663        headers += [ 
    57                 'include/QuicktimeWebcamDriverFactory.h', 
    58                 'src/quicktime/QuicktimeWebcamDriver.h' 
     64                'include/quicktime/QuicktimeWebcamDriver.h' 
    5965        ] 
     66         
    6067        sources += [ 
    6168                'src/quicktime/QuicktimeWebcamDriver.cpp' 
     69                'src/webcam.cpp' 
    6270        ] 
     71         
    6372        include_path += [ 
    6473                '/System/Library/Frameworks/Quicktime.framework/Headers' 
    6574        ] 
     75         
     76        libs.append('owthread') 
     77         
     78        defines["OS_MACOSX"] = 1 
    6679 
    6780 
    68 env.Append(CPPPATH = include_path) 
     81 
     82env.Append(CPPPATH = include_path, CPPDEFINES = defines) 
    6983BJ.Use(env, libs)  
    7084 

  • libs/webcam/include/webcam.h

    r0 r102  
    2222 
    2323#include <pixertool.h> 
     24#include <string.h> 
    2425 
    2526/*TODO: add function to set factory*/ 
    …… 
    4647 
    4748typedef struct { 
    48         unsigned count; 
     49        int count; 
    4950        const char ** name; 
    5051} webcamdevicelist; 
    …… 
    8485 * @see IWebcamDriver::getDeviceList() 
    8586 */ 
    86 webcamdevicelist * webcam_get_device_list(webcam *); 
     87webcamdevicelist * webcam_get_device_list(void); 
    8788 
    8889/** 
    …… 
    9798 * @see IWebcamDriver::getDefaultDevice() 
    9899 */ 
    99 const char * webcam_get_default_device(webcam *); 
     100const char * webcam_get_default_device(webcam * wc); 
    100101 
    101102 
    …… 
    107108 * @return the new webcam 
    108109 */ 
    109 webcam * webcam_get_instance(); 
     110//webcam * webcam_get_instance(); 
     111webcam *webcam_open(char *name); 
     112 
    110113 
    111114/** 
    112115 * @see IWebcamDriver::setFlags(int flags) 
    113116 */ 
    114 void webcam_set_flags(webcam *wc, int flags); 
     117void webcam_set_flags(webcam *wc, int flags) ; 
    115118 
    116119 
    …… 
    253256 */ 
    254257int webcam_get_contrast(webcam *wc); 
    255  
    256258 
    257259#ifdef __cplusplus 

  • libs/webcam/src/webcam.cpp

    r5 r102  
    1818 */ 
    1919 
    20 #include <webcam/webcam.h> 
    21  
    22 #include <webcam/WebcamDriver.h> 
    23  
    24 using namespace std; 
    25  
    26 typedef struct _webcamcallbacklist { 
     20#include <webcam.h> 
     21#include <webcamdriver.h> 
     22 
     23#if defined (CC_MSVC) 
     24#include <directx/directxwebcamdriver.h> 
     25 
     26#elif defined (OS_LINUX) 
     27#include <v4l/v4lwebcamdriver.h> 
     28 
     29#elif defined (OS_MACOSX) 
     30#include <nullwebcamdriver.h> 
     31 
     32#else 
     33#include <nullwebcamdriver.h> 
     34 
     35#endif 
     36 
     37 
     38//using namespace std; 
     39 
     40typedef struct _webcamcallbacklist webcamcallbacklist; 
     41struct _webcamcallbacklist  
     42{ 
    2743        /** sender */ 
    2844        webcam * wc; 
    …… 
    3248        void * data; 
    3349        /** Link to previous and next callback. Linked list */ 
    34         _webcamcallbacklist *prev, *next; 
    35 } webcamcallbacklist; 
    36  
    37 struct opaquewebcam { 
    38         WebcamDriver * driver; 
     50        webcamcallbacklist *prev, *next; 
     51}; 
     52 
     53struct opaquewebcam  
     54{ 
     55        WebcamDriver *driver; 
     56        void *context; 
    3957}; 
    4058 
    …… 
    4260static webcamcallbacklist * cbks = NULL; 
    4361 
    44 static void webcam_frame_captured_event_handler(IWebcamDriver *sender, piximage *image) { 
     62//static  
     63void webcam_frame_captured_event_handler(WebcamDriver *driver, piximage *image)  
     64{ 
    4565        webcamcallbacklist * cur = cbks; 
    4666 
    …… 
    5171} 
    5272 
    53 webcamdevicelist * webcam_get_device_list(webcam *) { 
    54         IWebcamDriver * driver = WebcamDriver::getInstance(); 
    55         StringList deviceList = driver->getDeviceList(); 
     73webcamdevicelist * webcam_get_device_list()   
     74{ 
     75        int i,j; 
     76         
     77        ArrayDevice *devName = getDevices(); 
     78        ArrayDevice *Array_Device = devName; 
    5679        webcamdevicelist *devlist = (webcamdevicelist *)malloc(sizeof(webcamdevicelist)); 
    5780 
    58         devlist->count = deviceList.size(); 
    59         devlist->name = (const char **)malloc(devlist->count * sizeof(const char *)); 
    60  
    61         for (register unsigned i = 0; i < devlist->count; i++) { 
    62                 devlist->name[i] = (const char *)malloc(deviceList[i].size()); 
    63                 sprintf((char *) devlist->name[i], deviceList[i].c_str(), deviceList[i].size()); 
     81        devlist->count = sizeof_deviceList(devName); 
     82        devlist->name = (const char **) malloc(devlist->count * sizeof(const char*)); 
     83 
     84        for (i = 0; i < devlist->count; i++)  
     85        { 
     86                if (i!=0) 
     87                        Array_Device = Array_Device->next; 
     88 
     89                j = strlen(Array_Device->device); 
     90                devlist->name[i] = (char *)malloc(j*sizeof(char)); 
     91                sprintf((char *) devlist->name[i], Array_Device->device, sizeof(Array_Device->device)); 
    6492        } 
    6593 
    …… 
    6795} 
    6896 
    69 void webcam_release_webcamdevicelist(webcamdevicelist *devlist) { 
    70         if (devlist) { 
    71                 if (devlist->name) { 
    72                         for (register unsigned i = 0; i < devlist->count; i++) { 
    73                                 if (devlist->name[i]) { 
     97void webcam_release_webcamdevicelist(webcamdevicelist *devlist)  
     98{ 
     99        int i; 
     100        if (devlist)  
     101        { 
     102                if (devlist->name)  
     103                { 
     104                        for (i = 0; i < devlist->count; i++)  
     105                        { 
     106                                if (devlist->name[i])  
     107                                { 
    74108                                        free((void *) devlist->name[i]); 
    75109                                } 
    …… 
    81115} 
    82116 
    83 const char * webcam_get_default_device(webcam *) { 
    84         IWebcamDriver * driver = WebcamDriver::getInstance(); 
    85         static string device; 
    86  
    87         device = driver->getDefaultDevice(); 
    88  
    89         return device.c_str(); 
    90 } 
    91  
    92 webcam * webcam_get_instance() { 
     117const char * webcam_get_default_device(webcam * wc)  
     118{ 
     119        static const char* device; 
     120 
     121        device = wc->driver->getDefaultDevice(); 
     122 
     123        return device; 
     124} 
     125 
     126/* 
     127webcam * webcam_get_instance()  
     128{ 
    93129        webcam * wc = (webcam *) malloc(sizeof(webcam)); 
    94130 
    …… 
    99135        return wc; 
    100136} 
    101  
    102 void webcam_set_flags(webcam * wc, int flags) { 
    103         wc->driver->setFlags(flags); 
    104 } 
    105  
    106 void webcam_unset_flags(webcam * wc, int flags) { 
    107         wc->driver->unsetFlags(flags); 
    108 } 
    109  
    110 int webcam_is_flag_set(webcam * wc, int flag) { 
    111         if (wc->driver->isFlagSet(flag)) { 
     137*/ 
     138 
     139 
     140webcam *webcam_open(char *name) 
     141{ 
     142        webcam *wc; 
     143        wc =  (webcam *)malloc(sizeof(webcam)); 
     144#if defined (OS_LINUX) 
     145        if (!strncmp(name,"v4l", 3)) 
     146        { 
     147                wc->driver = v4ldriver; 
     148                wc->context = v4ldriver->openwebcam(name,webcam_frame_captured_event_handler); 
     149        } 
     150#elif defined (CC_MSVC) 
     151        if (!strncmp(name,"directx", 7)) 
     152        { 
     153                wc->driver = directxdriver; 
     154                wc->context = directxdriver->openwebcam(name, &webcam_frame_captured_event_handler); 
     155                 
     156        } 
     157#elif defined (OS_MACOSX) 
     158        if (!strncmp(name,"quicktime", 9)) 
     159        { 
     160                wc->driver = quicktimedriver; 
     161                wc->context = quicktimedriver->openwebcam(name,webcam_frame_captured_event_handler); 
     162 
     163        } 
     164         
     165#else 
     166        { 
     167                name = strdup("null"); 
     168                wc->driver = nulldriver; 
     169                wc->context = nulldriver->openwebcam(name, webcam_frame_captured_event_handler); 
     170        } 
     171#endif           
     172        return wc; 
     173} 
     174 
     175 
     176 
     177void webcam_set_flags(webcam * wc, int flags)  
     178{ 
     179        wc->driver->setFlags(wc->context, flags); 
     180} 
     181 
     182void webcam_unset_flags(webcam * wc, int flags)  
     183{ 
     184        wc->driver->unsetFlags(wc->context, flags); 
     185} 
     186 
     187int webcam_is_flag_set(webcam * wc, int flag)  
     188{ 
     189        if (wc->driver->isFlagSet(wc->context, flag))  
     190        { 
    112191                return 1; 
    113         } else { 
     192        }  
     193        else 
     194        { 
    114195                return 0; 
    115196        } 
    116197} 
    117198 
    118 void webcam_release(webcam * wc) { 
     199void webcam_release(webcam * wc) 
     200{ 
    119201        webcamcallbacklist *nxt, *cur; 
    120202 
    121203        webcam_stop_capture(wc); 
    122         if (wc) { 
     204        if (wc)  
     205        { 
    123206                free(wc); 
    124207 
    125208                cur = cbks; 
    126                 while(cur) { 
     209                while(cur)  
     210                {        
    127211                        nxt = cur->next; 
    128212                        free(cur); 
    …… 
    130214                } 
    131215                cbks = NULL; 
    132         } 
    133 } 
    134  
    135 webcamerrorcode webcam_set_device(webcam * wc, const char * device_name) { 
    136         return wc->driver->setDevice(device_name); 
    137 } 
    138  
    139 void webcam_add_callback(webcam * wc, webcamcallback * callback, void * userData) { 
     216                 
     217        } 
     218} 
     219 
     220webcamerrorcode webcam_set_device(webcam * wc, const char * device_name)  
     221{ 
     222 
     223        return wc->driver->setDevice(wc->context, "Logitech QuickCam Pro 4000"); 
     224         
     225} 
     226 
     227void webcam_add_callback(webcam * wc, webcamcallback * callback, void * userData)  
     228{ 
    140229        webcamcallbacklist *cur; 
    141  
    142         if (cbks == NULL) { 
     230        if (cbks == NULL)  
     231        { 
    143232                cbks = (webcamcallbacklist *) malloc(sizeof(webcamcallbacklist)); 
    144233                cbks->prev = NULL; 
    145234                cbks->next = NULL; 
    146235                cur = cbks; 
    147         } else { 
     236        }  
     237        else  
     238        { 
    148239                //Find last 
    149240                cur = cbks; 
    150                 while (cur->next != NULL) { 
     241                while (cur->next != NULL)  
     242                {        
    151243                        cur = cur->next; 
    152244                } 
    …… 
    162254} 
    163255 
    164 void webcam_remove_callback(webcam * wc, webcamcallback * callback) { 
     256void webcam_remove_callback(webcam * wc, webcamcallback * callback) 
     257{ 
    165258        webcamcallbacklist * cur = cbks; 
    166259 
    167         while ((cur != NULL) && (cur->cbk != callback)) { 
     260        while ((cur != NULL) && (cur->cbk != callback))  
     261        { 
    168262                cur = cur->next; 
    169263        } 
    170264 
    171         if (cur != NULL) { 
     265        if (cur != NULL)  
     266        { 
    172267                cur->prev->next = cur->next; 
    173                 if (cur->next) { 
     268                if (cur->next)  
     269                { 
    174270                        cur->next->prev = cur->prev; 
    175271                } 
    …… 
    178274} 
    179275 
    180 void webcam_start_capture(webcam * wc) { 
    181         wc->driver->startCapture(); 
    182 } 
    183  
    184 void webcam_pause_capture(webcam * wc) { 
    185         wc->driver->pauseCapture(); 
    186 } 
    187  
    188 void webcam_stop_capture(webcam *wc) { 
    189         wc->driver->stopCapture(); 
    190 } 
    191  
    192 unsigned webcam_get_width(webcam * wc) { 
    193         return wc->driver->getWidth(); 
    194 } 
    195  
    196 unsigned webcam_get_height(webcam * wc) { 
    197         return wc->driver->getHeight(); 
    198 } 
    199  
    200 pixosi webcam_get_palette(webcam * wc) { 
    201         return wc->driver->getPalette(); 
    202 } 
    203  
    204 webcamerrorcode webcam_set_palette(webcam * wc, pixosi palette) { 
    205         return wc->driver->setPalette(palette); 
    206 } 
    207  
    208 int webcam_is_opened(webcam * wc) { 
    209         if (wc->driver->isOpened()) { 
     276void webcam_start_capture(webcam * wc)  
     277{ 
     278        wc->driver->startCapture(wc->context); 
     279} 
     280 
     281void webcam_pause_capture(webcam * wc)  
     282{ 
     283        wc->driver->pauseCapture(wc->context); 
     284} 
     285 
     286void webcam_stop_capture(webcam *wc)  
     287{ 
     288        wc->driver->stopCapture(wc->context); 
     289} 
     290 
     291unsigned webcam_get_width(webcam * wc)  
     292{ 
     293        return wc->driver->getWidth(wc->context); 
     294} 
     295 
     296unsigned webcam_get_height(webcam * wc)  
     297{ 
     298        return wc->driver->getHeight(wc->context); 
     299} 
     300 
     301pixosi webcam_get_palette(webcam * wc)  
     302{ 
     303        return wc->driver->getPalette(wc->context); 
     304} 
     305 
     306webcamerrorcode webcam_set_palette(webcam * wc, pixosi palette)  
     307{ 
     308        return wc->driver->setPalette(wc->context, palette); 
     309} 
     310 
     311int webcam_is_opened(webcam * wc)  
     312{ 
     313        if (wc->driver->isOpened(wc->context))  
     314        { 
    210315                return 1; 
    211         } else { 
     316        }  
     317        else  
     318        { 
    212319                return 0; 
    213320        } 
    214321} 
    215322 
    216 webcamerrorcode webcam_set_fps(webcam * wc, unsigned fps) { 
    217         return wc->driver->setFPS(fps); 
    218 } 
    219  
    220 unsigned webcam_get_fps(webcam * wc) { 
    221         return wc->driver->getFPS(); 
    222 } 
    223  
    224 void webcam_set_resolution(webcam * wc, unsigned width, unsigned height) { 
    225         wc->driver->setResolution(width, height); 
    226 } 
    227  
    228 void webcam_flip_horizontally(webcam * wc, int flip) { 
    229         if (flip) { 
    230                 wc->driver->flipHorizontally(true); 
    231         } else { 
    232                 wc->driver->flipHorizontally(false); 
    233         } 
    234 } 
    235  
    236 void webcam_set_brightness(webcam * wc, int brightness) { 
    237         wc->driver->setBrightness(brightness); 
    238 } 
    239  
    240 int webcam_get_brightness(webcam * wc) { 
    241         return wc->driver->getBrightness(); 
    242 } 
    243  
    244 void webcam_set_contrast(webcam * wc, int contrast) { 
    245         wc->driver->setContrast(contrast); 
    246 } 
    247  
    248 int webcam_get_contrast(webcam * wc) { 
    249         return wc->driver->getContrast(); 
    250 } 
     323webcamerrorcode webcam_set_fps(webcam * wc, unsigned fps)  
     324{ 
     325        return wc->driver->setFPS(wc->context, fps); 
     326} 
     327 
     328unsigned webcam_get_fps(webcam * wc)  
     329{ 
     330        return wc->driver->getFPS(wc->context); 
     331} 
     332//****************** 
     333void webcam_set_resolution(webcam * wc, unsigned width, unsigned height)  
     334{ 
     335        wc->driver->setResolution(wc->context, width, height); 
     336} 
     337 
     338void webcam_flip_horizontally(webcam * wc, int flip)  
     339{ 
     340        if (flip)  
     341        { 
     342                wc->driver->flipHorizontally(wc->context, 1); 
     343        }  
     344        else  
     345        { 
     346                wc->driver->flipHorizontally(wc->context, 0); 
     347        } 
     348} 
     349 
     350void webcam_set_brightness(webcam * wc, int brightness)  
     351{ 
     352        wc->driver->setBrightness(wc->context, brightness); 
     353} 
     354 
     355int webcam_get_brightness(webcam * wc)  
     356{ 
     357        return wc->driver->getBrightness(wc->context); 
     358} 
     359 
     360void webcam_set_contrast(webcam * wc, int contrast)  
     361{ 
     362        wc->driver->setContrast(wc->context, contrast); 
     363} 
     364 
     365int webcam_get_contrast(webcam * wc)  
     366{ 
     367        return wc->driver->getContrast(wc->context); 
     368} 
     369 
     370