Ticket #1804: vlc-0.9.3-libv4l2.patch

File vlc-0.9.3-libv4l2.patch, 26.4 kB (added by jwrdegoede, 3 weeks ago)

PATCH: use libv4l2 in v4l2 plugin

  • vlc-0.9.3/configure.ac

    old new  
    24212421    AC_DEFINE(HAVE_ALSA, 1, Define if ALSA is present.) 
    24222422  fi 
    24232423 
     2424  VLC_ADD_LDFLAGS([v4l2],[-lv4l2]) 
    24242425  CPPFLAGS="${CPPFLAGS_save} ${CPPFLAGS_v4l2}" 
    24252426  AC_CHECK_HEADERS(linux/videodev2.h, [ 
    24262427    VLC_ADD_PLUGIN([v4l2]) 
  • vlc-0.9.3/modules/access/v4l2/v4l2.c

    old new  
    6767 
    6868#include <poll.h> 
    6969 
     70#include <libv4l2.h> 
     71 
    7072/***************************************************************************** 
    7173 * Module descriptior 
    7274 *****************************************************************************/ 
     
    11081110                buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
    11091111                buf.memory = ( p_sys->io == IO_METHOD_USERPTR ) ? 
    11101112                    V4L2_MEMORY_USERPTR : V4L2_MEMORY_MMAP; 
    1111                 ioctl( p_sys->i_fd_video, VIDIOC_DQBUF, &buf ); /* ignore result */ 
     1113                v4l2_ioctl( p_sys->i_fd_video, VIDIOC_DQBUF, &buf ); /* ignore result */ 
    11121114            } 
    11131115 
    11141116            buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
    1115             if( ioctl( p_sys->i_fd_video, VIDIOC_STREAMOFF, &buf_type ) < 0 ) { 
     1117            if( v4l2_ioctl( p_sys->i_fd_video, VIDIOC_STREAMOFF, &buf_type ) < 0 ) { 
    11161118                msg_Err( p_this, "VIDIOC_STREAMOFF failed" ); 
    11171119            } 
    11181120 
     
    11311133        case IO_METHOD_MMAP: 
    11321134            for( i = 0; i < p_sys->i_nbuffers; ++i ) 
    11331135            { 
    1134                 if( munmap( p_sys->p_buffers[i].start, p_sys->p_buffers[i].length ) ) 
     1136                if( v4l2_munmap( p_sys->p_buffers[i].start, p_sys->p_buffers[i].length ) ) 
    11351137                { 
    11361138                    msg_Err( p_this, "munmap failed" ); 
    11371139                } 
     
    11551157{ 
    11561158    (void)p_this; 
    11571159    /* Close */ 
    1158     if( p_sys->i_fd_video >= 0 ) close( p_sys->i_fd_video ); 
     1160    if( p_sys->i_fd_video >= 0 ) v4l2_close( p_sys->i_fd_video ); 
    11591161#ifdef HAVE_ALSA 
    11601162    if( p_sys->p_alsa_pcm ) 
    11611163    { 
     
    13501352        return -1; 
    13511353    } 
    13521354 
    1353     i_ret = read( p_sys->i_fd_video, p_buffer, i_len ); 
     1355    i_ret = v4l2_read( p_sys->i_fd_video, p_buffer, i_len ); 
    13541356    if( i_ret == 0 ) 
    13551357    { 
    13561358        p_access->info.b_eof = true; 
     
    14191421    switch( p_sys->io ) 
    14201422    { 
    14211423    case IO_METHOD_READ: 
    1422         i_ret = read( p_sys->i_fd_video, p_sys->p_buffers[0].start, p_sys->p_buffers[0].length ); 
     1424        i_ret = v4l2_read( p_sys->i_fd_video, p_sys->p_buffers[0].start, p_sys->p_buffers[0].length ); 
    14231425        if( i_ret == -1 ) 
    14241426        { 
    14251427            switch( errno ) 
     
    14461448        buf.memory = V4L2_MEMORY_MMAP; 
    14471449 
    14481450        /* Wait for next frame */ 
    1449         if (ioctl( p_sys->i_fd_video, VIDIOC_DQBUF, &buf ) < 0 ) 
     1451        if (v4l2_ioctl( p_sys->i_fd_video, VIDIOC_DQBUF, &buf ) < 0 ) 
    14501452        { 
    14511453            switch( errno ) 
    14521454            { 
     
    14701472        if( !p_block ) return 0; 
    14711473 
    14721474        /* Unlock */ 
    1473         if( ioctl( p_sys->i_fd_video, VIDIOC_QBUF, &buf ) < 0 ) 
     1475        if( v4l2_ioctl( p_sys->i_fd_video, VIDIOC_QBUF, &buf ) < 0 ) 
    14741476        { 
    14751477            msg_Err (p_demux, "Failed to unlock (VIDIOC_QBUF)"); 
    14761478            return 0; 
     
    14841486        buf.memory = V4L2_MEMORY_USERPTR; 
    14851487 
    14861488        /* Wait for next frame */ 
    1487         if (ioctl( p_sys->i_fd_video, VIDIOC_DQBUF, &buf ) < 0 ) 
     1489        if (v4l2_ioctl( p_sys->i_fd_video, VIDIOC_DQBUF, &buf ) < 0 ) 
    14881490        { 
    14891491            switch( errno ) 
    14901492            { 
     
    15171519        if( !p_block ) return 0; 
    15181520 
    15191521        /* Unlock */ 
    1520         if( ioctl( p_sys->i_fd_video, VIDIOC_QBUF, &buf ) < 0 ) 
     1522        if( v4l2_ioctl( p_sys->i_fd_video, VIDIOC_QBUF, &buf ) < 0 ) 
    15211523        { 
    15221524            msg_Err (p_demux, "Failed to unlock (VIDIOC_QBUF)"); 
    15231525            return 0; 
     
    17051707    req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
    17061708    req.memory = V4L2_MEMORY_MMAP; 
    17071709 
    1708     if( ioctl( i_fd, VIDIOC_REQBUFS, &req ) < 0 ) 
     1710    if( v4l2_ioctl( i_fd, VIDIOC_REQBUFS, &req ) < 0 ) 
    17091711    { 
    17101712        msg_Err( p_demux, "device does not support mmap i/o" ); 
    17111713        goto open_failed; 
     
    17331735        buf.memory = V4L2_MEMORY_MMAP; 
    17341736        buf.index = p_sys->i_nbuffers; 
    17351737 
    1736         if( ioctl( i_fd, VIDIOC_QUERYBUF, &buf ) < 0 ) 
     1738        if( v4l2_ioctl( i_fd, VIDIOC_QUERYBUF, &buf ) < 0 ) 
    17371739        { 
    17381740            msg_Err( p_demux, "VIDIOC_QUERYBUF" ); 
    17391741            goto open_failed; 
     
    17411743 
    17421744        p_sys->p_buffers[p_sys->i_nbuffers].length = buf.length; 
    17431745        p_sys->p_buffers[p_sys->i_nbuffers].start = 
    1744             mmap( NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, i_fd, buf.m.offset ); 
     1746            v4l2_mmap( NULL, buf.length, PROT_READ | PROT_WRITE, MAP_SHARED, i_fd, buf.m.offset ); 
    17451747 
    17461748        if( p_sys->p_buffers[p_sys->i_nbuffers].start == MAP_FAILED ) 
    17471749        { 
     
    17741776    req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
    17751777    req.memory = V4L2_MEMORY_USERPTR; 
    17761778 
    1777     if( ioctl( i_fd, VIDIOC_REQBUFS, &req ) < 0 ) 
     1779    if( v4l2_ioctl( i_fd, VIDIOC_REQBUFS, &req ) < 0 ) 
    17781780    { 
    17791781        msg_Err( p_demux, "device does not support user pointer i/o" ); 
    17801782        return VLC_EGENERIC; 
     
    18301832    enum v4l2_buf_type buf_type; 
    18311833    char *psz_device = p_sys->psz_vdev; 
    18321834    es_format_t es_fmt; 
     1835    int libv4l2_fd; 
    18331836 
    18341837    if( ( i_fd = open( psz_device, O_RDWR ) ) < 0 ) 
    18351838    { 
     
    18371840        goto open_failed; 
    18381841    } 
    18391842 
     1843    /* Note the v4l2_xxx functions are designed so that if they get passed an 
     1844       unknown fd, the will behave exactly as their regular xxx counterparts, 
     1845       so if v4l2_fd_open fails, we continue as normal (missing the libv4l2 
     1846       custom cam format to normal formats conversion). Chances are big we will 
     1847       still fail then though, as normally v4l2_fd_open only fails if the 
     1848       device is not a v4l2 device. */ 
     1849    libv4l2_fd = v4l2_fd_open(i_fd, V4L2_ENABLE_ENUM_FMT_EMULATION); 
     1850    if (libv4l2_fd != -1) 
     1851        i_fd = libv4l2_fd; 
     1852 
    18401853    /* Tune the tuner */ 
    18411854    if( p_sys->i_frequency >= 0 ) 
    18421855    { 
     
    18501863        frequency.tuner = p_sys->i_cur_tuner; 
    18511864        frequency.type = p_sys->p_tuners[p_sys->i_cur_tuner].type; 
    18521865        frequency.frequency = p_sys->i_frequency / 62.5; 
    1853         if( ioctl( i_fd, VIDIOC_S_FREQUENCY, &frequency ) < 0 ) 
     1866        if( v4l2_ioctl( i_fd, VIDIOC_S_FREQUENCY, &frequency ) < 0 ) 
    18541867        { 
    18551868            msg_Err( p_obj, "cannot set tuner frequency (%m)" ); 
    18561869            goto open_failed; 
     
    18701883        memset( &tuner, 0, sizeof( tuner ) ); 
    18711884        tuner.index = p_sys->i_cur_tuner; 
    18721885        tuner.audmode = p_sys->i_audio_mode; 
    1873         if( ioctl( i_fd, VIDIOC_S_TUNER, &tuner ) < 0 ) 
     1886        if( v4l2_ioctl( i_fd, VIDIOC_S_TUNER, &tuner ) < 0 ) 
    18741887        { 
    18751888            msg_Err( p_obj, "cannot set tuner audio mode (%m)" ); 
    18761889            goto open_failed; 
     
    18821895 
    18831896    if( p_sys->i_selected_standard_id != V4L2_STD_UNKNOWN ) 
    18841897    { 
    1885         if( ioctl( i_fd, VIDIOC_S_STD, &p_sys->i_selected_standard_id ) < 0 ) 
     1898        if( v4l2_ioctl( i_fd, VIDIOC_S_STD, &p_sys->i_selected_standard_id ) < 0 ) 
    18861899        { 
    18871900            msg_Err( p_obj, "cannot set standard (%m)" ); 
    18881901            goto open_failed; 
     
    18981911        p_sys->i_selected_input = 0; 
    18991912    } 
    19001913 
    1901     if( ioctl( i_fd, VIDIOC_S_INPUT, &p_sys->i_selected_input ) < 0 ) 
     1914    if( v4l2_ioctl( i_fd, VIDIOC_S_INPUT, &p_sys->i_selected_input ) < 0 ) 
    19021915    { 
    19031916        msg_Err( p_obj, "cannot set input (%m)" ); 
    19041917        goto open_failed; 
     
    19151928            p_sys->i_selected_audio_input = 0; 
    19161929        } 
    19171930 
    1918         if( ioctl( i_fd, VIDIOC_S_AUDIO, &p_sys->p_audios[p_sys->i_selected_audio_input] ) < 0 ) 
     1931        if( v4l2_ioctl( i_fd, VIDIOC_S_AUDIO, &p_sys->p_audios[p_sys->i_selected_audio_input] ) < 0 ) 
    19191932        { 
    19201933            msg_Err( p_obj, "cannot set audio input (%m)" ); 
    19211934            goto open_failed; 
     
    19641977    /* Reset Cropping */ 
    19651978    memset( &cropcap, 0, sizeof(cropcap) ); 
    19661979    cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
    1967     if( ioctl( i_fd, VIDIOC_CROPCAP, &cropcap ) >= 0 ) 
     1980    if( v4l2_ioctl( i_fd, VIDIOC_CROPCAP, &cropcap ) >= 0 ) 
    19681981    { 
    19691982        crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
    19701983        crop.c = cropcap.defrect; /* reset to default */ 
    1971         if( ioctl( i_fd, VIDIOC_S_CROP, &crop ) < 0 ) 
     1984        if( v4l2_ioctl( i_fd, VIDIOC_S_CROP, &crop ) < 0 ) 
    19721985        { 
    19731986            switch( errno ) 
    19741987            { 
     
    19882001 
    19892002    if( p_sys->i_width <= 0 || p_sys->i_height <= 0 ) 
    19902003    { 
    1991         if( ioctl( i_fd, VIDIOC_G_FMT, &fmt ) < 0 ) 
     2004        if( v4l2_ioctl( i_fd, VIDIOC_G_FMT, &fmt ) < 0 ) 
    19922005        { 
    19932006            msg_Err( p_demux, "Cannot get default width and height." ); 
    19942007            goto open_failed; 
     
    20312044            } 
    20322045        } 
    20332046        /* Try and set user chroma */ 
    2034         if( !IsPixelFormatSupported( p_demux, fmt.fmt.pix.pixelformat ) || ( fmt.fmt.pix.pixelformat && ioctl( i_fd, VIDIOC_S_FMT, &fmt ) < 0 ) ) 
     2047        if( !IsPixelFormatSupported( p_demux, fmt.fmt.pix.pixelformat ) || ( fmt.fmt.pix.pixelformat && v4l2_ioctl( i_fd, VIDIOC_S_FMT, &fmt ) < 0 ) ) 
    20352048        { 
    20362049            msg_Warn( p_demux, "Driver is unable to use specified chroma %s. Trying defaults.", p_sys->psz_requested_chroma ); 
    20372050            fmt.fmt.pix.pixelformat = 0; 
     
    20472060        { 
    20482061            fmt.fmt.pix.pixelformat = p_chroma_fallbacks[i]; 
    20492062            if( IsPixelFormatSupported( p_demux, fmt.fmt.pix.pixelformat ) 
    2050              && ioctl( i_fd, VIDIOC_S_FMT, &fmt ) >= 0 ) 
     2063             && v4l2_ioctl( i_fd, VIDIOC_S_FMT, &fmt ) >= 0 ) 
    20512064                break; 
    20522065        } 
    20532066        if( i == ARRAY_SIZE( p_chroma_fallbacks ) ) 
     
    20922105    frmival.pixel_format = fmt.fmt.pix.pixelformat; 
    20932106    frmival.width = p_sys->i_width; 
    20942107    frmival.height = p_sys->i_height; 
    2095     if( ioctl( i_fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival ) >= 0 ) 
     2108    if( v4l2_ioctl( i_fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival ) >= 0 ) 
    20962109    { 
    20972110        char psz_fourcc[5]; 
    20982111        memset( &psz_fourcc, 0, sizeof( psz_fourcc ) ); 
     
    21082121                             frmival.discrete.numerator, 
    21092122                             frmival.discrete.denominator ); 
    21102123                    frmival.index++; 
    2111                 } while( ioctl( i_fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival ) >= 0 ); 
     2124                } while( v4l2_ioctl( i_fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival ) >= 0 ); 
    21122125                break; 
    21132126            case V4L2_FRMIVAL_TYPE_STEPWISE: 
    21142127                msg_Dbg( p_demux, "    supported frame intervals: %d/%d to " 
     
    21752188            buf.memory = V4L2_MEMORY_MMAP; 
    21762189            buf.index = i; 
    21772190 
    2178             if( ioctl( i_fd, VIDIOC_QBUF, &buf ) < 0 ) 
     2191            if( v4l2_ioctl( i_fd, VIDIOC_QBUF, &buf ) < 0 ) 
    21792192            { 
    21802193                msg_Err( p_demux, "VIDIOC_QBUF failed" ); 
    21812194                goto open_failed; 
     
    21832196        } 
    21842197 
    21852198        buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
    2186         if( ioctl( i_fd, VIDIOC_STREAMON, &buf_type ) < 0 ) 
     2199        if( v4l2_ioctl( i_fd, VIDIOC_STREAMON, &buf_type ) < 0 ) 
    21872200        { 
    21882201            msg_Err( p_demux, "VIDIOC_STREAMON failed" ); 
    21892202            goto open_failed; 
     
    22032216            buf.m.userptr = (unsigned long)p_sys->p_buffers[i].start; 
    22042217            buf.length = p_sys->p_buffers[i].length; 
    22052218 
    2206             if( ioctl( i_fd, VIDIOC_QBUF, &buf ) < 0 ) 
     2219            if( v4l2_ioctl( i_fd, VIDIOC_QBUF, &buf ) < 0 ) 
    22072220            { 
    22082221                msg_Err( p_demux, "VIDIOC_QBUF failed" ); 
    22092222                goto open_failed; 
     
    22112224        } 
    22122225 
    22132226        buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
    2214         if( ioctl( i_fd, VIDIOC_STREAMON, &buf_type ) < 0 ) 
     2227        if( v4l2_ioctl( i_fd, VIDIOC_STREAMON, &buf_type ) < 0 ) 
    22152228        { 
    22162229            msg_Err( p_demux, "VIDIOC_STREAMON failed" ); 
    22172230            goto open_failed; 
     
    22292242    return i_fd; 
    22302243 
    22312244open_failed: 
    2232     if( i_fd >= 0 ) close( i_fd ); 
     2245    if( i_fd >= 0 ) v4l2_close( i_fd ); 
    22332246    return -1; 
    22342247 
    22352248} 
     
    25482561    int i_standard; 
    25492562 
    25502563    int i_fd; 
     2564    int libv4l2_fd; 
    25512565 
    25522566    if( ( i_fd = open( psz_device, O_RDWR ) ) < 0 ) 
    25532567    { 
     
    25552569        goto open_failed; 
    25562570    } 
    25572571 
     2572    /* Note the v4l2_xxx functions are designed so that if they get passed an 
     2573       unknown fd, the will behave exactly as their regular xxx counterparts, 
     2574       so if v4l2_fd_open fails, we continue as normal (missing the libv4l2 
     2575       custom cam format to normal formats conversion). Chances are big we will 
     2576       still fail then though, as normally v4l2_fd_open only fails if the 
     2577       device is not a v4l2 device. */ 
     2578    libv4l2_fd = v4l2_fd_open(i_fd, V4L2_ENABLE_ENUM_FMT_EMULATION); 
     2579    if (libv4l2_fd != -1) 
     2580        i_fd = libv4l2_fd; 
     2581 
    25582582    /* Get device capabilites */ 
    25592583 
    2560     if( ioctl( i_fd, VIDIOC_QUERYCAP, &p_sys->dev_cap ) < 0 ) 
     2584    if( v4l2_ioctl( i_fd, VIDIOC_QUERYCAP, &p_sys->dev_cap ) < 0 ) 
    25612585    { 
    25622586        msg_Err( p_obj, "cannot get video capabilities (%m)" ); 
    25632587        goto open_failed; 
     
    25932617    { 
    25942618        struct v4l2_input t_input; 
    25952619        t_input.index = 0; 
    2596         while( ioctl( i_fd, VIDIOC_ENUMINPUT, &t_input ) >= 0 ) 
     2620        while( v4l2_ioctl( i_fd, VIDIOC_ENUMINPUT, &t_input ) >= 0 ) 
    25972621        { 
    25982622            p_sys->i_input++; 
    25992623            t_input.index = p_sys->i_input; 
     
    26062630        { 
    26072631            p_sys->p_inputs[i_index].index = i_index; 
    26082632 
    2609             if( ioctl( i_fd, VIDIOC_ENUMINPUT, &p_sys->p_inputs[i_index] ) ) 
     2633            if( v4l2_ioctl( i_fd, VIDIOC_ENUMINPUT, &p_sys->p_inputs[i_index] ) ) 
    26102634            { 
    26112635                msg_Err( p_obj, "cannot get video input characteristics (%m)" ); 
    26122636                goto open_failed; 
     
    26272651    { 
    26282652        struct v4l2_standard t_standards; 
    26292653        t_standards.index = 0; 
    2630         while( ioctl( i_fd, VIDIOC_ENUMSTD, &t_standards ) >=0 ) 
     2654        while( v4l2_ioctl( i_fd, VIDIOC_ENUMSTD, &t_standards ) >=0 ) 
    26312655        { 
    26322656            p_sys->i_standard++; 
    26332657            t_standards.index = p_sys->i_standard; 
     
    26402664        { 
    26412665            p_sys->p_standards[i_standard].index = i_standard; 
    26422666 
    2643             if( ioctl( i_fd, VIDIOC_ENUMSTD, &p_sys->p_standards[i_standard] ) ) 
     2667            if( v4l2_ioctl( i_fd, VIDIOC_ENUMSTD, &p_sys->p_standards[i_standard] ) ) 
    26442668            { 
    26452669                msg_Err( p_obj, "cannot get video input standards (%m)" ); 
    26462670                goto open_failed; 
     
    26622686    if( p_sys->dev_cap.capabilities & V4L2_CAP_AUDIO ) 
    26632687    { 
    26642688        while( p_sys->i_audio < 32 && 
    2665                ioctl( i_fd, VIDIOC_S_AUDIO, &p_sys->p_audios[p_sys->i_audio] ) >= 0 ) 
     2689               v4l2_ioctl( i_fd, VIDIOC_S_AUDIO, &p_sys->p_audios[p_sys->i_audio] ) >= 0 ) 
    26662690        { 
    2667             if( ioctl( i_fd, VIDIOC_G_AUDIO, &p_sys->p_audios[ p_sys->i_audio] ) < 0 ) 
     2691            if( v4l2_ioctl( i_fd, VIDIOC_G_AUDIO, &p_sys->p_audios[ p_sys->i_audio] ) < 0 ) 
    26682692            { 
    26692693                msg_Err( p_obj, "cannot get audio input characteristics (%m)" ); 
    26702694                goto open_failed; 
     
    26902714    { 
    26912715        struct v4l2_tuner tuner; 
    26922716        memset( &tuner, 0, sizeof(tuner) ); 
    2693         while( ioctl( i_fd, VIDIOC_G_TUNER, &tuner ) >= 0 ) 
     2717        while( v4l2_ioctl( i_fd, VIDIOC_G_TUNER, &tuner ) >= 0 ) 
    26942718        { 
    26952719            p_sys->i_tuner++; 
    26962720            memset( &tuner, 0, sizeof(tuner) ); 
     
    27042728        { 
    27052729            p_sys->p_tuners[i_index].index = i_index; 
    27062730 
    2707             if( ioctl( i_fd, VIDIOC_G_TUNER, &p_sys->p_tuners[i_index] ) ) 
     2731            if( v4l2_ioctl( i_fd, VIDIOC_G_TUNER, &p_sys->p_tuners[i_index] ) ) 
    27082732            { 
    27092733                msg_Err( p_obj, "cannot get tuner characteristics (%m)" ); 
    27102734                goto open_failed; 
     
    27272751 
    27282752            struct v4l2_frequency frequency; 
    27292753            memset( &frequency, 0, sizeof( frequency ) ); 
    2730             if( ioctl( i_fd, VIDIOC_G_FREQUENCY, &frequency ) < 0 ) 
     2754            if( v4l2_ioctl( i_fd, VIDIOC_G_FREQUENCY, &frequency ) < 0 ) 
    27312755            { 
    27322756                msg_Err( p_obj, "cannot get tuner frequency (%m)" ); 
    27332757                goto open_failed; 
     
    27522776        codec.index = i_index; 
    27532777        codec.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
    27542778 
    2755         while( ioctl( i_fd, VIDIOC_ENUM_FMT, &codec ) >= 0 ) 
     2779        while( v4l2_ioctl( i_fd, VIDIOC_ENUM_FMT, &codec ) >= 0 ) 
    27562780        { 
    27572781            i_index++; 
    27582782            codec.index = i_index; 
     
    27672791            p_sys->p_codecs[i_index].index = i_index; 
    27682792            p_sys->p_codecs[i_index].type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 
    27692793 
    2770             if( ioctl( i_fd, VIDIOC_ENUM_FMT, &p_sys->p_codecs[i_index] ) < 0 ) 
     2794            if( v4l2_ioctl( i_fd, VIDIOC_ENUM_FMT, &p_sys->p_codecs[i_index] ) < 0 ) 
    27712795            { 
    27722796                msg_Err( p_obj, "cannot get codec description (%m)" ); 
    27732797                goto open_failed; 
     
    28002824                    struct v4l2_frmsizeenum frmsize; 
    28012825                    frmsize.index = 0; 
    28022826                    frmsize.pixel_format = p_sys->p_codecs[i_index].pixelformat; 
    2803                     if( ioctl( i_fd, VIDIOC_ENUM_FRAMESIZES, &frmsize ) < 0 ) 
     2827                    if( v4l2_ioctl( i_fd, VIDIOC_ENUM_FRAMESIZES, &frmsize ) < 0 ) 
    28042828                    { 
    28052829                        /* Not all devices support this ioctl */ 
    28062830                        msg_Warn( p_obj, "Unable to query for frame sizes" ); 
     
    28162840                "    device supports size %dx%d", 
    28172841                frmsize.discrete.width, frmsize.discrete.height ); 
    28182842                                    frmsize.index++; 
    2819                                 } while( ioctl( i_fd, VIDIOC_ENUM_FRAMESIZES, &frmsize ) >= 0 ); 
     2843                                } while( v4l2_ioctl( i_fd, VIDIOC_ENUM_FRAMESIZES, &frmsize ) >= 0 ); 
    28202844                                break; 
    28212845                            case V4L2_FRMSIZE_TYPE_STEPWISE: 
    28222846                                msg_Dbg( p_obj, 
     
    28482872    } 
    28492873 
    28502874 
    2851     if( i_fd >= 0 ) close( i_fd ); 
     2875    if( i_fd >= 0 ) v4l2_close( i_fd ); 
    28522876    return true; 
    28532877 
    28542878open_failed: 
    28552879 
    2856     if( i_fd >= 0 ) close( i_fd ); 
     2880    if( i_fd >= 0 ) v4l2_close( i_fd ); 
    28572881    return false; 
    28582882 
    28592883} 
     
    30193043            { 
    30203044                querymenu.index = i_mid; 
    30213045                querymenu.id = queryctrl.id; 
    3022                 if( ioctl( i_fd, VIDIOC_QUERYMENU, &querymenu ) >= 0 ) 
     3046                if( v4l2_ioctl( i_fd, VIDIOC_QUERYMENU, &querymenu ) >= 0 ) 
    30233047                { 
    30243048                    msg_Dbg( p_obj, "        %d: %s", 
    30253049                             querymenu.index, querymenu.name ); 
     
    30563080                         queryctrl.default_value ); 
    30573081                memset( &control, 0, sizeof( control ) ); 
    30583082                control.id = queryctrl.id; 
    3059                 if( ioctl( i_fd, VIDIOC_G_CTRL, &control ) >= 0 ) 
     3083                if( v4l2_ioctl( i_fd, VIDIOC_G_CTRL, &control ) >= 0 ) 
    30603084                { 
    30613085                    msg_Dbg( p_obj, "    current value: %d", control.value ); 
    30623086                } 
     
    31533177        var_AddCallback( p_obj, "controls-reset", AccessControlResetCallback, NULL ); 
    31543178 
    31553179    queryctrl.id = V4L2_CTRL_FLAG_NEXT_CTRL; 
    3156     if( ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) >= 0 ) 
     3180    if( v4l2_ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) >= 0 ) 
    31573181    { 
    31583182        msg_Dbg( p_obj, "Extended control API supported by v4l2 driver" ); 
    31593183 
    31603184        /* List extended controls */ 
    31613185        queryctrl.id = V4L2_CTRL_FLAG_NEXT_CTRL; 
    3162         while( ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) >= 0 ) 
     3186        while( v4l2_ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) >= 0 ) 
    31633187        { 
    31643188            if( queryctrl.type == V4L2_CTRL_TYPE_CTRL_CLASS ) 
    31653189            { 
     
    31973221             i_cid ++ ) 
    31983222        { 
    31993223            queryctrl.id = i_cid; 
    3200             if( ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) >= 0 ) 
     3224            if( v4l2_ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) >= 0 ) 
    32013225            { 
    32023226                if( queryctrl.flags & V4L2_CTRL_FLAG_DISABLED ) 
    32033227                    continue; 
     
    32133237             i_cid ++ ) 
    32143238        { 
    32153239            queryctrl.id = i_cid; 
    3216             if( ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) >= 0 ) 
     3240            if( v4l2_ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) >= 0 ) 
    32173241            { 
    32183242                if( queryctrl.flags & V4L2_CTRL_FLAG_DISABLED ) 
    32193243                    continue; 
     
    33123336    memset( &queryctrl, 0, sizeof( queryctrl ) ); 
    33133337 
    33143338    queryctrl.id = V4L2_CTRL_FLAG_NEXT_CTRL; 
    3315     if( ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) >= 0 ) 
     3339    if( v4l2_ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) >= 0 ) 
    33163340    { 
    33173341        /* Extended control API supported */ 
    33183342        queryctrl.id = V4L2_CTRL_FLAG_NEXT_CTRL; 
    3319         while( ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) >= 0 ) 
     3343        while( v4l2_ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) >= 0 ) 
    33203344        { 
    33213345            if( queryctrl.type == V4L2_CTRL_TYPE_CTRL_CLASS 
    33223346             || V4L2_CTRL_ID2CLASS( queryctrl.id ) == V4L2_CTRL_CLASS_MPEG ) 
     
    33273351            struct v4l2_control control; 
    33283352            memset( &control, 0, sizeof( control ) ); 
    33293353            control.id = queryctrl.id; 
    3330             if( ioctl( i_fd, VIDIOC_G_CTRL, &control ) >= 0 
     3354            if( v4l2_ioctl( i_fd, VIDIOC_G_CTRL, &control ) >= 0 
    33313355             && queryctrl.default_value != control.value ) 
    33323356            { 
    33333357                int i; 
     
    33503374             i_cid ++ ) 
    33513375        { 
    33523376            queryctrl.id = i_cid; 
    3353             if( ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) >= 0 ) 
     3377            if( v4l2_ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) >= 0 ) 
    33543378            { 
    33553379                struct v4l2_control control; 
    33563380                if( queryctrl.flags & V4L2_CTRL_FLAG_DISABLED ) 
    33573381                    continue; 
    33583382                memset( &control, 0, sizeof( control ) ); 
    33593383                control.id = queryctrl.id; 
    3360                 if( ioctl( i_fd, VIDIOC_G_CTRL, &control ) >= 0 
     3384                if( v4l2_ioctl( i_fd, VIDIOC_G_CTRL, &control ) >= 0 
    33613385                 && queryctrl.default_value != control.value ) 
    33623386                { 
    33633387                    int i; 
     
    33773401             i_cid ++ ) 
    33783402        { 
    33793403            queryctrl.id = i_cid; 
    3380             if( ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) >= 0 ) 
     3404            if( v4l2_ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) >= 0 ) 
    33813405            { 
    33823406                struct v4l2_control control; 
    33833407                if( queryctrl.flags & V4L2_CTRL_FLAG_DISABLED ) 
    33843408                    continue; 
    33853409                memset( &control, 0, sizeof( control ) ); 
    33863410                control.id = queryctrl.id; 
    3387                 if( ioctl( i_fd, VIDIOC_G_CTRL, &control ) >= 0 
     3411                if( v4l2_ioctl( i_fd, VIDIOC_G_CTRL, &control ) >= 0 
    33883412                 && queryctrl.default_value != control.value ) 
    33893413                { 
    33903414                    name2var( queryctrl.name ); 
     
    34173441 
    34183442    queryctrl.id = i_cid; 
    34193443 
    3420     if( ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) < 0 
     3444    if( v4l2_ioctl( i_fd, VIDIOC_QUERYCTRL, &queryctrl ) < 0 
    34213445        || queryctrl.flags & V4L2_CTRL_FLAG_DISABLED ) 
    34223446    { 
    34233447        msg_Dbg( p_obj, "%s (%x) control is not supported.", psz_name, i_cid ); 
     
    34383462    if( i_value >= 0 ) 
    34393463    { 
    34403464        ext_control.value = i_value; 
    3441         if( ioctl( i_fd, VIDIOC_S_EXT_CTRLS, &ext_controls ) < 0 ) 
     3465        if( v4l2_ioctl( i_fd, VIDIOC_S_EXT_CTRLS, &ext_controls ) < 0 ) 
    34423466        { 
    34433467            control.value = i_value; 
    3444             if( ioctl( i_fd, VIDIOC_S_CTRL, &control ) < 0 ) 
     3468            if( v4l2_ioctl( i_fd, VIDIOC_S_CTRL, &control ) < 0 ) 
    34453469            { 
    34463470                msg_Err( p_obj, "unable to set %s (%x) to %d (%m)", 
    34473471                         psz_name, i_cid, i_value ); 
    34483472                return VLC_EGENERIC; 
    34493473            } 
    3450             i_ret = ioctl( i_fd, VIDIOC_G_CTRL, &control ); 
     3474            i_ret = v4l2_ioctl( i_fd, VIDIOC_G_CTRL, &control ); 
    34513475        } 
    34523476        else 
    34533477        { 
    3454             i_ret = ioctl( i_fd, VIDIOC_G_EXT_CTRLS, &ext_controls ); 
     3478            i_ret = v4l2_ioctl( i_fd, VIDIOC_G_EXT_CTRLS, &ext_controls ); 
    34553479            control.value = ext_control.value; 
    34563480        } 
    34573481    }