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