dshow: indent
[ffmpeg.git] / libavdevice / dshow.c
1 /*
2  * Directshow capture interface
3  * Copyright (c) 2010 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 "libavutil/opt.h"
23
24 #include "avdevice.h"
25 #include "dshow.h"
26
27 struct dshow_ctx {
28     const AVClass *class;
29
30     IGraphBuilder *graph;
31
32     char *device_name[2];
33
34     int   list_devices;
35
36     IBaseFilter *device_filter[2];
37     IPin        *device_pin[2];
38     libAVFilter *capture_filter[2];
39     libAVPin    *capture_pin[2];
40
41     HANDLE mutex;
42     HANDLE event;
43     AVPacketList *pktl;
44
45     unsigned int curbufsize;
46     unsigned int video_frame_num;
47
48     IMediaControl *control;
49 };
50
51 static enum PixelFormat dshow_pixfmt(DWORD biCompression, WORD biBitCount)
52 {
53     switch(biCompression) {
54     case MKTAG('U', 'Y', 'V', 'Y'):
55         return PIX_FMT_UYVY422;
56     case MKTAG('Y', 'U', 'Y', '2'):
57         return PIX_FMT_YUYV422;
58     case MKTAG('I', '4', '2', '0'):
59         return PIX_FMT_YUV420P;
60     case BI_RGB:
61         switch(biBitCount) { /* 1-8 are untested */
62             case 1:
63                 return PIX_FMT_MONOWHITE;
64             case 4:
65                 return PIX_FMT_RGB4;
66             case 8:
67                 return PIX_FMT_RGB8;
68             case 16:
69                 return PIX_FMT_RGB555;
70             case 24:
71                 return PIX_FMT_BGR24;
72             case 32:
73                 return PIX_FMT_RGB32;
74         }
75     }
76     return PIX_FMT_NONE;
77 }
78
79 static enum CodecID dshow_codecid(DWORD biCompression)
80 {
81     switch(biCompression) {
82     case MKTAG('d', 'v', 's', 'd'):
83         return CODEC_ID_DVVIDEO;
84     case MKTAG('M', 'J', 'P', 'G'):
85     case MKTAG('m', 'j', 'p', 'g'):
86         return CODEC_ID_MJPEG;
87     }
88     return CODEC_ID_NONE;
89 }
90
91 static int
92 dshow_read_close(AVFormatContext *s)
93 {
94     struct dshow_ctx *ctx = s->priv_data;
95     AVPacketList *pktl;
96
97     if (ctx->control) {
98         IMediaControl_Stop(ctx->control);
99         IMediaControl_Release(ctx->control);
100     }
101
102     if (ctx->capture_pin[VideoDevice])
103         libAVPin_Release(ctx->capture_pin[VideoDevice]);
104     if (ctx->capture_pin[AudioDevice])
105         libAVPin_Release(ctx->capture_pin[AudioDevice]);
106     if (ctx->capture_filter[VideoDevice])
107         libAVFilter_Release(ctx->capture_filter[VideoDevice]);
108     if (ctx->capture_filter[AudioDevice])
109         libAVFilter_Release(ctx->capture_filter[AudioDevice]);
110
111     if (ctx->device_pin[VideoDevice])
112         IPin_Release(ctx->device_pin[VideoDevice]);
113     if (ctx->device_pin[AudioDevice])
114         IPin_Release(ctx->device_pin[AudioDevice]);
115     if (ctx->device_filter[VideoDevice])
116         IBaseFilter_Release(ctx->device_filter[VideoDevice]);
117     if (ctx->device_filter[AudioDevice])
118         IBaseFilter_Release(ctx->device_filter[AudioDevice]);
119
120     if (ctx->graph) {
121         IEnumFilters *fenum;
122         int r;
123         r = IGraphBuilder_EnumFilters(ctx->graph, &fenum);
124         if (r == S_OK) {
125             IBaseFilter *f;
126             IEnumFilters_Reset(fenum);
127             while (IEnumFilters_Next(fenum, 1, &f, NULL) == S_OK)
128                 IGraphBuilder_RemoveFilter(ctx->graph, f);
129             IEnumFilters_Release(fenum);
130         }
131         IGraphBuilder_Release(ctx->graph);
132     }
133
134     if (ctx->device_name[0])
135         av_free(ctx->device_name[0]);
136     if (ctx->device_name[1])
137         av_free(ctx->device_name[1]);
138
139     if(ctx->mutex)
140         CloseHandle(ctx->mutex);
141     if(ctx->event)
142         CloseHandle(ctx->event);
143
144     pktl = ctx->pktl;
145     while (pktl) {
146         AVPacketList *next = pktl->next;
147         av_destruct_packet(&pktl->pkt);
148         av_free(pktl);
149         pktl = next;
150     }
151
152     return 0;
153 }
154
155 static char *dup_wchar_to_utf8(wchar_t *w)
156 {
157     char *s = NULL;
158     int l = WideCharToMultiByte(CP_UTF8, 0, w, -1, 0, 0, 0, 0);
159     s = av_malloc(l);
160     if (s)
161         WideCharToMultiByte(CP_UTF8, 0, w, -1, s, l, 0, 0);
162     return s;
163 }
164
165 static int shall_we_drop(AVFormatContext *s)
166 {
167     struct dshow_ctx *ctx = s->priv_data;
168     const uint8_t dropscore[] = {62, 75, 87, 100};
169     const int ndropscores = FF_ARRAY_ELEMS(dropscore);
170     unsigned int buffer_fullness = (ctx->curbufsize*100)/s->max_picture_buffer;
171
172     if(dropscore[++ctx->video_frame_num%ndropscores] <= buffer_fullness) {
173         av_log(s, AV_LOG_ERROR,
174               "real-time buffer %d%% full! frame dropped!\n", buffer_fullness);
175         return 1;
176     }
177
178     return 0;
179 }
180
181 static void
182 callback(void *priv_data, int index, uint8_t *buf, int buf_size, int64_t time)
183 {
184     AVFormatContext *s = priv_data;
185     struct dshow_ctx *ctx = s->priv_data;
186     AVPacketList **ppktl, *pktl_next;
187
188 //    dump_videohdr(s, vdhdr);
189
190     if(shall_we_drop(s))
191         return;
192
193     WaitForSingleObject(ctx->mutex, INFINITE);
194
195     pktl_next = av_mallocz(sizeof(AVPacketList));
196     if(!pktl_next)
197         goto fail;
198
199     if(av_new_packet(&pktl_next->pkt, buf_size) < 0) {
200         av_free(pktl_next);
201         goto fail;
202     }
203
204     pktl_next->pkt.stream_index = index;
205     pktl_next->pkt.pts = time;
206     memcpy(pktl_next->pkt.data, buf, buf_size);
207
208     for(ppktl = &ctx->pktl ; *ppktl ; ppktl = &(*ppktl)->next);
209     *ppktl = pktl_next;
210
211     ctx->curbufsize += buf_size;
212
213     SetEvent(ctx->event);
214     ReleaseMutex(ctx->mutex);
215
216     return;
217 fail:
218     ReleaseMutex(ctx->mutex);
219     return;
220 }
221
222 /**
223  * Cycle through available devices using the device enumerator devenum,
224  * retrieve the device with type specified by devtype and return the
225  * pointer to the object found in *pfilter.
226  * If pfilter is NULL, list all device names.
227  */
228 static int
229 dshow_cycle_devices(AVFormatContext *avctx, ICreateDevEnum *devenum,
230                     enum dshowDeviceType devtype, IBaseFilter **pfilter)
231 {
232     struct dshow_ctx *ctx = avctx->priv_data;
233     IBaseFilter *device_filter = NULL;
234     IEnumMoniker *classenum = NULL;
235     IMoniker *m = NULL;
236     const char *device_name = ctx->device_name[devtype];
237     int r;
238
239     const GUID *device_guid[2] = { &CLSID_VideoInputDeviceCategory,
240                                    &CLSID_AudioInputDeviceCategory };
241     const char *devtypename = (devtype == VideoDevice) ? "video" : "audio";
242
243     r = ICreateDevEnum_CreateClassEnumerator(devenum, device_guid[devtype],
244                                              (IEnumMoniker **) &classenum, 0);
245     if (r != S_OK) {
246         av_log(avctx, AV_LOG_ERROR, "Could not enumerate %s devices.\n",
247                devtypename);
248         return AVERROR(EIO);
249     }
250
251     while (IEnumMoniker_Next(classenum, 1, &m, NULL) == S_OK && !device_filter) {
252         IPropertyBag *bag = NULL;
253         char *buf = NULL;
254         VARIANT var;
255
256         r = IMoniker_BindToStorage(m, 0, 0, &IID_IPropertyBag, (void *) &bag);
257         if (r != S_OK)
258             goto fail1;
259
260         var.vt = VT_BSTR;
261         r = IPropertyBag_Read(bag, L"FriendlyName", &var, NULL);
262         if (r != S_OK)
263             goto fail1;
264
265         buf = dup_wchar_to_utf8(var.bstrVal);
266
267         if (pfilter) {
268             if (strcmp(device_name, buf))
269                 goto fail1;
270
271             IMoniker_BindToObject(m, 0, 0, &IID_IBaseFilter, (void *) &device_filter);
272         } else {
273             av_log(avctx, AV_LOG_INFO, " \"%s\"\n", buf);
274         }
275
276 fail1:
277         if (buf)
278             av_free(buf);
279         if (bag)
280             IPropertyBag_Release(bag);
281         IMoniker_Release(m);
282     }
283
284     IEnumMoniker_Release(classenum);
285
286     if (pfilter) {
287         if (!device_filter) {
288             av_log(avctx, AV_LOG_ERROR, "Could not find %s device.\n",
289                    devtypename);
290             return AVERROR(EIO);
291         }
292         *pfilter = device_filter;
293     }
294
295     return 0;
296 }
297
298 static int
299 dshow_open_device(AVFormatContext *avctx, ICreateDevEnum *devenum,
300                   enum dshowDeviceType devtype)
301 {
302     struct dshow_ctx *ctx = avctx->priv_data;
303     IBaseFilter *device_filter = NULL;
304     IGraphBuilder *graph = ctx->graph;
305     IEnumPins *pins = 0;
306     IPin *device_pin = NULL;
307     libAVPin *capture_pin = NULL;
308     libAVFilter *capture_filter = NULL;
309     int ret = AVERROR(EIO);
310     IPin *pin;
311     int r;
312
313     const GUID *mediatype[2] = { &MEDIATYPE_Video, &MEDIATYPE_Audio };
314     const char *devtypename = (devtype == VideoDevice) ? "video" : "audio";
315     const wchar_t *filter_name[2] = { L"Audio capture filter", L"Video capture filter" };
316
317     if ((r = dshow_cycle_devices(avctx, devenum, devtype, &device_filter)) < 0) {
318         ret = r;
319         goto error;
320     }
321
322     ctx->device_filter [devtype] = device_filter;
323
324     r = IGraphBuilder_AddFilter(graph, device_filter, NULL);
325     if (r != S_OK) {
326         av_log(avctx, AV_LOG_ERROR, "Could not add device filter to graph.\n");
327         goto error;
328     }
329
330     r = IBaseFilter_EnumPins(device_filter, &pins);
331     if (r != S_OK) {
332         av_log(avctx, AV_LOG_ERROR, "Could not enumerate pins.\n");
333         goto error;
334     }
335
336     while (IEnumPins_Next(pins, 1, &pin, NULL) == S_OK && !device_pin) {
337         IKsPropertySet *p = NULL;
338         IEnumMediaTypes *types;
339         PIN_INFO info = {0};
340         AM_MEDIA_TYPE *type;
341         GUID category;
342         DWORD r2;
343
344         IPin_QueryPinInfo(pin, &info);
345         IBaseFilter_Release(info.pFilter);
346
347         if (info.dir != PINDIR_OUTPUT)
348             goto next;
349         if (IPin_QueryInterface(pin, &IID_IKsPropertySet, (void **) &p) != S_OK)
350             goto next;
351         if (IKsPropertySet_Get(p, &AMPROPSETID_Pin, AMPROPERTY_PIN_CATEGORY,
352                                NULL, 0, &category, sizeof(GUID), &r2) != S_OK)
353             goto next;
354         if (!IsEqualGUID(&category, &PIN_CATEGORY_CAPTURE))
355             goto next;
356
357         if (IPin_EnumMediaTypes(pin, &types) != S_OK)
358             goto next;
359
360         IEnumMediaTypes_Reset(types);
361         while (IEnumMediaTypes_Next(types, 1, &type, NULL) == S_OK && !device_pin) {
362             if (IsEqualGUID(&type->majortype, mediatype[devtype])) {
363                 device_pin = pin;
364                 goto next;
365             }
366             CoTaskMemFree(type);
367         }
368
369 next:
370         if (types)
371             IEnumMediaTypes_Release(types);
372         if (p)
373             IKsPropertySet_Release(p);
374         if (device_pin != pin)
375             IPin_Release(pin);
376     }
377
378     if (!device_pin) {
379         av_log(avctx, AV_LOG_ERROR,
380                "Could not find output pin from %s capture device.\n", devtypename);
381         goto error;
382     }
383     ctx->device_pin[devtype] = device_pin;
384
385     capture_filter = libAVFilter_Create(avctx, callback, devtype);
386     if (!capture_filter) {
387         av_log(avctx, AV_LOG_ERROR, "Could not create grabber filter.\n");
388         goto error;
389     }
390     ctx->capture_filter[devtype] = capture_filter;
391
392     r = IGraphBuilder_AddFilter(graph, (IBaseFilter *) capture_filter,
393                                 filter_name[devtype]);
394     if (r != S_OK) {
395         av_log(avctx, AV_LOG_ERROR, "Could not add capture filter to graph\n");
396         goto error;
397     }
398
399     libAVPin_AddRef(capture_filter->pin);
400     capture_pin = capture_filter->pin;
401     ctx->capture_pin[devtype] = capture_pin;
402
403     r = IGraphBuilder_ConnectDirect(graph, device_pin, (IPin *) capture_pin, NULL);
404     if (r != S_OK) {
405         av_log(avctx, AV_LOG_ERROR, "Could not connect pins\n");
406         goto error;
407     }
408
409     ret = 0;
410
411 error:
412     if (pins)
413         IEnumPins_Release(pins);
414
415     return ret;
416 }
417
418 static enum CodecID waveform_codec_id(enum AVSampleFormat sample_fmt)
419 {
420     switch (sample_fmt) {
421     case AV_SAMPLE_FMT_U8:  return CODEC_ID_PCM_U8;
422     case AV_SAMPLE_FMT_S16: return CODEC_ID_PCM_S16LE;
423     case AV_SAMPLE_FMT_S32: return CODEC_ID_PCM_S32LE;
424     default:                return CODEC_ID_NONE; /* Should never happen. */
425     }
426 }
427
428 static enum SampleFormat sample_fmt_bits_per_sample(int bits)
429 {
430     switch (bits) {
431     case 8:  return AV_SAMPLE_FMT_U8;
432     case 16: return AV_SAMPLE_FMT_S16;
433     case 32: return AV_SAMPLE_FMT_S32;
434     default: return AV_SAMPLE_FMT_NONE; /* Should never happen. */
435     }
436 }
437
438 static int
439 dshow_add_device(AVFormatContext *avctx, AVFormatParameters *ap,
440                  enum dshowDeviceType devtype)
441 {
442     struct dshow_ctx *ctx = avctx->priv_data;
443     AM_MEDIA_TYPE type;
444     AVCodecContext *codec;
445     AVStream *st;
446     int ret = AVERROR(EIO);
447
448     st = av_new_stream(avctx, devtype);
449     if (!st) {
450         ret = AVERROR(ENOMEM);
451         goto error;
452     }
453
454     ctx->capture_filter[devtype]->stream_index = st->index;
455
456     libAVPin_ConnectionMediaType(ctx->capture_pin[devtype], &type);
457
458     codec = st->codec;
459     if (devtype == VideoDevice) {
460         BITMAPINFOHEADER *bih = NULL;
461
462         if (IsEqualGUID(&type.formattype, &FORMAT_VideoInfo)) {
463             VIDEOINFOHEADER *v = (void *) type.pbFormat;
464             bih = &v->bmiHeader;
465         } else if (IsEqualGUID(&type.formattype, &FORMAT_VideoInfo2)) {
466             VIDEOINFOHEADER2 *v = (void *) type.pbFormat;
467             bih = &v->bmiHeader;
468         }
469         if (!bih) {
470             av_log(avctx, AV_LOG_ERROR, "Could not get media type.\n");
471             goto error;
472         }
473
474         codec->time_base  = ap->time_base;
475         codec->codec_type = AVMEDIA_TYPE_VIDEO;
476         codec->width      = bih->biWidth;
477         codec->height     = bih->biHeight;
478         codec->pix_fmt    = dshow_pixfmt(bih->biCompression, bih->biBitCount);
479         if (codec->pix_fmt == PIX_FMT_NONE) {
480             codec->codec_id = dshow_codecid(bih->biCompression);
481             if (codec->codec_id == CODEC_ID_NONE) {
482                 av_log(avctx, AV_LOG_ERROR, "Unknown compression type. "
483                                  "Please report verbose (-v 9) debug information.\n");
484                 dshow_read_close(avctx);
485                 return AVERROR_PATCHWELCOME;
486             }
487             codec->bits_per_coded_sample = bih->biBitCount;
488         } else {
489             codec->codec_id = CODEC_ID_RAWVIDEO;
490             if (bih->biCompression == BI_RGB) {
491                 codec->bits_per_coded_sample = bih->biBitCount;
492                 codec->extradata = av_malloc(9 + FF_INPUT_BUFFER_PADDING_SIZE);
493                 if (codec->extradata) {
494                     codec->extradata_size = 9;
495                     memcpy(codec->extradata, "BottomUp", 9);
496                 }
497             }
498         }
499     } else {
500         WAVEFORMATEX *fx = NULL;
501
502         if (IsEqualGUID(&type.formattype, &FORMAT_WaveFormatEx)) {
503             fx = (void *) type.pbFormat;
504         }
505         if (!fx) {
506             av_log(avctx, AV_LOG_ERROR, "Could not get media type.\n");
507             goto error;
508         }
509
510         codec->codec_type  = AVMEDIA_TYPE_AUDIO;
511         codec->sample_fmt  = sample_fmt_bits_per_sample(fx->wBitsPerSample);
512         codec->codec_id    = waveform_codec_id(codec->sample_fmt);
513         codec->sample_rate = fx->nSamplesPerSec;
514         codec->channels    = fx->nChannels;
515     }
516
517     av_set_pts_info(st, 64, 1, 10000000);
518
519     ret = 0;
520
521 error:
522     return ret;
523 }
524
525 static int parse_device_name(AVFormatContext *avctx)
526 {
527     struct dshow_ctx *ctx = avctx->priv_data;
528     char **device_name = ctx->device_name;
529     char *name = av_strdup(avctx->filename);
530     char *tmp = name;
531     int ret = 1;
532     char *type;
533
534     while ((type = strtok(tmp, "="))) {
535         char *token = strtok(NULL, ":");
536         tmp = NULL;
537
538         if        (!strcmp(type, "video")) {
539             device_name[0] = token;
540         } else if (!strcmp(type, "audio")) {
541             device_name[1] = token;
542         } else {
543             device_name[0] = NULL;
544             device_name[1] = NULL;
545             break;
546         }
547     }
548
549     if (!device_name[0] && !device_name[1]) {
550         ret = 0;
551     } else {
552         if (device_name[0])
553             device_name[0] = av_strdup(device_name[0]);
554         if (device_name[1])
555             device_name[1] = av_strdup(device_name[1]);
556     }
557
558     av_free(name);
559     return ret;
560 }
561
562 static int dshow_read_header(AVFormatContext *avctx, AVFormatParameters *ap)
563 {
564     struct dshow_ctx *ctx = avctx->priv_data;
565     IGraphBuilder *graph = NULL;
566     ICreateDevEnum *devenum = NULL;
567     IMediaControl *control = NULL;
568     int ret = AVERROR(EIO);
569     int r;
570
571     if (!ctx->list_devices && !parse_device_name(avctx)) {
572         av_log(avctx, AV_LOG_ERROR, "Malformed dshow input string.\n");
573         goto error;
574     }
575
576     CoInitialize(0);
577
578     r = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
579                          &IID_IGraphBuilder, (void **) &graph);
580     if (r != S_OK) {
581         av_log(avctx, AV_LOG_ERROR, "Could not create capture graph.\n");
582         goto error;
583     }
584     ctx->graph = graph;
585
586     r = CoCreateInstance(&CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
587                          &IID_ICreateDevEnum, (void **) &devenum);
588     if (r != S_OK) {
589         av_log(avctx, AV_LOG_ERROR, "Could not enumerate system devices.\n");
590         goto error;
591     }
592
593     if (ctx->list_devices) {
594         av_log(avctx, AV_LOG_INFO, "DirectShow video devices\n");
595         dshow_cycle_devices(avctx, devenum, VideoDevice, NULL);
596         av_log(avctx, AV_LOG_INFO, "DirectShow audio devices\n");
597         dshow_cycle_devices(avctx, devenum, AudioDevice, NULL);
598         ret = AVERROR_EXIT;
599         goto error;
600     }
601
602     if (ctx->device_name[VideoDevice]) {
603         ret = dshow_open_device(avctx, devenum, VideoDevice);
604         if (ret < 0)
605             goto error;
606         ret = dshow_add_device(avctx, ap, VideoDevice);
607         if (ret < 0)
608             goto error;
609     }
610     if (ctx->device_name[AudioDevice]) {
611         ret = dshow_open_device(avctx, devenum, AudioDevice);
612         if (ret < 0)
613             goto error;
614         ret = dshow_add_device(avctx, ap, AudioDevice);
615         if (ret < 0)
616             goto error;
617     }
618
619     ctx->mutex = CreateMutex(NULL, 0, NULL);
620     if (!ctx->mutex) {
621         av_log(avctx, AV_LOG_ERROR, "Could not create Mutex\n");
622         goto error;
623     }
624     ctx->event = CreateEvent(NULL, 1, 0, NULL);
625     if (!ctx->event) {
626         av_log(avctx, AV_LOG_ERROR, "Could not create Event\n");
627         goto error;
628     }
629
630     r = IGraphBuilder_QueryInterface(graph, &IID_IMediaControl, (void **) &control);
631     if (r != S_OK) {
632         av_log(avctx, AV_LOG_ERROR, "Could not get media control.\n");
633         goto error;
634     }
635     ctx->control = control;
636
637     r = IMediaControl_Run(control);
638     if (r == S_FALSE) {
639         OAFilterState pfs;
640         r = IMediaControl_GetState(control, 0, &pfs);
641     }
642     if (r != S_OK) {
643         av_log(avctx, AV_LOG_ERROR, "Could not run filter\n");
644         goto error;
645     }
646
647     ret = 0;
648
649 error:
650
651     if (ret < 0)
652         dshow_read_close(avctx);
653
654     if (devenum)
655         ICreateDevEnum_Release(devenum);
656
657     return ret;
658 }
659
660 static int dshow_read_packet(AVFormatContext *s, AVPacket *pkt)
661 {
662     struct dshow_ctx *ctx = s->priv_data;
663     AVPacketList *pktl = NULL;
664
665     while (!pktl) {
666         WaitForSingleObject(ctx->mutex, INFINITE);
667         pktl = ctx->pktl;
668         if (ctx->pktl) {
669             *pkt = ctx->pktl->pkt;
670             ctx->pktl = ctx->pktl->next;
671             av_free(pktl);
672         }
673         ResetEvent(ctx->event);
674         ReleaseMutex(ctx->mutex);
675         if (!pktl) {
676             if (s->flags & AVFMT_FLAG_NONBLOCK) {
677                 return AVERROR(EAGAIN);
678             } else {
679                 WaitForSingleObject(ctx->event, INFINITE);
680             }
681         }
682     }
683
684     ctx->curbufsize -= pkt->size;
685
686     return pkt->size;
687 }
688
689 #define OFFSET(x) offsetof(struct dshow_ctx, x)
690 #define DEC AV_OPT_FLAG_DECODING_PARAM
691 static const AVOption options[] = {
692     { "list_devices", "list available devices", OFFSET(list_devices), FF_OPT_TYPE_INT, {.dbl=0}, 0, 1, DEC, "list_devices" },
693     { "true", "", 0, FF_OPT_TYPE_CONST, {.dbl=1}, 0, 0, DEC, "list_devices" },
694     { "false", "", 0, FF_OPT_TYPE_CONST, {.dbl=0}, 0, 0, DEC, "list_devices" },
695     { NULL },
696 };
697
698 static const AVClass dshow_class = {
699     .class_name = "DirectShow indev",
700     .item_name  = av_default_item_name,
701     .option     = options,
702     .version    = LIBAVUTIL_VERSION_INT,
703 };
704
705 AVInputFormat ff_dshow_demuxer = {
706     "dshow",
707     NULL_IF_CONFIG_SMALL("DirectShow capture"),
708     sizeof(struct dshow_ctx),
709     NULL,
710     dshow_read_header,
711     dshow_read_packet,
712     dshow_read_close,
713     .flags = AVFMT_NOFILE,
714     .priv_class = &dshow_class,
715 };