[libav.git] / libavdevice / vfwcap.c

/*
 * VFW capture interface
 * Copyright (c) 2006-2008 Ramiro Polla.
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "avformat.h"
#include <vfw.h>
#include <windows.h>

//#define DEBUG_VFW

/* Defines for VFW missing from MinGW.
 * Remove this when MinGW incorporates them. */
#define WM_CAP_START                (0x0400)
#define WM_CAP_SET_CALLBACK_VIDEOSTREAM (WM_CAP_START + 6)
#define WM_CAP_DRIVER_CONNECT       (WM_CAP_START + 10)
#define WM_CAP_DRIVER_DISCONNECT    (WM_CAP_START + 11)
#define WM_CAP_GET_VIDEOFORMAT      (WM_CAP_START + 44)
#define WM_CAP_SET_VIDEOFORMAT      (WM_CAP_START + 45)
#define WM_CAP_SET_PREVIEW          (WM_CAP_START + 50)
#define WM_CAP_SET_OVERLAY          (WM_CAP_START + 51)
#define WM_CAP_SEQUENCE_NOFILE      (WM_CAP_START + 63)
#define WM_CAP_SET_SEQUENCE_SETUP   (WM_CAP_START + 64)
#define WM_CAP_GET_SEQUENCE_SETUP   (WM_CAP_START + 65)

#define HWND_MESSAGE                ((HWND)-3)

#define BI_RGB                      0

typedef struct videohdr_tag {
    LPBYTE      lpData;
    DWORD       dwBufferLength;
    DWORD       dwBytesUsed;
    DWORD       dwTimeCaptured;
    DWORD       dwUser;
    DWORD       dwFlags;
    DWORD_PTR   dwReserved[4];
} VIDEOHDR, NEAR *PVIDEOHDR, FAR * LPVIDEOHDR;

typedef struct {
    DWORD dwRequestMicroSecPerFrame;
    BOOL  fMakeUserHitOKToCapture;
    UINT  wPercentDropForError;
    BOOL  fYield;
    DWORD dwIndexSize;
    UINT  wChunkGranularity;
    BOOL  fUsingDOSMemory;
    UINT  wNumVideoRequested;
    BOOL  fCaptureAudio;
    UINT  wNumAudioRequested;
    UINT  vKeyAbort;
    BOOL  fAbortLeftMouse;
    BOOL  fAbortRightMouse;
    BOOL  fLimitEnabled;
    UINT  wTimeLimit;
    BOOL  fMCIControl;
    BOOL  fStepMCIDevice;
    DWORD dwMCIStartTime;
    DWORD dwMCIStopTime;
    BOOL  fStepCaptureAt2x;
    UINT  wStepCaptureAverageFrames;
    DWORD dwAudioBufferSize;
    BOOL  fDisableWriteCache;
    UINT  AVStreamMaster;
} CAPTUREPARMS;
/* End of missing MinGW defines */

struct vfw_ctx {
    HWND hwnd;
    HANDLE mutex;
    HANDLE event;
    AVPacketList *pktl;
    AVFormatContext *s;
    unsigned int curbufsize;
    unsigned int frame_num;
};

static enum PixelFormat vfw_pixfmt(DWORD biCompression, WORD biBitCount)
{
    switch(biCompression) {
    case MKTAG('Y', 'U', 'Y', '2'):
        return PIX_FMT_YUYV422;
    case BI_RGB:
        switch(biBitCount) { /* 1-8 are untested */
            case 1:
                return PIX_FMT_MONOWHITE;
            case 4:
                return PIX_FMT_RGB4;
            case 8:
                return PIX_FMT_RGB8;
            case 16:
                return PIX_FMT_RGB555;
            case 24:
                return PIX_FMT_BGR24;
            case 32:
                return PIX_FMT_RGB32;
        }
    }
    return -1;
}

