dlls/qcap/v4l.c

   1 /*
   2  * DirectShow capture services (QCAP.DLL)
   3  *
   4  * Copyright 2005 Maarten Lankhorst
   5  *
   6  * This file contains the part of the vfw capture interface that
   7  * does the actual Video4Linux(1/2) stuff required for capturing
   8  * and setting/getting media format..
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include "config.h"
  26 #include "wine/port.h"
  27 #include "wine/library.h"
  28
  29 #define NONAMELESSSTRUCT
  30 #define NONAMELESSUNION
  31 #define COBJMACROS
  32
  33 #include <stdarg.h>
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "wtypes.h"
  37 #include "wingdi.h"
  38 #include "winuser.h"
  39 #include "dshow.h"
  40 #include "vfwmsgs.h"
  41 #include "amvideo.h"
  42 #include "wine/debug.h"
  43
  44 #include "capture.h"
  45 #include "qcap_main.h"
  46
  47 #include <stdio.h>
  48 #include <fcntl.h>
  49
  50 #ifdef HAVE_SYS_IOCTL_H
  51 #include <sys/ioctl.h>
  52 #endif
  53 #ifdef HAVE_SYS_MMAN_H
  54 #include <sys/mman.h>
  55 #endif
  56 #ifdef HAVE_SYS_ERRNO_H
  57 #include <sys/errno.h>
  58 #endif
  59 #ifdef HAVE_SYS_TIME_H
  60 #include <sys/time.h>
  61 #endif
  62 #ifdef HAVE_ASM_TYPES_H
  63 #include <asm/types.h>
  64 #endif
  65 #ifdef HAVE_LINUX_VIDEODEV_H
  66 #include <linux/videodev.h>
  67 #endif
  68 #ifdef HAVE_UNISTD_H
  69 #include <unistd.h>
  70 #endif
  71
  72 WINE_DEFAULT_DEBUG_CHANNEL(qcap_v4l);
  73
  74 #ifdef HAVE_LINUX_VIDEODEV_H
  75
  76 static typeof(open) *video_open = open;
  77 static typeof(close) *video_close = close;
  78 static typeof(ioctl) *video_ioctl = ioctl;
  79 static typeof(read) *video_read = read;
  80 static typeof(mmap) *video_mmap = mmap;
  81 static typeof(munmap) *video_munmap = munmap;
  82
  83 static void video_init(void)
  84 {
  85 #ifdef SONAME_LIBV4L1
  86     static void *video_lib;
  87
  88     if (video_lib)
  89         return;
  90     video_lib = wine_dlopen(SONAME_LIBV4L1, RTLD_NOW, NULL, 0);
  91     if (!video_lib)
  92         return;
  93     video_open = wine_dlsym(video_lib, "v4l1_open", NULL, 0);
  94     video_close = wine_dlsym(video_lib, "v4l1_close", NULL, 0);
  95     video_ioctl = wine_dlsym(video_lib, "v4l1_ioctl", NULL, 0);
  96     video_read = wine_dlsym(video_lib, "v4l1_read", NULL, 0);
  97     video_mmap = wine_dlsym(video_lib, "v4l1_mmap", NULL, 0);
  98     video_munmap = wine_dlsym(video_lib, "v4l1_munmap", NULL, 0);
  99 #endif
 100 }
 101
 102 typedef void (* Renderer)(const Capture *, LPBYTE bufferin, const BYTE *stream);
 103
 104 struct _Capture
 105 {
 106     UINT width, height, bitDepth, fps, outputwidth, outputheight;
 107     BOOL swresize;
 108
 109     CRITICAL_SECTION CritSect;
 110
 111     IPin *pOut;
 112     int fd, mmap;
 113     int iscommitted, stopped;
 114     struct video_picture pict;
 115     int dbrightness, dhue, dcolour, dcontrast;
 116
 117     /* mmap (V4l1) */
 118     struct video_mmap *grab_buf;
 119     struct video_mbuf gb_buffers;
 120     unsigned char *pmap;
 121     int buffers;
 122
 123     /* read (V4l1) */
 124     int imagesize;
 125     char * grab_data;
 126
 127     int curframe;
 128
 129     HANDLE thread;
 130     Renderer renderer;
 131 };
 132
 133 struct renderlist
 134 {
 135     int depth;
 136     const char* name;
 137     Renderer renderer;
 138 };
 139
 140 static void renderer_RGB(const Capture *capBox, LPBYTE bufferin, const BYTE *stream);
 141 static void renderer_YUV(const Capture *capBox, LPBYTE bufferin, const BYTE *stream);
 142
 143 static const struct renderlist renderlist_V4l[] = {
 144     {  0, "NULL renderer",               NULL },
 145     {  8, "Gray scales",                 NULL }, /* 1,  Don't support  */
 146     {  0, "High 240 cube (BT848)",       NULL }, /* 2,  Don't support  */
 147     { 16, "16 bit RGB (565)",            NULL }, /* 3,  Don't support  */
 148     { 24, "24 bit RGB values",   renderer_RGB }, /* 4,  Supported,     */
 149     { 32, "32 bit RGB values",   renderer_RGB }, /* 5,  Supported      */
 150     { 16, "15 bit RGB (555)",            NULL }, /* 6,  Don't support  */
 151     { 16, "YUV 422 (Not P)",     renderer_YUV }, /* 7,  Supported */
 152     { 16, "YUYV (Not P)",        renderer_YUV }, /* 8,  Supported */
 153     { 16, "UYVY (Not P)",        renderer_YUV }, /* 9,  Supported */
 154     { 16, "YUV 420 (Not P)", NULL }, /* 10, Not supported, if I had to guess it's YYUYYV */
 155     { 12, "YUV 411 (Not P)",     renderer_YUV }, /* 11, Supported */
 156     {  0, "Raw capturing (BT848)",       NULL }, /* 12, Don't support  */
 157     { 16, "YUV 422 (Planar)",    renderer_YUV }, /* 13, Supported */
 158     { 12, "YUV 411 (Planar)",    renderer_YUV }, /* 14, Supported */
 159     { 12, "YUV 420 (Planar)",    renderer_YUV }, /* 15, Supported */
 160     { 10, "YUV 410 (Planar)",    renderer_YUV }, /* 16, Supported */
 161     /* FIXME: add YUV420 support */
 162     {  0, NULL,                          NULL },
 163 };
 164
 165 static const int fallback_V4l[] = { 4, 5, 7, 8, 9, 13, 15, 14, 16, 11, -1 };
 166 /* Fallback: First try raw formats (Should try yuv first perhaps?), then yuv */
 167
 168 /* static const Capture defbox; */
 169
 170 static int xioctl(int fd, int request, void * arg)
 171 {
 172     int r;
 173
 174     do {
 175         r = video_ioctl (fd, request, arg);
 176     } while (-1 == r && EINTR == errno);
 177
 178     return r;
 179 }
 180
 181 /* Prepare the capture buffers */
 182 static HRESULT V4l_Prepare(Capture *capBox)
 183 {
 184     TRACE("%p: Preparing for %dx%d resolution\n", capBox, capBox->width, capBox->height);
 185
 186     /* Try mmap */
 187     capBox->mmap = 0;
 188     if (xioctl(capBox->fd, VIDIOCGMBUF, &capBox->gb_buffers) != -1 &&
 189         capBox->gb_buffers.frames)
 190     {
 191         capBox->buffers = capBox->gb_buffers.frames;
 192         if (capBox->gb_buffers.frames > 1)
 193             capBox->buffers = 1;
 194         TRACE("%p: Using %d/%d buffers\n", capBox,
 195               capBox->buffers, capBox->gb_buffers.frames);
 196
 197         capBox->pmap = video_mmap( 0, capBox->gb_buffers.size, PROT_READ|PROT_WRITE,
 198                                    MAP_SHARED, capBox->fd, 0 );
 199         if (capBox->pmap != MAP_FAILED)
 200         {
 201             int i;
 202
 203             capBox->grab_buf = CoTaskMemAlloc(sizeof(struct video_mmap) * capBox->buffers);
 204             if (!capBox->grab_buf)
 205             {
 206                 video_munmap(capBox->pmap, capBox->gb_buffers.size);
 207                 return E_OUTOFMEMORY;
 208             }
 209
 210             /* Setup mmap capture buffers. */
 211             for (i = 0; i < capBox->buffers; i++)
 212             {
 213                 capBox->grab_buf[i].format = capBox->pict.palette;
 214                 capBox->grab_buf[i].frame = i;
 215                 capBox->grab_buf[i].width = capBox->width;
 216                 capBox->grab_buf[i].height = capBox->height;
 217             }
 218             capBox->mmap = 1;
 219         }
 220     }
 221     if (!capBox->mmap)
 222     {
 223         capBox->buffers = 1;
 224         capBox->imagesize = renderlist_V4l[capBox->pict.palette].depth *
 225                                 capBox->height * capBox->width / 8;
 226         capBox->grab_data = CoTaskMemAlloc(capBox->imagesize);
 227         if (!capBox->grab_data)
 228             return E_OUTOFMEMORY;
 229     }
 230     TRACE("Using mmap: %d\n", capBox->mmap);
 231     return S_OK;
 232 }
 233
 234 static void V4l_Unprepare(Capture *capBox)
 235 {
 236     if (capBox->mmap)
 237     {
 238         for (capBox->curframe = 0; capBox->curframe < capBox->buffers; capBox->curframe++)
 239             xioctl(capBox->fd, VIDIOCSYNC, &capBox->grab_buf[capBox->curframe]);
 240         video_munmap(capBox->pmap, capBox->gb_buffers.size);
 241         CoTaskMemFree(capBox->grab_buf);
 242     }
 243     else
 244         CoTaskMemFree(capBox->grab_data);
 245 }
 246
 247 HRESULT qcap_driver_destroy(Capture *capBox)
 248 {
 249     TRACE("%p\n", capBox);
 250
 251     if( capBox->fd != -1 )
 252         video_close(capBox->fd);
 253     capBox->CritSect.DebugInfo->Spare[0] = 0;
 254     DeleteCriticalSection(&capBox->CritSect);
 255     CoTaskMemFree(capBox);
 256     return S_OK;
 257 }
 258
 259 HRESULT qcap_driver_set_format(Capture *capBox, AM_MEDIA_TYPE * mT)
 260 {
 261     int newheight, newwidth;
 262     struct video_window window;
 263     VIDEOINFOHEADER *format;
 264
 265     TRACE("%p\n", capBox);
 266
 267     format = (VIDEOINFOHEADER *) mT->pbFormat;
 268     if (format->bmiHeader.biBitCount != 24 ||
 269         format->bmiHeader.biCompression != BI_RGB)
 270     {
 271         FIXME("unsupported media type %d %d\n", format->bmiHeader.biBitCount,
 272               format->bmiHeader.biCompression );
 273         return VFW_E_INVALIDMEDIATYPE;
 274     }
 275
 276     newwidth = format->bmiHeader.biWidth;
 277     newheight = format->bmiHeader.biHeight;
 278
 279     TRACE("%p -> (%p) - %d %d\n", capBox, mT, newwidth, newheight);
 280
 281     if (capBox->height == newheight && capBox->width == newwidth)
 282         return S_OK;
 283
 284     if(-1 == xioctl(capBox->fd, VIDIOCGWIN, &window))
 285     {
 286         ERR("ioctl(VIDIOCGWIN) failed (%d)\n", errno);
 287         return E_FAIL;
 288     }
 289     window.width = newwidth;
 290     window.height = newheight;
 291     if (xioctl(capBox->fd, VIDIOCSWIN, &window) == -1)
 292     {
 293         TRACE("using software resize: %dx%d -> %dx%d\n",
 294                window.width, window.height, capBox->width, capBox->height);
 295         capBox->swresize = TRUE;
 296     }
 297     else
 298     {
 299         capBox->height = window.height;
 300         capBox->width = window.width;
 301         capBox->swresize = FALSE;
 302     }
 303     capBox->outputwidth = window.width;
 304     capBox->outputheight = window.height;
 305     return S_OK;
 306 }
 307
 308 HRESULT qcap_driver_get_format(const Capture *capBox, AM_MEDIA_TYPE ** mT)
 309 {
 310     VIDEOINFOHEADER *vi;
 311
 312     mT[0] = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE));
 313     if (!mT[0])
 314         return E_OUTOFMEMORY;
 315     vi = CoTaskMemAlloc(sizeof(VIDEOINFOHEADER));
 316     mT[0]->cbFormat = sizeof(VIDEOINFOHEADER);
 317     if (!vi)
 318     {
 319         CoTaskMemFree(mT[0]);
 320         return E_OUTOFMEMORY;
 321     }
 322     mT[0]->majortype = MEDIATYPE_Video;
 323     mT[0]->subtype = MEDIASUBTYPE_RGB24;
 324     mT[0]->formattype = FORMAT_VideoInfo;
 325     mT[0]->bFixedSizeSamples = TRUE;
 326     mT[0]->bTemporalCompression = FALSE;
 327     mT[0]->pUnk = NULL;
 328     mT[0]->lSampleSize = capBox->outputwidth * capBox->outputheight * capBox->bitDepth / 8;
 329     TRACE("Output format: %dx%d - %d bits = %u KB\n", capBox->outputwidth,
 330           capBox->outputheight, capBox->bitDepth, mT[0]->lSampleSize/1024);
 331     vi->rcSource.left = 0; vi->rcSource.top = 0;
 332     vi->rcTarget.left = 0; vi->rcTarget.top = 0;
 333     vi->rcSource.right = capBox->width; vi->rcSource.bottom = capBox->height;
 334     vi->rcTarget.right = capBox->outputwidth; vi->rcTarget.bottom = capBox->outputheight;
 335     vi->dwBitRate = capBox->fps * mT[0]->lSampleSize;
 336     vi->dwBitErrorRate = 0;
 337     vi->AvgTimePerFrame = (LONGLONG)10000000.0 / (LONGLONG)capBox->fps;
 338     vi->bmiHeader.biSize = 40;
 339     vi->bmiHeader.biWidth = capBox->outputwidth;
 340     vi->bmiHeader.biHeight = capBox->outputheight;
 341     vi->bmiHeader.biPlanes = 1;
 342     vi->bmiHeader.biBitCount = 24;
 343     vi->bmiHeader.biCompression = BI_RGB;
 344     vi->bmiHeader.biSizeImage = mT[0]->lSampleSize;
 345     vi->bmiHeader.biClrUsed = vi->bmiHeader.biClrImportant = 0;
 346     vi->bmiHeader.biXPelsPerMeter = 100;
 347     vi->bmiHeader.biYPelsPerMeter = 100;
 348     mT[0]->pbFormat = (void *)vi;
 349     dump_AM_MEDIA_TYPE(mT[0]);
 350     return S_OK;
 351 }
 352
 353 HRESULT qcap_driver_get_prop_range( Capture *capBox,
 354             VideoProcAmpProperty Property, LONG *pMin, LONG *pMax,
 355             LONG *pSteppingDelta, LONG *pDefault, LONG *pCapsFlags )
 356 {
 357     TRACE("%p -> %d %p %p %p %p %p\n", capBox, Property,
 358           pMin, pMax, pSteppingDelta, pDefault, pCapsFlags);
 359
 360     switch (Property)
 361     {
 362     case VideoProcAmp_Brightness:
 363         *pDefault = capBox->dbrightness;
 364         break;
 365     case VideoProcAmp_Contrast:
 366         *pDefault = capBox->dcontrast;
 367         break;
 368     case VideoProcAmp_Hue:
 369         *pDefault = capBox->dhue;
 370         break;
 371     case VideoProcAmp_Saturation:
 372         *pDefault = capBox->dcolour;
 373         break;
 374     default:
 375         FIXME("Not implemented %d\n", Property);
 376         return E_NOTIMPL;
 377     }
 378     *pMin = 0;
 379     *pMax = 65535;
 380     *pSteppingDelta = 65536/256;
 381     *pCapsFlags = VideoProcAmp_Flags_Manual;
 382     return S_OK;
 383 }
 384
 385 HRESULT qcap_driver_get_prop( Capture *capBox,
 386             VideoProcAmpProperty Property, LONG *lValue, LONG *Flags )
 387 {
 388     TRACE("%p -> %d %p %p\n", capBox, Property, lValue, Flags);
 389
 390     switch (Property)
 391     {
 392     case VideoProcAmp_Brightness:
 393         *lValue = capBox->pict.brightness;
 394         break;
 395     case VideoProcAmp_Contrast:
 396         *lValue = capBox->pict.contrast;
 397         break;
 398     case VideoProcAmp_Hue:
 399         *lValue = capBox->pict.hue;
 400         break;
 401     case VideoProcAmp_Saturation:
 402         *lValue = capBox->pict.colour;
 403         break;
 404     default:
 405         FIXME("Not implemented %d\n", Property);
 406         return E_NOTIMPL;
 407     }
 408     *Flags = VideoProcAmp_Flags_Manual;
 409     return S_OK;
 410 }
 411
 412 HRESULT qcap_driver_set_prop(Capture *capBox, VideoProcAmpProperty Property,
 413             LONG lValue, LONG Flags)
 414 {
 415     TRACE("%p -> %d %d %d\n", capBox, Property, lValue, Flags);
 416
 417     switch (Property)
 418     {
 419     case VideoProcAmp_Brightness:
 420         capBox->pict.brightness = lValue;
 421         break;
 422     case VideoProcAmp_Contrast:
 423         capBox->pict.contrast = lValue;
 424         break;
 425     case VideoProcAmp_Hue:
 426         capBox->pict.hue = lValue;
 427         break;
 428     case VideoProcAmp_Saturation:
 429         capBox->pict.colour = lValue;
 430         break;
 431     default:
 432         FIXME("Not implemented %d\n", Property);
 433         return E_NOTIMPL;
 434     }
 435
 436     if (xioctl(capBox->fd, VIDIOCSPICT, &capBox->pict) == -1)
 437     {
 438         ERR("ioctl(VIDIOCSPICT) failed (%d)\n",errno);
 439         return E_FAIL;
 440     }
 441     return S_OK;
 442 }
 443
 444 static void renderer_RGB(const Capture *capBox, LPBYTE bufferin, const BYTE *stream)
 445 {
 446     int depth = renderlist_V4l[capBox->pict.palette].depth;
 447     int size = capBox->height * capBox->width * depth / 8;
 448     int pointer, offset;
 449
 450     switch (depth)
 451     {
 452     case 24:
 453         memcpy(bufferin, stream, size);
 454         break;
 455     case 32:
 456         pointer = 0;
 457         offset = 1;
 458         while (pointer + offset <= size)
 459         {
 460             bufferin[pointer] = stream[pointer + offset];
 461             pointer++;
 462             bufferin[pointer] = stream[pointer + offset];
 463             pointer++;
 464             bufferin[pointer] = stream[pointer + offset];
 465             pointer++;
 466             offset++;
 467         }
 468         break;
 469     default:
 470         ERR("Unknown bit depth %d\n", depth);
 471         return;
 472     }
 473 }
 474
 475 static void renderer_YUV(const Capture *capBox, LPBYTE bufferin, const BYTE *stream)
 476 {
 477     enum YUV_Format format;
 478
 479     switch (capBox->pict.palette)
 480     {
 481     case  7: /* YUV422  -  same as YUYV */
 482     case  8: /* YUYV    */
 483         format = YUYV;
 484         break;
 485     case  9: /* UYVY    */
 486         format = UYVY;
 487         break;
 488     case 11: /* YUV411  */
 489         format = UYYVYY;
 490         break;
 491     case 13: /* YUV422P */
 492         format = YUVP_421;
 493         break;
 494     case 14: /* YUV411P */
 495         format = YUVP_441;
 496         break;
 497     case 15: /* YUV420P */
 498         format = YUVP_422;
 499         break;
 500     case 16: /* YUV410P */
 501         format = YUVP_444;
 502         break;
 503     default:
 504         ERR("Unknown palette %d\n", capBox->pict.palette);
 505         return;
 506     }
 507     YUV_To_RGB24(format, bufferin, stream, capBox->width, capBox->height);
 508 }
 509
 510 static void Resize(const Capture * capBox, LPBYTE output, const BYTE *input)
 511 {
 512     /* the whole image needs to be reversed,
 513        because the dibs are messed up in windows */
 514     if (!capBox->swresize)
 515     {
 516         int depth = capBox->bitDepth / 8;
 517         int inoffset = 0, outoffset = capBox->height * capBox->width * depth;
 518         int ow = capBox->width * depth;
 519         while (outoffset > 0)
 520         {
 521             int x;
 522             outoffset -= ow;
 523             for (x = 0; x < ow; x++)
 524                 output[outoffset + x] = input[inoffset + x];
 525             inoffset += ow;
 526         }
 527     }
 528     else
 529     {
 530         HDC dc_s, dc_d;
 531         HBITMAP bmp_s, bmp_d;
 532         int depth = capBox->bitDepth / 8;
 533         int inoffset = 0, outoffset = (capBox->outputheight) * capBox->outputwidth * depth;
 534         int ow = capBox->outputwidth * depth;
 535         LPBYTE myarray;
 536
 537         /* FIXME: Improve software resizing: add error checks and optimize */
 538
 539         myarray = CoTaskMemAlloc(capBox->outputwidth * capBox->outputheight * depth);
 540         dc_s = CreateCompatibleDC(NULL);
 541         dc_d = CreateCompatibleDC(NULL);
 542         bmp_s = CreateBitmap(capBox->width, capBox->height, 1, capBox->bitDepth, input);
 543         bmp_d = CreateBitmap(capBox->outputwidth, capBox->outputheight, 1, capBox->bitDepth, NULL);
 544         SelectObject(dc_s, bmp_s);
 545         SelectObject(dc_d, bmp_d);
 546         StretchBlt(dc_d, 0, 0, capBox->outputwidth, capBox->outputheight,
 547                    dc_s, 0, 0, capBox->width, capBox->height, SRCCOPY);
 548         GetBitmapBits(bmp_d, capBox->outputwidth * capBox->outputheight * depth, myarray);
 549         while (outoffset > 0)
 550         {
 551             int i;
 552
 553             outoffset -= ow;
 554             for (i = 0; i < ow; i++)
 555                 output[outoffset + i] = myarray[inoffset + i];
 556             inoffset += ow;
 557         }
 558         CoTaskMemFree(myarray);
 559         DeleteObject(dc_s);
 560         DeleteObject(dc_d);
 561         DeleteObject(bmp_s);
 562         DeleteObject(bmp_d);
 563     }
 564 }
 565
 566 static void V4l_GetFrame(Capture * capBox, unsigned char ** pInput)
 567 {
 568     if (capBox->mmap)
 569     {
 570         if (xioctl(capBox->fd, VIDIOCSYNC, &capBox->grab_buf[capBox->curframe]) == -1)
 571             WARN("Syncing ioctl failed: %d\n", errno);
 572
 573         *pInput = capBox->pmap + capBox->gb_buffers.offsets[capBox->curframe];
 574     }
 575     else
 576     {
 577         int retval;
 578         while ((retval = video_read(capBox->fd, capBox->grab_data, capBox->imagesize)) == -1)
 579             if (errno != EAGAIN) break;
 580         if (retval == -1)
 581             WARN("Error occurred while reading from device: %s\n", strerror(errno));
 582         *pInput = (unsigned char*) capBox->grab_data;
 583     }
 584 }
 585
 586 static void V4l_FreeFrame(Capture * capBox)
 587 {
 588     TRACE("\n");
 589     if (capBox->mmap)
 590     {
 591         if (xioctl(capBox->fd, VIDIOCMCAPTURE, &capBox->grab_buf[capBox->curframe]) == -1)
 592            ERR("Freeing frame for capture failed: %s\n", strerror(errno));
 593     }
 594     if (++capBox->curframe == capBox->buffers)
 595         capBox->curframe = 0;
 596 }
 597
 598 static DWORD WINAPI ReadThread(LPVOID lParam)
 599 {
 600     Capture * capBox = lParam;
 601     HRESULT hr;
 602     IMediaSample *pSample = NULL;
 603     ULONG framecount = 0;
 604     unsigned char *pTarget, *pInput, *pOutput;
 605
 606     hr = V4l_Prepare(capBox);
 607     if (FAILED(hr))
 608         goto fail;
 609
 610     pOutput = CoTaskMemAlloc(capBox->width * capBox->height * capBox->bitDepth / 8);
 611     capBox->curframe = 0;
 612     do {
 613         V4l_FreeFrame(capBox);
 614     } while (capBox->curframe != 0);
 615
 616     while (1)
 617     {
 618         EnterCriticalSection(&capBox->CritSect);
 619         if (capBox->stopped)
 620             break;
 621         hr = BaseOutputPinImpl_GetDeliveryBuffer((BaseOutputPin *)capBox->pOut, &pSample, NULL, NULL, 0);
 622         if (SUCCEEDED(hr))
 623         {
 624             int len;
 625
 626             if (!capBox->swresize)
 627                 len = capBox->height * capBox->width * capBox->bitDepth / 8;
 628             else
 629                 len = capBox->outputheight * capBox->outputwidth * capBox->bitDepth / 8;
 630             IMediaSample_SetActualDataLength(pSample, len);
 631
 632             len = IMediaSample_GetActualDataLength(pSample);
 633             TRACE("Data length: %d KB\n", len / 1024);
 634
 635             IMediaSample_GetPointer(pSample, &pTarget);
 636             /* FIXME: Check return values.. */
 637             V4l_GetFrame(capBox, &pInput);
 638             capBox->renderer(capBox, pOutput, pInput);
 639             Resize(capBox, pTarget, pOutput);
 640             hr = BaseOutputPinImpl_Deliver((BaseOutputPin *)capBox->pOut, pSample);
 641             TRACE("%p -> Frame %u: %x\n", capBox, ++framecount, hr);
 642             IMediaSample_Release(pSample);
 643             V4l_FreeFrame(capBox);
 644         }
 645         LeaveCriticalSection(&capBox->CritSect);
 646         if (FAILED(hr) && hr != VFW_E_NOT_CONNECTED)
 647         {
 648             ERR("Received error: %x\n", hr);
 649             goto cfail;
 650         }
 651     }
 652     LeaveCriticalSection(&capBox->CritSect);
 653     CoTaskMemFree(pOutput);
 654
 655     return 0;
 656
 657 cfail:
 658     CoTaskMemFree(pOutput);
 659     V4l_Unprepare(capBox);
 660     LeaveCriticalSection(&capBox->CritSect);
 661
 662 fail:
 663     capBox->thread = 0; capBox->stopped = 1;
 664     FIXME("Stop IFilterGraph\n");
 665     return 0;
 666 }
 667
 668 HRESULT qcap_driver_run(Capture *capBox, FILTER_STATE *state)
 669 {
 670     HANDLE thread;
 671     HRESULT hr;
 672
 673     TRACE("%p -> (%p)\n", capBox, state);
 674
 675     if (*state == State_Running) return S_OK;
 676
 677     EnterCriticalSection(&capBox->CritSect);
 678
 679     capBox->stopped = 0;
 680
 681     if (*state == State_Stopped)
 682     {
 683         *state = State_Running;
 684         if (!capBox->iscommitted++)
 685         {
 686             IMemAllocator * pAlloc = NULL;
 687             ALLOCATOR_PROPERTIES ap, actual;
 688             BaseOutputPin *out;
 689
 690             ap.cBuffers = 3;
 691             if (!capBox->swresize)
 692                 ap.cbBuffer = capBox->width * capBox->height;
 693             else
 694                 ap.cbBuffer = capBox->outputwidth * capBox->outputheight;
 695             ap.cbBuffer = (ap.cbBuffer * capBox->bitDepth) / 8;
 696             ap.cbAlign = 1;
 697             ap.cbPrefix = 0;
 698
 699             out = (BaseOutputPin *)capBox->pOut;
 700             hr = IMemInputPin_GetAllocator(out->pMemInputPin, &pAlloc);
 701
 702             if (SUCCEEDED(hr))
 703                 hr = IMemAllocator_SetProperties(pAlloc, &ap, &actual);
 704
 705             if (SUCCEEDED(hr))
 706                 hr = IMemAllocator_Commit(pAlloc);
 707
 708             if (pAlloc)
 709                 IMemAllocator_Release(pAlloc);
 710
 711             TRACE("Committing allocator: %x\n", hr);
 712         }
 713
 714         thread = CreateThread(NULL, 0, ReadThread, capBox, 0, NULL);
 715         if (thread)
 716         {
 717             capBox->thread = thread;
 718             SetThreadPriority(thread, THREAD_PRIORITY_LOWEST);
 719             LeaveCriticalSection(&capBox->CritSect);
 720             return S_OK;
 721         }
 722         ERR("Creating thread failed.. %u\n", GetLastError());
 723         LeaveCriticalSection(&capBox->CritSect);
 724         return E_FAIL;
 725     }
 726
 727     ResumeThread(capBox->thread);
 728     *state = State_Running;
 729     LeaveCriticalSection(&capBox->CritSect);
 730     return S_OK;
 731 }
 732
 733 HRESULT qcap_driver_pause(Capture *capBox, FILTER_STATE *state)
 734 {
 735     TRACE("%p -> (%p)\n", capBox, state);
 736
 737     if (*state == State_Paused)
 738         return S_OK;
 739     if (*state == State_Stopped)
 740         qcap_driver_run(capBox, state);
 741
 742     EnterCriticalSection(&capBox->CritSect);
 743     *state = State_Paused;
 744     SuspendThread(capBox->thread);
 745     LeaveCriticalSection(&capBox->CritSect);
 746
 747     return S_OK;
 748 }
 749
 750 HRESULT qcap_driver_stop(Capture *capBox, FILTER_STATE *state)
 751 {
 752     TRACE("%p -> (%p)\n", capBox, state);
 753
 754     if (*state == State_Stopped)
 755         return S_OK;
 756
 757     EnterCriticalSection(&capBox->CritSect);
 758
 759     if (capBox->thread)
 760     {
 761         if (*state == State_Paused)
 762             ResumeThread(capBox->thread);
 763         capBox->stopped = 1;
 764         capBox->thread = 0;
 765         if (capBox->iscommitted)
 766         {
 767             IMemInputPin *pMem = NULL;
 768             IMemAllocator * pAlloc = NULL;
 769             IPin *pConnect = NULL;
 770             HRESULT hr;
 771
 772             capBox->iscommitted = 0;
 773
 774             hr = IPin_ConnectedTo(capBox->pOut, &pConnect);
 775
 776             if (SUCCEEDED(hr))
 777                 hr = IPin_QueryInterface(pConnect, &IID_IMemInputPin, (void **) &pMem);
 778
 779             if (SUCCEEDED(hr))
 780                 hr = IMemInputPin_GetAllocator(pMem, &pAlloc);
 781
 782             if (SUCCEEDED(hr))
 783                 hr = IMemAllocator_Decommit(pAlloc);
 784
 785             if (pAlloc)
 786                 IMemAllocator_Release(pAlloc);
 787
 788             if (pMem)
 789                 IMemInputPin_Release(pMem);
 790
 791             if (pConnect)
 792                 IPin_Release(pConnect);
 793
 794             if (hr != S_OK && hr != VFW_E_NOT_COMMITTED)
 795                 WARN("Decommitting allocator: %x\n", hr);
 796         }
 797         V4l_Unprepare(capBox);
 798     }
 799
 800     *state = State_Stopped;
 801     LeaveCriticalSection(&capBox->CritSect);
 802     return S_OK;
 803 }
 804
 805 Capture * qcap_driver_init( IPin *pOut, USHORT card )
 806 {
 807     Capture * capBox = NULL;
 808     char device[20];
 809     struct video_capability capa;
 810     struct video_picture pict;
 811     struct video_window window;
 812
 813     YUV_Init();
 814     video_init();
 815
 816     capBox = CoTaskMemAlloc(sizeof(Capture));
 817     if (!capBox)
 818         goto error;
 819
 820     /* capBox->vtbl = &defboxVtbl; */
 821
 822     InitializeCriticalSection( &capBox->CritSect );
 823     capBox->CritSect.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": Capture.CritSect");
 824
 825     sprintf(device, "/dev/video%i", card);
 826     TRACE("opening %s\n", device);
 827     capBox->fd = video_open(device, O_RDWR | O_NONBLOCK);
 828     if (capBox->fd == -1)
 829     {
 830         WARN("open failed (%d)\n", errno);
 831         goto error;
 832     }
 833
 834     memset(&capa, 0, sizeof(capa));
 835
 836     if (xioctl(capBox->fd, VIDIOCGCAP, &capa) == -1)
 837     {
 838         WARN("ioctl(VIDIOCGCAP) failed (%d)\n", errno);
 839         goto error;
 840     }
 841
 842     if (!(capa.type & VID_TYPE_CAPTURE))
 843     {
 844         WARN("not a video capture device\n");
 845         goto error;
 846     }
 847
 848     TRACE("%d inputs on %s\n", capa.channels, capa.name );
 849
 850     if (xioctl(capBox->fd, VIDIOCGPICT, &pict) == -1)
 851     {
 852         ERR("ioctl(VIDIOCGPICT) failed (%d)\n", errno );
 853         goto error;
 854     }
 855
 856     TRACE("depth %d palette %d (%s) hue %d color %d contrast %d\n",
 857           pict.depth, pict.palette, renderlist_V4l[pict.palette].name,
 858           pict.hue, pict.colour, pict.contrast );
 859
 860     capBox->dbrightness = pict.brightness;
 861     capBox->dcolour = pict.colour;
 862     capBox->dhue = pict.hue;
 863     capBox->dcontrast = pict.contrast;
 864
 865     if (!renderlist_V4l[pict.palette].renderer)
 866     {
 867         int palet = pict.palette, i;
 868
 869         TRACE("No renderer available for %s, falling back to defaults\n",
 870              renderlist_V4l[pict.palette].name);
 871         capBox->renderer = NULL;
 872         for (i = 0; fallback_V4l[i] >=0 ; i++)
 873         {
 874             int n = fallback_V4l[i];
 875
 876             if (renderlist_V4l[n].renderer == NULL)
 877                 continue;
 878
 879             pict.depth = renderlist_V4l[n].depth;
 880             pict.palette = n;
 881             if (xioctl(capBox->fd, VIDIOCSPICT, &pict) == -1)
 882             {
 883                 TRACE("Could not render with %s (%d)\n",
 884                       renderlist_V4l[n].name, n);
 885                 continue;
 886             }
 887             TRACE("using renderer %s (%d)\n",
 888                   renderlist_V4l[n].name, n);
 889             capBox->renderer = renderlist_V4l[n].renderer;
 890             break;
 891         }
 892
 893         if (!capBox->renderer)
 894         {
 895             ERR("video format %s isn't available\n",
 896                  renderlist_V4l[palet].name);
 897             goto error;
 898         }
 899     }
 900     else
 901     {
 902         TRACE("Using the suggested format\n");
 903         capBox->renderer = renderlist_V4l[pict.palette].renderer;
 904     }
 905     memcpy(&capBox->pict, &pict, sizeof(struct video_picture));
 906
 907     memset(&window, 0, sizeof(window));
 908     if (xioctl(capBox->fd, VIDIOCGWIN, &window) == -1)
 909     {
 910         WARN("VIDIOCGWIN failed (%d)\n", errno);
 911         goto error;
 912     }
 913
 914     capBox->height = capBox->outputheight = window.height;
 915     capBox->width = capBox->outputwidth = window.width;
 916     capBox->swresize = FALSE;
 917     capBox->bitDepth = 24;
 918     capBox->pOut = pOut;
 919     capBox->fps = 3;
 920     capBox->stopped = 0;
 921     capBox->curframe = 0;
 922     capBox->iscommitted = 0;
 923
 924     TRACE("format: %d bits - %d x %d\n", capBox->bitDepth, capBox->width, capBox->height);
 925
 926     return capBox;
 927
 928 error:
 929     if (capBox)
 930         qcap_driver_destroy( capBox );
 931
 932     return NULL;
 933 }
 934
 935 #else
 936
 937 Capture * qcap_driver_init( IPin *pOut, USHORT card )
 938 {
 939     const char msg[] =
 940         "The v4l headers were not available at compile time,\n"
 941         "so video capture support is not available.\n";
 942     MESSAGE(msg);
 943     return NULL;
 944 }
 945
 946 #define FAIL_WITH_ERR \
 947     ERR("v4l absent: shouldn't be called\n"); \
 948     return E_NOTIMPL
 949
 950 HRESULT qcap_driver_destroy(Capture *capBox)
 951 {
 952     FAIL_WITH_ERR;
 953 }
 954
 955 HRESULT qcap_driver_set_format(Capture *capBox, AM_MEDIA_TYPE * mT)
 956 {
 957     FAIL_WITH_ERR;
 958 }
 959
 960 HRESULT qcap_driver_get_format(const Capture *capBox, AM_MEDIA_TYPE ** mT)
 961 {
 962     FAIL_WITH_ERR;
 963 }
 964
 965 HRESULT qcap_driver_get_prop_range( Capture *capBox,
 966         VideoProcAmpProperty  Property, LONG *pMin, LONG *pMax,
 967         LONG *pSteppingDelta, LONG *pDefault, LONG *pCapsFlags )
 968 {
 969     FAIL_WITH_ERR;
 970 }
 971
 972 HRESULT qcap_driver_get_prop(Capture *capBox,
 973         VideoProcAmpProperty Property, LONG *lValue, LONG *Flags)
 974 {
 975     FAIL_WITH_ERR;
 976 }
 977
 978 HRESULT qcap_driver_set_prop(Capture *capBox, VideoProcAmpProperty Property,
 979         LONG lValue, LONG Flags)
 980 {
 981     FAIL_WITH_ERR;
 982 }
 983
 984 HRESULT qcap_driver_run(Capture *capBox, FILTER_STATE *state)
 985 {
 986     FAIL_WITH_ERR;
 987 }
 988
 989 HRESULT qcap_driver_pause(Capture *capBox, FILTER_STATE *state)
 990 {
 991     FAIL_WITH_ERR;
 992 }
 993
 994 HRESULT qcap_driver_stop(Capture *capBox, FILTER_STATE *state)
 995 {
 996     FAIL_WITH_ERR;
 997 }
 998
 999 #endif /* HAVE_LINUX_VIDEODEV_H */