#define dstruct(pctx, sname, var, type) \
    av_log(pctx, AV_LOG_DEBUG, #var":\t%"type"\n", sname->var)

static void dump_captureparms(AVFormatContext *s, CAPTUREPARMS *cparms)
{
    av_log(s, AV_LOG_DEBUG, "CAPTUREPARMS\n");
    dstruct(s, cparms, dwRequestMicroSecPerFrame, "lu");
    dstruct(s, cparms, fMakeUserHitOKToCapture, "d");
    dstruct(s, cparms, wPercentDropForError, "u");
    dstruct(s, cparms, fYield, "d");
    dstruct(s, cparms, dwIndexSize, "lu");
    dstruct(s, cparms, wChunkGranularity, "u");
    dstruct(s, cparms, fUsingDOSMemory, "d");
    dstruct(s, cparms, wNumVideoRequested, "u");
    dstruct(s, cparms, fCaptureAudio, "d");
    dstruct(s, cparms, wNumAudioRequested, "u");
    dstruct(s, cparms, vKeyAbort, "u");
    dstruct(s, cparms, fAbortLeftMouse, "d");
    dstruct(s, cparms, fAbortRightMouse, "d");
    dstruct(s, cparms, fLimitEnabled, "d");
    dstruct(s, cparms, wTimeLimit, "u");
    dstruct(s, cparms, fMCIControl, "d");
    dstruct(s, cparms, fStepMCIDevice, "d");
    dstruct(s, cparms, dwMCIStartTime, "lu");
    dstruct(s, cparms, dwMCIStopTime, "lu");
    dstruct(s, cparms, fStepCaptureAt2x, "d");
    dstruct(s, cparms, wStepCaptureAverageFrames, "u");
    dstruct(s, cparms, dwAudioBufferSize, "lu");
    dstruct(s, cparms, fDisableWriteCache, "d");
    dstruct(s, cparms, AVStreamMaster, "u");
}

static void dump_videohdr(AVFormatContext *s, VIDEOHDR *vhdr)
{
#ifdef DEBUG_VFW
    av_log(s, AV_LOG_DEBUG, "VIDEOHDR\n");
    dstruct(s, vhdr, lpData, "p");
    dstruct(s, vhdr, dwBufferLength, "lu");
    dstruct(s, vhdr, dwBytesUsed, "lu");
    dstruct(s, vhdr, dwTimeCaptured, "lu");
    dstruct(s, vhdr, dwUser, "lu");
    dstruct(s, vhdr, dwFlags, "lu");
    dstruct(s, vhdr, dwReserved[0], "lu");
    dstruct(s, vhdr, dwReserved[1], "lu");
    dstruct(s, vhdr, dwReserved[2], "lu");
    dstruct(s, vhdr, dwReserved[3], "lu");
#endif
}

static void dump_bih(AVFormatContext *s, BITMAPINFOHEADER *bih)
{
    av_log(s, AV_LOG_DEBUG, "BITMAPINFOHEADER\n");
    dstruct(s, bih, biSize, "lu");
    dstruct(s, bih, biWidth, "ld");
    dstruct(s, bih, biHeight, "ld");
    dstruct(s, bih, biPlanes, "d");
    dstruct(s, bih, biBitCount, "d");
    dstruct(s, bih, biCompression, "lu");
    av_log(s, AV_LOG_DEBUG, "    biCompression:\t\"%.4s\"\n",
                   (char*) &bih->biCompression);
    dstruct(s, bih, biSizeImage, "lu");
    dstruct(s, bih, biXPelsPerMeter, "lu");
    dstruct(s, bih, biYPelsPerMeter, "lu");
    dstruct(s, bih, biClrUsed, "lu");
    dstruct(s, bih, biClrImportant, "lu");
}

static int shall_we_drop(struct vfw_ctx *ctx)
{
    AVFormatContext *s = ctx->s;
    const uint8_t dropscore[] = {62, 75, 87, 100};
    const int ndropscores = sizeof(dropscore)/sizeof(dropscore[0]);
    unsigned int buffer_fullness = (ctx->curbufsize*100)/s->max_picture_buffer;

    if(dropscore[++ctx->frame_num%ndropscores] < buffer_fullness) {
        av_log(ctx->s, AV_LOG_ERROR,
              "real-time buffer %d%% full! frame dropped!\n", buffer_fullness);
        return 1;
    }

    return 0;
}

static LRESULT CALLBACK videostream_cb(HWND hwnd, LPVIDEOHDR vdhdr)
{
    struct vfw_ctx *ctx;
    AVPacketList **ppktl, *pktl_next;

    ctx = (struct vfw_ctx *) GetWindowLongPtr(hwnd, GWLP_USERDATA);

    dump_videohdr(ctx->s, vdhdr);

    if(shall_we_drop(ctx))
        return FALSE;

    WaitForSingleObject(ctx->mutex, INFINITE);

    pktl_next = av_mallocz(sizeof(AVPacketList));
    if(!pktl_next)
        goto fail;

    if(av_new_packet(&pktl_next->pkt, vdhdr->dwBytesUsed) < 0) {
        av_free(pktl_next);
        goto fail;
    }

    pktl_next->pkt.pts = vdhdr->dwTimeCaptured;
    memcpy(pktl_next->pkt.data, vdhdr->lpData, vdhdr->dwBytesUsed);

    for(ppktl = &ctx->pktl ; *ppktl ; ppktl = &(*ppktl)->next);
    *ppktl = pktl_next;

    ctx->curbufsize += vdhdr->dwBytesUsed;

    SetEvent(ctx->event);
    ReleaseMutex(ctx->mutex);

    return TRUE;
fail:
    ReleaseMutex(ctx->mutex);
    return FALSE;
}

static int vfw_read_close(AVFormatContext *s);

static int vfw_read_header(AVFormatContext *s, AVFormatParameters *ap)
{
    struct vfw_ctx *ctx = s->priv_data;
    AVCodecContext *codec;
    AVStream *st;
    int devnum;
    int bisize;
    BITMAPINFO *bi;
    CAPTUREPARMS cparms;
    DWORD biCompression;
    WORD biBitCount;
    int width;
    int height;
    int ret;

    if(!ap->time_base.den) {
        av_log(s, AV_LOG_ERROR, "A time base must be specified.\n");
        return AVERROR_IO;
    }

    ctx->s = s;

    ctx->hwnd = capCreateCaptureWindow(NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, 0);
    if(!ctx->hwnd) {
        av_log(s, AV_LOG_ERROR, "Could not create capture window.\n");
        return AVERROR_IO;
    }

    /* If atoi fails, devnum==0 and the default device is used */
    devnum = atoi(s->filename);

    ret = SendMessage(ctx->hwnd, WM_CAP_DRIVER_CONNECT, devnum, 0);
    if(!ret) {
        av_log(s, AV_LOG_ERROR, "Could not connect to device.\n");
        DestroyWindow(ctx->hwnd);
        return AVERROR(ENODEV);
    }

    SendMessage(ctx->hwnd, WM_CAP_SET_OVERLAY, 0, 0);
    SendMessage(ctx->hwnd, WM_CAP_SET_PREVIEW, 0, 0);

    ret = SendMessage(ctx->hwnd, WM_CAP_SET_CALLBACK_VIDEOSTREAM, 0,
                      (LPARAM) videostream_cb);
    if(!ret) {
        av_log(s, AV_LOG_ERROR, "Could not set video stream callback.\n");
        vfw_read_close(s);
        return AVERROR_IO;
    }

    SetWindowLongPtr(ctx->hwnd, GWLP_USERDATA, (LONG_PTR) ctx);

    st = av_new_stream(s, 0);
    if(!st) {
        vfw_read_close(s);
        return AVERROR_NOMEM;
    }

    /* Set video format */
    bisize = SendMessage(ctx->hwnd, WM_CAP_GET_VIDEOFORMAT, 0, 0);
    if(!bisize) {
        vfw_read_close(s);
        return AVERROR_IO;
    }
    bi = av_malloc(bisize);
    if(!bi) {
        vfw_read_close(s);
        return AVERROR_NOMEM;
    }
    ret = SendMessage(ctx->hwnd, WM_CAP_GET_VIDEOFORMAT, bisize, (LPARAM) bi);
    if(!ret) {
        av_free(bi);
        vfw_read_close(s);
        return AVERROR_IO;
    }

    dump_bih(s, &bi->bmiHeader);

    width  = ap->width  ? ap->width  : bi->bmiHeader.biWidth ;
    height = ap->height ? ap->height : bi->bmiHeader.biHeight;
    bi->bmiHeader.biWidth  = width ;
    bi->bmiHeader.biHeight = height;

    ret = SendMessage(ctx->hwnd, WM_CAP_SET_VIDEOFORMAT, bisize, (LPARAM) bi);
    if(!ret) {
        av_log(s, AV_LOG_ERROR, "Could not set Video Format.\n");
        av_free(bi);
        vfw_read_close(s);
        return AVERROR_IO;
    }

    biCompression = bi->bmiHeader.biCompression;
    biBitCount = bi->bmiHeader.biBitCount;

    av_free(bi);

    /* Set sequence setup */
    ret = SendMessage(ctx->hwnd, WM_CAP_GET_SEQUENCE_SETUP, sizeof(cparms),
                      (LPARAM) &cparms);
    if(!ret) {
        vfw_read_close(s);
        return AVERROR_IO;
    }

    dump_captureparms(s, &cparms);

    cparms.fYield = 1; // Spawn a background thread
    cparms.dwRequestMicroSecPerFrame =
                               (ap->time_base.num*1000000) / ap->time_base.den;
    cparms.fAbortLeftMouse = 0;
    cparms.fAbortRightMouse = 0;
    cparms.fCaptureAudio = 0;
    cparms.vKeyAbort = 0;

    ret = SendMessage(ctx->hwnd, WM_CAP_SET_SEQUENCE_SETUP, sizeof(cparms),
                      (LPARAM) &cparms);
    if(!ret) {
        vfw_read_close(s);
        return AVERROR_IO;
    }

    codec = st->codec;
    codec->time_base = ap->time_base;
    codec->codec_type = CODEC_TYPE_VIDEO;
    codec->width = width;
    codec->height = height;
    codec->codec_id = CODEC_ID_RAWVIDEO;
    codec->pix_fmt = vfw_pixfmt(biCompression, biBitCount);
    if(biCompression == BI_RGB)
        codec->bits_per_sample = biBitCount;

    av_set_pts_info(st, 32, 1, 1000);

    if(codec->pix_fmt == -1) {
        av_log(s, AV_LOG_ERROR, "Unknown compression type."
                         "Please report verbose (-v 99) debug information.\n");
        vfw_read_close(s);
        return AVERROR_PATCHWELCOME;
    }

    ctx->mutex = CreateMutex(NULL, 0, NULL);
    if(!ctx->mutex) {
        av_log(s, AV_LOG_ERROR, "Could not create Mutex.\n" );
        vfw_read_close(s);
        return AVERROR_IO;
    }
    ctx->event = CreateEvent(NULL, 1, 0, NULL);
    if(!ctx->event) {
        av_log(s, AV_LOG_ERROR, "Could not create Event.\n" );
        vfw_read_close(s);
        return AVERROR_IO;
    }

    ret = SendMessage(ctx->hwnd, WM_CAP_SEQUENCE_NOFILE, 0, 0);
    if(!ret) {
        av_log(s, AV_LOG_ERROR, "Could not start capture sequence.\n" );
        vfw_read_close(s);
        return AVERROR_IO;
    }

    return 0;
}

static int vfw_read_packet(AVFormatContext *s, AVPacket *pkt)
{
    struct vfw_ctx *ctx = s->priv_data;
    AVPacketList *pktl = NULL;

    while(!pktl) {
        WaitForSingleObject(ctx->mutex, INFINITE);
        pktl = ctx->pktl;
        if(ctx->pktl) {
            *pkt = ctx->pktl->pkt;
            ctx->pktl = ctx->pktl->next;
            av_free(pktl);
        }
        ResetEvent(ctx->event);
        ReleaseMutex(ctx->mutex);
        if(!pktl) {
            if(s->flags & AVFMT_FLAG_NONBLOCK) {
                return AVERROR(EAGAIN);
            } else {
                WaitForSingleObject(ctx->event, INFINITE);
            }
        }
    }

    ctx->curbufsize -= pkt->size;

    return pkt->size;
}

static int vfw_read_close(AVFormatContext *s)
{
    struct vfw_ctx *ctx = s->priv_data;

    if(ctx->hwnd) {
        SendMessage(ctx->hwnd, WM_CAP_SET_CALLBACK_VIDEOSTREAM, 0, 0);
        SendMessage(ctx->hwnd, WM_CAP_DRIVER_DISCONNECT, 0, 0);
        DestroyWindow(ctx->hwnd);
    }
    if(ctx->mutex)
        CloseHandle(ctx->mutex);
    if(ctx->event)
        CloseHandle(ctx->event);

    return 0;
}

AVInputFormat vfwcap_demuxer = {
    "vfwcap",
    "VFW video capture",
    sizeof(struct vfw_ctx),
    NULL,
    vfw_read_header,
    vfw_read_packet,
    vfw_read_close,
    .flags = AVFMT_NOFILE,
};
Commit	Line	Data
c2345207 RP	1	/*
	2	* VFW capture interface
	3	* Copyright (c) 2006-2008 Ramiro Polla.
	4	*
	5	* This file is part of FFmpeg.
	6	*
	7	* FFmpeg is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2.1 of the License, or (at your option) any later version.
	11	*
	12	* FFmpeg is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with FFmpeg; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	#include "avformat.h"
	23	#include <vfw.h>
	24	#include <windows.h>
	25
	26	//#define DEBUG_VFW
	27
	28	/* Defines for VFW missing from MinGW.
	29	* Remove this when MinGW incorporates them. */
	30	#define WM_CAP_START (0x0400)
	31	#define WM_CAP_SET_CALLBACK_VIDEOSTREAM (WM_CAP_START + 6)
	32	#define WM_CAP_DRIVER_CONNECT (WM_CAP_START + 10)
	33	#define WM_CAP_DRIVER_DISCONNECT (WM_CAP_START + 11)
	34	#define WM_CAP_GET_VIDEOFORMAT (WM_CAP_START + 44)
	35	#define WM_CAP_SET_VIDEOFORMAT (WM_CAP_START + 45)
	36	#define WM_CAP_SET_PREVIEW (WM_CAP_START + 50)
	37	#define WM_CAP_SET_OVERLAY (WM_CAP_START + 51)
	38	#define WM_CAP_SEQUENCE_NOFILE (WM_CAP_START + 63)
	39	#define WM_CAP_SET_SEQUENCE_SETUP (WM_CAP_START + 64)
	40	#define WM_CAP_GET_SEQUENCE_SETUP (WM_CAP_START + 65)
	41
	42	#define HWND_MESSAGE ((HWND)-3)
	43
	44	#define BI_RGB 0
	45
	46	typedef struct videohdr_tag {
	47	LPBYTE lpData;
	48	DWORD dwBufferLength;
	49	DWORD dwBytesUsed;
	50	DWORD dwTimeCaptured;
	51	DWORD dwUser;
	52	DWORD dwFlags;
	53	DWORD_PTR dwReserved[4];
	54	} VIDEOHDR, NEAR PVIDEOHDR, FAR LPVIDEOHDR;
	55
	56	typedef struct {
	57	DWORD dwRequestMicroSecPerFrame;
	58	BOOL fMakeUserHitOKToCapture;
	59	UINT wPercentDropForError;
	60	BOOL fYield;
	61	DWORD dwIndexSize;
	62	UINT wChunkGranularity;
	63	BOOL fUsingDOSMemory;
	64	UINT wNumVideoRequested;
65	BOOL fCaptureAudio;
66	UINT wNumAudioRequested;
67	UINT vKeyAbort;
68	BOOL fAbortLeftMouse;
69	BOOL fAbortRightMouse;
70	BOOL fLimitEnabled;
71	UINT wTimeLimit;
72	BOOL fMCIControl;
73	BOOL fStepMCIDevice;
74	DWORD dwMCIStartTime;
75	DWORD dwMCIStopTime;
76	BOOL fStepCaptureAt2x;
77	UINT wStepCaptureAverageFrames;
78	DWORD dwAudioBufferSize;
79	BOOL fDisableWriteCache;
80	UINT AVStreamMaster;
81	} CAPTUREPARMS;
82	/* End of missing MinGW defines */
83
84	struct vfw_ctx {
85	HWND hwnd;
86	HANDLE mutex;
87	HANDLE event;
88	AVPacketList *pktl;
89	AVFormatContext *s;
90	unsigned int curbufsize;
91	unsigned int frame_num;
92	};
93
94	static enum PixelFormat vfw_pixfmt(DWORD biCompression, WORD biBitCount)
95	{
96	switch(biCompression) {
97	case MKTAG('Y', 'U', 'Y', '2'):
98	return PIX_FMT_YUYV422;
99	case BI_RGB:
100	switch(biBitCount) { /* 1-8 are untested */
101	case 1:
102	return PIX_FMT_MONOWHITE;
103	case 4:
104	return PIX_FMT_RGB4;
105	case 8:
106	return PIX_FMT_RGB8;
107	case 16:
108	return PIX_FMT_RGB555;
109	case 24:
110	return PIX_FMT_BGR24;
111	case 32:
112	return PIX_FMT_RGB32;
113	}
114	}
115	return -1;
116	}
117
118	#define dstruct(pctx, sname, var, type) \
119	av_log(pctx, AV_LOG_DEBUG, #var":\t%"type"\n", sname->var)
120
121	static void dump_captureparms(AVFormatContext s, CAPTUREPARMS cparms)
122	{
123	av_log(s, AV_LOG_DEBUG, "CAPTUREPARMS\n");
124	dstruct(s, cparms, dwRequestMicroSecPerFrame, "lu");
125	dstruct(s, cparms, fMakeUserHitOKToCapture, "d");
126	dstruct(s, cparms, wPercentDropForError, "u");
127	dstruct(s, cparms, fYield, "d");
128	dstruct(s, cparms, dwIndexSize, "lu");
129	dstruct(s, cparms, wChunkGranularity, "u");
130	dstruct(s, cparms, fUsingDOSMemory, "d");
131	dstruct(s, cparms, wNumVideoRequested, "u");
132	dstruct(s, cparms, fCaptureAudio, "d");
133	dstruct(s, cparms, wNumAudioRequested, "u");
134	dstruct(s, cparms, vKeyAbort, "u");
135	dstruct(s, cparms, fAbortLeftMouse, "d");
136	dstruct(s, cparms, fAbortRightMouse, "d");
137	dstruct(s, cparms, fLimitEnabled, "d");
138	dstruct(s, cparms, wTimeLimit, "u");
139	dstruct(s, cparms, fMCIControl, "d");
140	dstruct(s, cparms, fStepMCIDevice, "d");
141	dstruct(s, cparms, dwMCIStartTime, "lu");
142	dstruct(s, cparms, dwMCIStopTime, "lu");
143	dstruct(s, cparms, fStepCaptureAt2x, "d");
144	dstruct(s, cparms, wStepCaptureAverageFrames, "u");
145	dstruct(s, cparms, dwAudioBufferSize, "lu");
146	dstruct(s, cparms, fDisableWriteCache, "d");
147	dstruct(s, cparms, AVStreamMaster, "u");
148	}
149
150	static void dump_videohdr(AVFormatContext s, VIDEOHDR vhdr)
151	{
152	#ifdef DEBUG_VFW
153	av_log(s, AV_LOG_DEBUG, "VIDEOHDR\n");
154	dstruct(s, vhdr, lpData, "p");
155	dstruct(s, vhdr, dwBufferLength, "lu");
156	dstruct(s, vhdr, dwBytesUsed, "lu");
157	dstruct(s, vhdr, dwTimeCaptured, "lu");
158	dstruct(s, vhdr, dwUser, "lu");
159	dstruct(s, vhdr, dwFlags, "lu");
160	dstruct(s, vhdr, dwReserved[0], "lu");
161	dstruct(s, vhdr, dwReserved[1], "lu");
162	dstruct(s, vhdr, dwReserved[2], "lu");
163	dstruct(s, vhdr, dwReserved[3], "lu");
164	#endif
165	}
166
167	static void dump_bih(AVFormatContext s, BITMAPINFOHEADER bih)
168	{
169	av_log(s, AV_LOG_DEBUG, "BITMAPINFOHEADER\n");
170	dstruct(s, bih, biSize, "lu");
171	dstruct(s, bih, biWidth, "ld");
172	dstruct(s, bih, biHeight, "ld");
173	dstruct(s, bih, biPlanes, "d");
174	dstruct(s, bih, biBitCount, "d");
175	dstruct(s, bih, biCompression, "lu");
176	av_log(s, AV_LOG_DEBUG, " biCompression:\t\"%.4s\"\n",
177	(char*) &bih->biCompression);
178	dstruct(s, bih, biSizeImage, "lu");
179	dstruct(s, bih, biXPelsPerMeter, "lu");
180	dstruct(s, bih, biYPelsPerMeter, "lu");
181	dstruct(s, bih, biClrUsed, "lu");
182	dstruct(s, bih, biClrImportant, "lu");
183	}
184
185	static int shall_we_drop(struct vfw_ctx *ctx)
186	{
187	AVFormatContext *s = ctx->s;
188	const uint8_t dropscore[] = {62, 75, 87, 100};
189	const int ndropscores = sizeof(dropscore)/sizeof(dropscore[0]);
190	unsigned int buffer_fullness = (ctx->curbufsize*100)/s->max_picture_buffer;
191
192	if(dropscore[++ctx->frame_num%ndropscores] < buffer_fullness) {
193	av_log(ctx->s, AV_LOG_ERROR,
194	"real-time buffer %d%% full! frame dropped!\n", buffer_fullness);
195	return 1;
196	}
197
198	return 0;
199	}
200
201	static LRESULT CALLBACK videostream_cb(HWND hwnd, LPVIDEOHDR vdhdr)
202	{
203	struct vfw_ctx *ctx;
204	AVPacketList *ppktl, pktl_next;
205
206	ctx = (struct vfw_ctx *) GetWindowLongPtr(hwnd, GWLP_USERDATA);
207
208	dump_videohdr(ctx->s, vdhdr);
209
210	if(shall_we_drop(ctx))
211	return FALSE;
212
213	WaitForSingleObject(ctx->mutex, INFINITE);
214
215	pktl_next = av_mallocz(sizeof(AVPacketList));
216	if(!pktl_next)
217	goto fail;
218
219	if(av_new_packet(&pktl_next->pkt, vdhdr->dwBytesUsed) < 0) {
220	av_free(pktl_next);
221	goto fail;
222	}
223
224	pktl_next->pkt.pts = vdhdr->dwTimeCaptured;
225	memcpy(pktl_next->pkt.data, vdhdr->lpData, vdhdr->dwBytesUsed);
226
227	for(ppktl = &ctx->pktl ; ppktl ; ppktl = &(ppktl)->next);
228	*ppktl = pktl_next;
229
230	ctx->curbufsize += vdhdr->dwBytesUsed;
231
232	SetEvent(ctx->event);
233	ReleaseMutex(ctx->mutex);
234
235	return TRUE;
236	fail:
237	ReleaseMutex(ctx->mutex);
238	return FALSE;
239	}
240
241	static int vfw_read_close(AVFormatContext *s);
242
243	static int vfw_read_header(AVFormatContext s, AVFormatParameters ap)
244	{
245	struct vfw_ctx *ctx = s->priv_data;
246	AVCodecContext *codec;
247	AVStream *st;
248	int devnum;
249	int bisize;
250	BITMAPINFO *bi;
251	CAPTUREPARMS cparms;
252	DWORD biCompression;
253	WORD biBitCount;
254	int width;
255	int height;
256	int ret;
257
258	if(!ap->time_base.den) {
259	av_log(s, AV_LOG_ERROR, "A time base must be specified.\n");
260	return AVERROR_IO;
261	}
262
263	ctx->s = s;
264
265	ctx->hwnd = capCreateCaptureWindow(NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, 0);
266	if(!ctx->hwnd) {
267	av_log(s, AV_LOG_ERROR, "Could not create capture window.\n");
268	return AVERROR_IO;
269	}
270
271	/* If atoi fails, devnum==0 and the default device is used */
272	devnum = atoi(s->filename);
273
274	ret = SendMessage(ctx->hwnd, WM_CAP_DRIVER_CONNECT, devnum, 0);
275	if(!ret) {
276	av_log(s, AV_LOG_ERROR, "Could not connect to device.\n");
277	DestroyWindow(ctx->hwnd);
278	return AVERROR(ENODEV);
279	}
280
281	SendMessage(ctx->hwnd, WM_CAP_SET_OVERLAY, 0, 0);
282	SendMessage(ctx->hwnd, WM_CAP_SET_PREVIEW, 0, 0);
283
284	ret = SendMessage(ctx->hwnd, WM_CAP_SET_CALLBACK_VIDEOSTREAM, 0,
285	(LPARAM) videostream_cb);
286	if(!ret) {
287	av_log(s, AV_LOG_ERROR, "Could not set video stream callback.\n");
288	vfw_read_close(s);
289	return AVERROR_IO;
290	}
291
292	SetWindowLongPtr(ctx->hwnd, GWLP_USERDATA, (LONG_PTR) ctx);
293
294	st = av_new_stream(s, 0);
295	if(!st) {
296	vfw_read_close(s);
297	return AVERROR_NOMEM;
298	}
299
300	/* Set video format */
301	bisize = SendMessage(ctx->hwnd, WM_CAP_GET_VIDEOFORMAT, 0, 0);
302	if(!bisize) {
303	vfw_read_close(s);
304	return AVERROR_IO;
305	}
306	bi = av_malloc(bisize);
307	if(!bi) {
308	vfw_read_close(s);
309	return AVERROR_NOMEM;
310	}
311	ret = SendMessage(ctx->hwnd, WM_CAP_GET_VIDEOFORMAT, bisize, (LPARAM) bi);
312	if(!ret) {
313	av_free(bi);
314	vfw_read_close(s);
315	return AVERROR_IO;
316	}
317
318	dump_bih(s, &bi->bmiHeader);
319
320	width = ap->width ? ap->width : bi->bmiHeader.biWidth ;
321	height = ap->height ? ap->height : bi->bmiHeader.biHeight;
322	bi->bmiHeader.biWidth = width ;
323	bi->bmiHeader.biHeight = height;
324
325	ret = SendMessage(ctx->hwnd, WM_CAP_SET_VIDEOFORMAT, bisize, (LPARAM) bi);
326	if(!ret) {
327	av_log(s, AV_LOG_ERROR, "Could not set Video Format.\n");
328	av_free(bi);
329	vfw_read_close(s);
330	return AVERROR_IO;
331	}
332
333	biCompression = bi->bmiHeader.biCompression;
334	biBitCount = bi->bmiHeader.biBitCount;
335
336	av_free(bi);
337
338	/* Set sequence setup */
339	ret = SendMessage(ctx->hwnd, WM_CAP_GET_SEQUENCE_SETUP, sizeof(cparms),
340	(LPARAM) &cparms);
341	if(!ret) {
342	vfw_read_close(s);
343	return AVERROR_IO;
344	}
345
346	dump_captureparms(s, &cparms);
347
348	cparms.fYield = 1; // Spawn a background thread
349	cparms.dwRequestMicroSecPerFrame =
350	(ap->time_base.num*1000000) / ap->time_base.den;
351	cparms.fAbortLeftMouse = 0;
352	cparms.fAbortRightMouse = 0;
353	cparms.fCaptureAudio = 0;
354	cparms.vKeyAbort = 0;
355
356	ret = SendMessage(ctx->hwnd, WM_CAP_SET_SEQUENCE_SETUP, sizeof(cparms),
357	(LPARAM) &cparms);
358	if(!ret) {
359	vfw_read_close(s);
360	return AVERROR_IO;
361	}
362
363	codec = st->codec;
364	codec->time_base = ap->time_base;
365	codec->codec_type = CODEC_TYPE_VIDEO;
366	codec->width = width;
367	codec->height = height;
368	codec->codec_id = CODEC_ID_RAWVIDEO;
369	codec->pix_fmt = vfw_pixfmt(biCompression, biBitCount);
370	if(biCompression == BI_RGB)
371	codec->bits_per_sample = biBitCount;
372
373	av_set_pts_info(st, 32, 1, 1000);
374
375	if(codec->pix_fmt == -1) {
376	av_log(s, AV_LOG_ERROR, "Unknown compression type."
377	"Please report verbose (-v 99) debug information.\n");
378	vfw_read_close(s);
379	return AVERROR_PATCHWELCOME;
380	}
381
382	ctx->mutex = CreateMutex(NULL, 0, NULL);
383	if(!ctx->mutex) {
384	av_log(s, AV_LOG_ERROR, "Could not create Mutex.\n" );
385	vfw_read_close(s);
386	return AVERROR_IO;
387	}
388	ctx->event = CreateEvent(NULL, 1, 0, NULL);
389	if(!ctx->event) {
390	av_log(s, AV_LOG_ERROR, "Could not create Event.\n" );
391	vfw_read_close(s);
392	return AVERROR_IO;
393	}
394
395	ret = SendMessage(ctx->hwnd, WM_CAP_SEQUENCE_NOFILE, 0, 0);
396	if(!ret) {
397	av_log(s, AV_LOG_ERROR, "Could not start capture sequence.\n" );
398	vfw_read_close(s);
399	return AVERROR_IO;
400	}
401
402	return 0;
403	}
404
405	static int vfw_read_packet(AVFormatContext s, AVPacket pkt)
406	{
407	struct vfw_ctx *ctx = s->priv_data;
408	AVPacketList *pktl = NULL;
409
410	while(!pktl) {
411	WaitForSingleObject(ctx->mutex, INFINITE);
412	pktl = ctx->pktl;
413	if(ctx->pktl) {
414	*pkt = ctx->pktl->pkt;
415	ctx->pktl = ctx->pktl->next;
416	av_free(pktl);
417	}
418	ResetEvent(ctx->event);
419	ReleaseMutex(ctx->mutex);
420	if(!pktl) {
421	if(s->flags & AVFMT_FLAG_NONBLOCK) {
422	return AVERROR(EAGAIN);
423	} else {
424	WaitForSingleObject(ctx->event, INFINITE);
425	}
426	}
427	}
428
429	ctx->curbufsize -= pkt->size;
430
431	return pkt->size;
432	}
433
434	static int vfw_read_close(AVFormatContext *s)
435	{
436	struct vfw_ctx *ctx = s->priv_data;
437
438	if(ctx->hwnd) {
439	SendMessage(ctx->hwnd, WM_CAP_SET_CALLBACK_VIDEOSTREAM, 0, 0);
440	SendMessage(ctx->hwnd, WM_CAP_DRIVER_DISCONNECT, 0, 0);
441	DestroyWindow(ctx->hwnd);
442	}
443	if(ctx->mutex)
444	CloseHandle(ctx->mutex);
445	if(ctx->event)
446	CloseHandle(ctx->event);
447
448	return 0;
449	}
450
451	AVInputFormat vfwcap_demuxer = {
452	"vfwcap",
453	"VFW video capture",
454	sizeof(struct vfw_ctx),
455	NULL,
456	vfw_read_header,
457	vfw_read_packet,
458	vfw_read_close,
459	.flags = AVFMT_NOFILE,
460	};