FFmpeg: libavdevice/dshow.c Source File

FFmpeg

[フレーム]

libavdevice

dshow.c

Go to the documentation of this file.

1 /*

2 * Directshow capture interface

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 */

22 #include "dshow_capture.h"

23 #include "libavutil/parseutils.h"

24 #include "libavutil/pixdesc.h"

25 #include "libavutil/opt.h"

26 #include "libavutil/mem.h"

27 #include "libavformat/internal.h"

28 #include "libavformat/riff.h"

29 #include "avdevice.h"

30 #include "libavcodec/raw.h"

31 #include "objidl.h"

32 #include "shlwapi.h"

33 // NB: technically, we should include dxva.h and use

34 // DXVA_ExtendedFormat, but that type is not defined in

35 // the MinGW headers. The DXVA2_ExtendedFormat and the

36 // contents of its fields is identical to

37 // DXVA_ExtendedFormat (see https://docs.microsoft.com/en-us/windows/win32/medfound/extended-color-information#color-space-in-media-types)

38 // and is provided by MinGW as well, so we use that

39 // instead. NB also that per the Microsoft docs, the

40 // lowest 8 bits of the structure, i.e. the SampleFormat

41 // field, contain AMCONTROL_xxx flags instead of sample

42 // format information, and should thus not be used.

43 // NB further that various values in the structure's

44 // fields (e.g. BT.2020 color space) are not provided

45 // for either of the DXVA structs, but are provided in

46 // the flags of the corresponding fields of Media Foundation.

47 // These may be provided by DirectShow devices (e.g. LAVFilters

48 // does so). So we use those values here too (the equivalence is

49 // indicated by Microsoft example code: https://docs.microsoft.com/en-us/windows/win32/api/dxva2api/ns-dxva2api-dxva2_videodesc)

50 #include "d3d9types.h"

51 #include "dxva2api.h"

53 #ifndef AMCONTROL_COLORINFO_PRESENT

54 // not defined in some versions of MinGW's dvdmedia.h

55 # define AMCONTROL_COLORINFO_PRESENT 0x00000080 // if set, indicates DXVA color info is present in the upper (24) bits of the dwControlFlags

56 #endif

59 static enum AVPixelFormat dshow_pixfmt(DWORD biCompression, WORD biBitCount)

60 {

61 switch(biCompression) {

62 case BI_BITFIELDS:

63 case BI_RGB:

64 switch(biBitCount) { /* 1-8 are untested */

65 case 1:

66 return AV_PIX_FMT_MONOWHITE;

67 case 4:

68 return AV_PIX_FMT_RGB4;

69 case 8:

70 return AV_PIX_FMT_RGB8;

71 case 16:

72 return AV_PIX_FMT_RGB555;

73 case 24:

74 return AV_PIX_FMT_BGR24;

75 case 32:

76 return AV_PIX_FMT_0RGB32;

77 }

78 }

79 return avpriv_pix_fmt_find(PIX_FMT_LIST_RAW, biCompression); // all others

80 }

82 static enum AVColorRange dshow_color_range(DXVA2_ExtendedFormat *fmt_info)

83 {

84 switch (fmt_info->NominalRange)

85 {

86 case DXVA2_NominalRange_Unknown:

87 return AVCOL_RANGE_UNSPECIFIED;

88 case DXVA2_NominalRange_Normal: // equal to DXVA2_NominalRange_0_255

89 return AVCOL_RANGE_JPEG;

90 case DXVA2_NominalRange_Wide: // equal to DXVA2_NominalRange_16_235

91 return AVCOL_RANGE_MPEG;

92 case DXVA2_NominalRange_48_208:

93 // not an ffmpeg color range

94 return AVCOL_RANGE_UNSPECIFIED;

96 // values from MediaFoundation SDK (mfobjects.h)

97 case 4: // MFNominalRange_64_127

98 // not an ffmpeg color range

99 return AVCOL_RANGE_UNSPECIFIED;

100

101 default:

102 return AVCOL_RANGE_UNSPECIFIED;

103 }

104 }

105

106 static enum AVColorSpace dshow_color_space(DXVA2_ExtendedFormat *fmt_info)

107 {

108 switch (fmt_info->VideoTransferMatrix)

109 {

110 case DXVA2_VideoTransferMatrix_BT709:

111 return AVCOL_SPC_BT709;

112 case DXVA2_VideoTransferMatrix_BT601:

113 return AVCOL_SPC_BT470BG;

114 case DXVA2_VideoTransferMatrix_SMPTE240M:

115 return AVCOL_SPC_SMPTE240M;

116

117 // values from MediaFoundation SDK (mfobjects.h)

118 case 4: // MFVideoTransferMatrix_BT2020_10

119 case 5: // MFVideoTransferMatrix_BT2020_12

120 if (fmt_info->VideoTransferFunction == 12) // MFVideoTransFunc_2020_const

121 return AVCOL_SPC_BT2020_CL;

122 else

123 return AVCOL_SPC_BT2020_NCL;

124

125 default:

126 return AVCOL_SPC_UNSPECIFIED;

127 }

128 }

129

130 static enum AVColorPrimaries dshow_color_primaries(DXVA2_ExtendedFormat *fmt_info)

131 {

132 switch (fmt_info->VideoPrimaries)

133 {

134 case DXVA2_VideoPrimaries_Unknown:

135 return AVCOL_PRI_UNSPECIFIED;

136 case DXVA2_VideoPrimaries_reserved:

137 return AVCOL_PRI_RESERVED;

138 case DXVA2_VideoPrimaries_BT709:

139 return AVCOL_PRI_BT709;

140 case DXVA2_VideoPrimaries_BT470_2_SysM:

141 return AVCOL_PRI_BT470M;

142 case DXVA2_VideoPrimaries_BT470_2_SysBG:

143 case DXVA2_VideoPrimaries_EBU3213: // this is PAL

144 return AVCOL_PRI_BT470BG;

145 case DXVA2_VideoPrimaries_SMPTE170M:

146 case DXVA2_VideoPrimaries_SMPTE_C:

147 return AVCOL_PRI_SMPTE170M;

148 case DXVA2_VideoPrimaries_SMPTE240M:

149 return AVCOL_PRI_SMPTE240M;

150

151 // values from MediaFoundation SDK (mfobjects.h)

152 case 9: // MFVideoPrimaries_BT2020

153 return AVCOL_PRI_BT2020;

154 case 10: // MFVideoPrimaries_XYZ

155 return AVCOL_PRI_SMPTE428;

156 case 11: // MFVideoPrimaries_DCI_P3

157 return AVCOL_PRI_SMPTE431;

158 case 12: // MFVideoPrimaries_ACES (Academy Color Encoding System)

159 // not an FFmpeg color primary

160 return AVCOL_PRI_UNSPECIFIED;

161

162 default:

163 return AVCOL_PRI_UNSPECIFIED;

164 }

165 }

166

167 static enum AVColorTransferCharacteristic dshow_color_trc(DXVA2_ExtendedFormat *fmt_info)

168 {

169 switch (fmt_info->VideoTransferFunction)

170 {

171 case DXVA2_VideoTransFunc_Unknown:

172 return AVCOL_TRC_UNSPECIFIED;

173 case DXVA2_VideoTransFunc_10:

174 return AVCOL_TRC_LINEAR;

175 case DXVA2_VideoTransFunc_18:

176 // not an FFmpeg transfer characteristic

177 return AVCOL_TRC_UNSPECIFIED;

178 case DXVA2_VideoTransFunc_20:

179 // not an FFmpeg transfer characteristic

180 return AVCOL_TRC_UNSPECIFIED;

181 case DXVA2_VideoTransFunc_22:

182 return AVCOL_TRC_GAMMA22;

183 case DXVA2_VideoTransFunc_709:

184 return AVCOL_TRC_BT709;

185 case DXVA2_VideoTransFunc_240M:

186 return AVCOL_TRC_SMPTE240M;

187 case DXVA2_VideoTransFunc_sRGB:

188 return AVCOL_TRC_IEC61966_2_1;

189 case DXVA2_VideoTransFunc_28:

190 return AVCOL_TRC_GAMMA28;

191

192 // values from MediaFoundation SDK (mfobjects.h)

193 case 9: // MFVideoTransFunc_Log_100

194 return AVCOL_TRC_LOG;

195 case 10: // MFVideoTransFunc_Log_316

196 return AVCOL_TRC_LOG_SQRT;

197 case 11: // MFVideoTransFunc_709_sym

198 // not an FFmpeg transfer characteristic

199 return AVCOL_TRC_UNSPECIFIED;

200 case 12: // MFVideoTransFunc_2020_const

201 case 13: // MFVideoTransFunc_2020

202 if (fmt_info->VideoTransferMatrix == 5) // MFVideoTransferMatrix_BT2020_12

203 return AVCOL_TRC_BT2020_12;

204 else

205 return AVCOL_TRC_BT2020_10;

206 case 14: // MFVideoTransFunc_26

207 // not an FFmpeg transfer characteristic

208 return AVCOL_TRC_UNSPECIFIED;

209 case 15: // MFVideoTransFunc_2084

210 return AVCOL_TRC_SMPTEST2084;

211 case 16: // MFVideoTransFunc_HLG

212 return AVCOL_TRC_ARIB_STD_B67;

213 case 17: // MFVideoTransFunc_10_rel

214 // not an FFmpeg transfer characteristic? Undocumented also by MS

215 return AVCOL_TRC_UNSPECIFIED;

216

217 default:

218 return AVCOL_TRC_UNSPECIFIED;

219 }

220 }

221

222 static enum AVChromaLocation dshow_chroma_loc(DXVA2_ExtendedFormat *fmt_info)

223 {

224 if (fmt_info->VideoChromaSubsampling == DXVA2_VideoChromaSubsampling_Cosited) // that is: (DXVA2_VideoChromaSubsampling_Horizontally_Cosited | DXVA2_VideoChromaSubsampling_Vertically_Cosited | DXVA2_VideoChromaSubsampling_Vertically_AlignedChromaPlanes)

225 return AVCHROMA_LOC_TOPLEFT;

226 else if (fmt_info->VideoChromaSubsampling == DXVA2_VideoChromaSubsampling_MPEG1) // that is: DXVA2_VideoChromaSubsampling_Vertically_AlignedChromaPlanes

227 return AVCHROMA_LOC_CENTER;

228 else if (fmt_info->VideoChromaSubsampling == DXVA2_VideoChromaSubsampling_MPEG2) // that is: (DXVA2_VideoChromaSubsampling_Horizontally_Cosited | DXVA2_VideoChromaSubsampling_Vertically_AlignedChromaPlanes)

229 return AVCHROMA_LOC_LEFT;

230 else if (fmt_info->VideoChromaSubsampling == DXVA2_VideoChromaSubsampling_DV_PAL) // that is: (DXVA2_VideoChromaSubsampling_Horizontally_Cosited | DXVA2_VideoChromaSubsampling_Vertically_Cosited)

231 return AVCHROMA_LOC_TOPLEFT;

232 else

233 // unknown

234 return AVCHROMA_LOC_UNSPECIFIED;

235 }

236

237 static int

238 dshow_read_close(AVFormatContext *s)

239 {

240 struct dshow_ctx *ctx = s->priv_data;

241 PacketListEntry *pktl;

242

243 if (ctx->control) {

244 IMediaControl_Stop(ctx->control);

245 IMediaControl_Release(ctx->control);

246 }

247

248 if (ctx->media_event)

249 IMediaEvent_Release(ctx->media_event);

250

251 if (ctx->graph) {

252 IEnumFilters *fenum;

253 int r;

254 r = IGraphBuilder_EnumFilters(ctx->graph, &fenum);

255 if (r == S_OK) {

256 IBaseFilter *f;

257 IEnumFilters_Reset(fenum);

258 while (IEnumFilters_Next(fenum, 1, &f, NULL) == S_OK) {

259 if (IGraphBuilder_RemoveFilter(ctx->graph, f) == S_OK)

260 IEnumFilters_Reset(fenum); /* When a filter is removed,

261 * the list must be reset. */

262 IBaseFilter_Release(f);

263 }

264 IEnumFilters_Release(fenum);

265 }

266 IGraphBuilder_Release(ctx->graph);

267 }

268

269 if (ctx->capture_pin[VideoDevice])

270 ff_dshow_pin_Release(ctx->capture_pin[VideoDevice]);

271 if (ctx->capture_pin[AudioDevice])

272 ff_dshow_pin_Release(ctx->capture_pin[AudioDevice]);

273 if (ctx->capture_filter[VideoDevice])

274 ff_dshow_filter_Release(ctx->capture_filter[VideoDevice]);

275 if (ctx->capture_filter[AudioDevice])

276 ff_dshow_filter_Release(ctx->capture_filter[AudioDevice]);

277

278 if (ctx->device_pin[VideoDevice])

279 IPin_Release(ctx->device_pin[VideoDevice]);

280 if (ctx->device_pin[AudioDevice])

281 IPin_Release(ctx->device_pin[AudioDevice]);

282 if (ctx->device_filter[VideoDevice])

283 IBaseFilter_Release(ctx->device_filter[VideoDevice]);

284 if (ctx->device_filter[AudioDevice])

285 IBaseFilter_Release(ctx->device_filter[AudioDevice]);

286

287 av_freep(&ctx->device_name[0]);

288 av_freep(&ctx->device_name[1]);

289 av_freep(&ctx->device_unique_name[0]);

290 av_freep(&ctx->device_unique_name[1]);

291

292 if(ctx->mutex)

293 CloseHandle(ctx->mutex);

294 if(ctx->event[0])

295 CloseHandle(ctx->event[0]);

296 if(ctx->event[1])

297 CloseHandle(ctx->event[1]);

298

299 pktl = ctx->pktl;

300 while (pktl) {

301 PacketListEntry *next = pktl->next;

302 av_packet_unref(&pktl->pkt);

303 av_free(pktl);

304 pktl = next;

305 }

306

307 CoUninitialize();

308

309 return 0;

310 }

311

312 static char *dup_wchar_to_utf8(wchar_t *w)

313 {

314 char *s = NULL;

315 int l = WideCharToMultiByte(CP_UTF8, 0, w, -1, 0, 0, 0, 0);

316 s = av_malloc(l);

317 if (s)

318 WideCharToMultiByte(CP_UTF8, 0, w, -1, s, l, 0, 0);

319 return s;

320 }

321

322 static int shall_we_drop(AVFormatContext *s, int index, enum dshowDeviceType devtype)

323 {

324 struct dshow_ctx *ctx = s->priv_data;

325 static const uint8_t dropscore[] = {62, 75, 87, 100};

326 const int ndropscores = FF_ARRAY_ELEMS(dropscore);

327 unsigned int buffer_fullness = (ctx->curbufsize[index]*100)/s->max_picture_buffer;

328 const char *devtypename = (devtype == VideoDevice) ? "video" : "audio";

329

330 if(dropscore[++ctx->video_frame_num%ndropscores] <= buffer_fullness) {

331 av_log(s, AV_LOG_ERROR,

332 "real-time buffer [%s] [%s input] too full or near too full (%d%% of size: %d [rtbufsize parameter])! frame dropped!\n",

333 ctx->device_name[devtype], devtypename, buffer_fullness, s->max_picture_buffer);

334 return 1;

335 }

336

337 return 0;

338 }

339

340 static void

341 callback(void *priv_data, int index, uint8_t *buf, int buf_size, int64_t time, enum dshowDeviceType devtype)

342 {

343 AVFormatContext *s = priv_data;

344 struct dshow_ctx *ctx = s->priv_data;

345 PacketListEntry **ppktl, *pktl_next;

346

347 // dump_videohdr(s, vdhdr);

348

349 WaitForSingleObject(ctx->mutex, INFINITE);

350

351 if(shall_we_drop(s, index, devtype))

352 goto fail;

353

354 pktl_next = av_mallocz(sizeof(*pktl_next));

355 if(!pktl_next)

356 goto fail;

357

358 if(av_new_packet(&pktl_next->pkt, buf_size) < 0) {

359 av_free(pktl_next);

360 goto fail;

361 }

362

363 pktl_next->pkt.stream_index = index;

364 pktl_next->pkt.pts = time;

365 memcpy(pktl_next->pkt.data, buf, buf_size);

366

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

368 *ppktl = pktl_next;

369 ctx->curbufsize[index] += buf_size;

370

371 SetEvent(ctx->event[1]);

372 ReleaseMutex(ctx->mutex);

373

374 return;

375 fail:

376 ReleaseMutex(ctx->mutex);

377 return;

378 }

379

380 static void

381 dshow_get_device_media_types(AVFormatContext *avctx, enum dshowDeviceType devtype,

382 enum dshowSourceFilterType sourcetype, IBaseFilter *device_filter,

383 enum AVMediaType **media_types, int *nb_media_types)

384 {

385 IEnumPins *pins = 0;

386 IPin *pin;

387 int has_audio = 0, has_video = 0;

388

389 if (IBaseFilter_EnumPins(device_filter, &pins) != S_OK)

390 return;

391

392 while (IEnumPins_Next(pins, 1, &pin, NULL) == S_OK) {

393 IKsPropertySet *p = NULL;

394 PIN_INFO info = { 0 };

395 GUID category;

396 DWORD r2;

397 IEnumMediaTypes *types = NULL;

398 AM_MEDIA_TYPE *type;

399

400 if (IPin_QueryPinInfo(pin, &info) != S_OK)

401 goto next;

402 IBaseFilter_Release(info.pFilter);

403

404 if (info.dir != PINDIR_OUTPUT)

405 goto next;

406 if (IPin_QueryInterface(pin, &IID_IKsPropertySet, (void **) &p) != S_OK)

407 goto next;

408 if (IKsPropertySet_Get(p, &AMPROPSETID_Pin, AMPROPERTY_PIN_CATEGORY,

409 NULL, 0, &category, sizeof(GUID), &r2) != S_OK)

410 goto next;

411 if (!IsEqualGUID(&category, &PIN_CATEGORY_CAPTURE))

412 goto next;

413

414 if (IPin_EnumMediaTypes(pin, &types) != S_OK)

415 goto next;

416

417 // enumerate media types exposed by pin

418 // NB: don't know if a pin can expose both audio and video, check 'm all to be safe

419 IEnumMediaTypes_Reset(types);

420 while (IEnumMediaTypes_Next(types, 1, &type, NULL) == S_OK) {

421 if (IsEqualGUID(&type->majortype, &MEDIATYPE_Video)) {

422 has_video = 1;

423 } else if (IsEqualGUID(&type->majortype, &MEDIATYPE_Audio)) {

424 has_audio = 1;

425 }

426 CoTaskMemFree(type);

427 }

428

429 next:

430 if (types)

431 IEnumMediaTypes_Release(types);

432 if (p)

433 IKsPropertySet_Release(p);

434 if (pin)

435 IPin_Release(pin);

436 }

437

438 IEnumPins_Release(pins);

439

440 if (has_audio || has_video) {

441 int nb_types = has_audio + has_video;

442 *media_types = av_malloc_array(nb_types, sizeof(enum AVMediaType));

443 if (*media_types) {

444 if (has_audio)

445 (*media_types)[0] = AVMEDIA_TYPE_AUDIO;

446 if (has_video)

447 (*media_types)[0 + has_audio] = AVMEDIA_TYPE_VIDEO;

448 *nb_media_types = nb_types;

449 }

450 }

451 }

452

453 /**

454 * Cycle through available devices using the device enumerator devenum,

455 * retrieve the device with type specified by devtype and return the

456 * pointer to the object found in *pfilter.

457 * If pfilter is NULL, list all device names.

458 * If device_list is not NULL, populate it with found devices instead of

459 * outputting device names to log

460 */

461 static int

462 dshow_cycle_devices(AVFormatContext *avctx, ICreateDevEnum *devenum,

463 enum dshowDeviceType devtype, enum dshowSourceFilterType sourcetype,

464 IBaseFilter **pfilter, char **device_unique_name,

465 AVDeviceInfoList **device_list)

466 {

467 struct dshow_ctx *ctx = avctx->priv_data;

468 IBaseFilter *device_filter = NULL;

469 IEnumMoniker *classenum = NULL;

470 IMoniker *m = NULL;

471 const char *device_name = ctx->device_name[devtype];

472 int skip = (devtype == VideoDevice) ? ctx->video_device_number

473 : ctx->audio_device_number;

474 int r;

475

476 const GUID *device_guid[2] = { &CLSID_VideoInputDeviceCategory,

477 &CLSID_AudioInputDeviceCategory };

478 const char *devtypename = (devtype == VideoDevice) ? "video" : "audio only";

479 const char *sourcetypename = (sourcetype == VideoSourceDevice) ? "video" : "audio";

480

481 r = ICreateDevEnum_CreateClassEnumerator(devenum, device_guid[sourcetype],

482 (IEnumMoniker **) &classenum, 0);

483 if (r != S_OK) {

484 av_log(avctx, AV_LOG_ERROR, "Could not enumerate %s devices (or none found).\n",

485 devtypename);

486 return AVERROR(EIO);

487 }

488

489 while (!device_filter && IEnumMoniker_Next(classenum, 1, &m, NULL) == S_OK) {

490 IPropertyBag *bag = NULL;

491 char *friendly_name = NULL;

492 char *unique_name = NULL;

493 VARIANT var;

494 IBindCtx *bind_ctx = NULL;

495 LPOLESTR olestr = NULL;

496 LPMALLOC co_malloc = NULL;

497 AVDeviceInfo *device = NULL;

498 enum AVMediaType *media_types = NULL;

499 int nb_media_types = 0;

500 int i;

501

502 r = CoGetMalloc(1, &co_malloc);

503 if (r != S_OK)

504 goto fail;

505 r = CreateBindCtx(0, &bind_ctx);

506 if (r != S_OK)

507 goto fail;

508 /* GetDisplayname works for both video and audio, DevicePath doesn't */

509 r = IMoniker_GetDisplayName(m, bind_ctx, NULL, &olestr);

510 if (r != S_OK)

511 goto fail;

512 unique_name = dup_wchar_to_utf8(olestr);

513 /* replace ':' with '_' since we use : to delineate between sources */

514 for (i = 0; i < strlen(unique_name); i++) {

515 if (unique_name[i] == ':')

516 unique_name[i] = '_';

517 }

518

519 r = IMoniker_BindToStorage(m, 0, 0, &IID_IPropertyBag, (void *) &bag);

520 if (r != S_OK)

521 goto fail;

522

523 var.vt = VT_BSTR;

524 r = IPropertyBag_Read(bag, L "FriendlyName", &var, NULL);

525 if (r != S_OK)

526 goto fail;

527 friendly_name = dup_wchar_to_utf8(var.bstrVal);

528

529 if (pfilter) {

530 if (strcmp(device_name, friendly_name) && strcmp(device_name, unique_name))

531 goto fail;

532

533 if (!skip--) {

534 r = IMoniker_BindToObject(m, 0, 0, &IID_IBaseFilter, (void *) &device_filter);

535 if (r != S_OK) {

536 av_log(avctx, AV_LOG_ERROR, "Unable to BindToObject for %s\n", device_name);

537 goto fail;

538 }

539 *device_unique_name = unique_name;

540 unique_name = NULL;

541 // success, loop will end now

542 }

543 } else {

544 // get media types exposed by pins of device

545 if (IMoniker_BindToObject(m, 0, 0, &IID_IBaseFilter, (void* ) &device_filter) == S_OK) {

546 dshow_get_device_media_types(avctx, devtype, sourcetype, device_filter, &media_types, &nb_media_types);

547 IBaseFilter_Release(device_filter);

548 device_filter = NULL;

549 }

550 if (device_list) {

551 device = av_mallocz(sizeof(AVDeviceInfo));

552 if (!device)

553 goto fail;

554

555 device->device_name = av_strdup(friendly_name);

556 device->device_description = av_strdup(unique_name);

557 if (!device->device_name || !device->device_description)

558 goto fail;

559

560 // make space in device_list for this new device

561 if (av_reallocp_array(&(*device_list)->devices,

562 (*device_list)->nb_devices + 1,

563 sizeof(*(*device_list)->devices)) < 0)

564 goto fail;

565

566 // attach media_types to device

567 device->nb_media_types = nb_media_types;

568 device->media_types = media_types;

569 nb_media_types = 0;

570 media_types = NULL;

571

572 // store device in list

573 (*device_list)->devices[(*device_list)->nb_devices] = device;

574 (*device_list)->nb_devices++;

575 device = NULL; // copied into array, make sure not freed below

576 }

577 else {

578 av_log(avctx, AV_LOG_INFO, "\"%s\"", friendly_name);

579 if (nb_media_types > 0) {

580 const char* media_type = av_get_media_type_string(media_types[0]);

581 av_log(avctx, AV_LOG_INFO, " (%s", media_type ? media_type : "unknown");

582 for (int i = 1; i < nb_media_types; ++i) {

583 media_type = av_get_media_type_string(media_types[i]);

584 av_log(avctx, AV_LOG_INFO, ", %s", media_type ? media_type : "unknown");

585 }

586 av_log(avctx, AV_LOG_INFO, ")");

587 } else {

588 av_log(avctx, AV_LOG_INFO, " (none)");

589 }

590 av_log(avctx, AV_LOG_INFO, "\n");

591 av_log(avctx, AV_LOG_INFO, " Alternative name \"%s\"\n", unique_name);

592 }

593 }

594

595 fail:

596 av_freep(&media_types);

597 if (device) {

598 av_freep(&device->device_name);

599 av_freep(&device->device_description);

600 // NB: no need to av_freep(&device->media_types), its only moved to device once nothing can fail anymore

601 av_free(device);

602 }

603 if (olestr && co_malloc)

604 IMalloc_Free(co_malloc, olestr);

605 if (bind_ctx)

606 IBindCtx_Release(bind_ctx);

607 av_freep(&friendly_name);

608 av_freep(&unique_name);

609 if (bag)

610 IPropertyBag_Release(bag);

611 IMoniker_Release(m);

612 }

613

614 IEnumMoniker_Release(classenum);

615

616 if (pfilter) {

617 if (!device_filter) {

618 av_log(avctx, AV_LOG_ERROR, "Could not find %s device with name [%s] among source devices of type %s.\n",

619 devtypename, device_name, sourcetypename);

620 return AVERROR(EIO);

621 }

622 *pfilter = device_filter;

623 }

624

625 return 0;

626 }

627

628 static int dshow_get_device_list(AVFormatContext *avctx, AVDeviceInfoList *device_list)

629 {

630 ICreateDevEnum *devenum = NULL;

631 int r;

632 int ret = AVERROR(EIO);

633

634 if (!device_list)

635 return AVERROR(EINVAL);

636

637 CoInitialize(0);

638

639 r = CoCreateInstance(&CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,

640 &IID_ICreateDevEnum, (void**)&devenum);

641 if (r != S_OK) {

642 av_log(avctx, AV_LOG_ERROR, "Could not enumerate system devices.\n");

643 goto error;

644 }

645

646 ret = dshow_cycle_devices(avctx, devenum, VideoDevice, VideoSourceDevice, NULL, NULL, &device_list);

647 if (ret < S_OK)

648 goto error;

649 ret = dshow_cycle_devices(avctx, devenum, AudioDevice, AudioSourceDevice, NULL, NULL, &device_list);

650

651 error:

652 if (devenum)

653 ICreateDevEnum_Release(devenum);

654

655 CoUninitialize();

656

657 return ret;

658 }

659

660 static int dshow_should_set_format(AVFormatContext *avctx, enum dshowDeviceType devtype)

661 {

662 struct dshow_ctx *ctx = avctx->priv_data;

663

664 return (devtype == VideoDevice && (ctx->framerate ||

665 (ctx->requested_width && ctx->requested_height) ||

666 ctx->pixel_format != AV_PIX_FMT_NONE ||

667 ctx->video_codec_id != AV_CODEC_ID_RAWVIDEO))

668 || (devtype == AudioDevice && (ctx->channels || ctx->sample_size || ctx->sample_rate));

669 }

670

671

672 struct dshow_format_info {

673 enum dshowDeviceType devtype;

674 // video

675 int64_t framerate;

676 enum AVPixelFormat pix_fmt;

677 enum AVCodecID codec_id;

678 enum AVColorRange col_range;

679 enum AVColorSpace col_space;

680 enum AVColorPrimaries col_prim;

681 enum AVColorTransferCharacteristic col_trc;

682 enum AVChromaLocation chroma_loc;

683 int width;

684 int height;

685 // audio

686 int sample_rate;

687 int sample_size;

688 int channels;

689 };

690

691 // user must av_free the returned pointer

692 static struct dshow_format_info *dshow_get_format_info(AM_MEDIA_TYPE *type)

693 {

694 struct dshow_format_info *fmt_info = NULL;

695 BITMAPINFOHEADER *bih;

696 DXVA2_ExtendedFormat *extended_format_info = NULL;

697 WAVEFORMATEX *fx;

698 enum dshowDeviceType devtype;

699 int64_t framerate;

700

701 if (!type)

702 return NULL;

703

704 if (IsEqualGUID(&type->formattype, &FORMAT_VideoInfo)) {

705 VIDEOINFOHEADER *v = (void *) type->pbFormat;

706 framerate = v->AvgTimePerFrame;

707 bih = &v->bmiHeader;

708 devtype = VideoDevice;

709 } else if (IsEqualGUID(&type->formattype, &FORMAT_VideoInfo2)) {

710 VIDEOINFOHEADER2 *v = (void *) type->pbFormat;

711 devtype = VideoDevice;

712 framerate = v->AvgTimePerFrame;

713 bih = &v->bmiHeader;

714 if (v->dwControlFlags & AMCONTROL_COLORINFO_PRESENT)

715 extended_format_info = (DXVA2_ExtendedFormat *) &v->dwControlFlags;

716 } else if (IsEqualGUID(&type->formattype, &FORMAT_WaveFormatEx)) {

717 fx = (void *) type->pbFormat;

718 devtype = AudioDevice;

719 } else {

720 return NULL;

721 }

722

723 fmt_info = av_mallocz(sizeof(struct dshow_format_info));

724 if (!fmt_info)

725 return NULL;

726 // initialize fields where unset is not zero

727 fmt_info->pix_fmt = AV_PIX_FMT_NONE;

728 fmt_info->col_space = AVCOL_SPC_UNSPECIFIED;

729 fmt_info->col_prim = AVCOL_PRI_UNSPECIFIED;

730 fmt_info->col_trc = AVCOL_TRC_UNSPECIFIED;

731 // now get info about format

732 fmt_info->devtype = devtype;

733 if (devtype == VideoDevice) {

734 fmt_info->width = bih->biWidth;

735 fmt_info->height = bih->biHeight;

736 fmt_info->framerate = framerate;

737 fmt_info->pix_fmt = dshow_pixfmt(bih->biCompression, bih->biBitCount);

738 if (fmt_info->pix_fmt == AV_PIX_FMT_NONE) {

739 const AVCodecTag *const tags[] = { avformat_get_riff_video_tags(), NULL };

740 fmt_info->codec_id = av_codec_get_id(tags, bih->biCompression);

741 }

742 else

743 fmt_info->codec_id = AV_CODEC_ID_RAWVIDEO;

744

745 if (extended_format_info) {

746 fmt_info->col_range = dshow_color_range(extended_format_info);

747 fmt_info->col_space = dshow_color_space(extended_format_info);

748 fmt_info->col_prim = dshow_color_primaries(extended_format_info);

749 fmt_info->col_trc = dshow_color_trc(extended_format_info);

750 fmt_info->chroma_loc = dshow_chroma_loc(extended_format_info);

751 }

752 } else {

753 fmt_info->sample_rate = fx->nSamplesPerSec;

754 fmt_info->sample_size = fx->wBitsPerSample;

755 fmt_info->channels = fx->nChannels;

756 }

757

758 return fmt_info;

759 }

760

761 static void dshow_get_default_format(IPin *pin, IAMStreamConfig *config, enum dshowDeviceType devtype, AM_MEDIA_TYPE **type)

762 {

763 HRESULT hr;

764

765 if ((hr = IAMStreamConfig_GetFormat(config, type)) != S_OK) {

766 if (hr == E_NOTIMPL || !IsEqualGUID(&(*type)->majortype, devtype == VideoDevice ? &MEDIATYPE_Video : &MEDIATYPE_Audio)) {

767 // default not available or of wrong type,

768 // fall back to iterating exposed formats

769 // until one of the right type is found

770 IEnumMediaTypes* types = NULL;

771 if (IPin_EnumMediaTypes(pin, &types) != S_OK)

772 return;

773 IEnumMediaTypes_Reset(types);

774 while (IEnumMediaTypes_Next(types, 1, type, NULL) == S_OK) {

775 if (IsEqualGUID(&(*type)->majortype, devtype == VideoDevice ? &MEDIATYPE_Video : &MEDIATYPE_Audio)) {

776 break;

777 }

778 CoTaskMemFree(*type);

779 *type = NULL;

780 }

781 IEnumMediaTypes_Release(types);

782 }

783 }

784 }

785

786 /**

787 * Cycle through available formats available from the specified pin,

788 * try to set parameters specified through AVOptions, or the pin's

789 * default format if no such parameters were set. If successful,

790 * return 1 in *pformat_set.

791 * If pformat_set is NULL, list all pin capabilities.

792 */

793 static void

794 dshow_cycle_formats(AVFormatContext *avctx, enum dshowDeviceType devtype,

795 IPin *pin, int *pformat_set)

796 {

797 struct dshow_ctx *ctx = avctx->priv_data;

798 IAMStreamConfig *config = NULL;

799 AM_MEDIA_TYPE *type = NULL;

800 AM_MEDIA_TYPE *previous_match_type = NULL;

801 int format_set = 0;

802 void *caps = NULL;

803 int i, n, size, r;

804 int wait_for_better = 0;

805 int use_default;

806

807 // format parameters requested by user

808 // if none are requested by user, the values will below be set to

809 // those of the default format

810 // video

811 enum AVCodecID requested_video_codec_id = ctx->video_codec_id;

812 enum AVPixelFormat requested_pixel_format = ctx->pixel_format;

813 int64_t requested_framerate = ctx->framerate ? ((int64_t)ctx->requested_framerate.den * 10000000)

814 / ctx->requested_framerate.num : 0;

815 int requested_width = ctx->requested_width;

816 int requested_height = ctx->requested_height;

817 // audio

818 int requested_sample_rate = ctx->sample_rate;

819 int requested_sample_size = ctx->sample_size;

820 int requested_channels = ctx->channels;

821

822 if (IPin_QueryInterface(pin, &IID_IAMStreamConfig, (void **) &config) != S_OK)

823 return;

824 if (IAMStreamConfig_GetNumberOfCapabilities(config, &n, &size) != S_OK)

825 goto end;

826

827 caps = av_malloc(size);

828 if (!caps)

829 goto end;

830

831 /**

832 * If we should open the device with the default format,

833 * then:

834 * 1. check what the format of the default device is, and

835 * 2. below we iterate all formats till we find a matching

836 * one, with most info exposed (see comment below).

837 */

838 use_default = !dshow_should_set_format(avctx, devtype);

839 if (use_default && pformat_set)

840 {

841 // get default

842 dshow_get_default_format(pin, config, devtype, &type);

843 if (!type)

844 // this pin does not expose any formats of the expected type

845 goto end;

846

847 if (type) {

848 // interrogate default format, so we know what to search for below

849 struct dshow_format_info *fmt_info = dshow_get_format_info(type);

850 if (fmt_info) {

851 if (fmt_info->devtype == VideoDevice) {

852 requested_video_codec_id = fmt_info->codec_id;

853 requested_pixel_format = fmt_info->pix_fmt;

854 requested_framerate = fmt_info->framerate;

855 requested_width = fmt_info->width;

856 requested_height = fmt_info->height;

857 } else {

858 requested_sample_rate = fmt_info->sample_rate;

859 requested_sample_size = fmt_info->sample_size;

860 requested_channels = fmt_info->channels;

861 }

862 av_free(fmt_info); // free but don't set to NULL to enable below check

863 }

864

865 if (type && type->pbFormat)

866 CoTaskMemFree(type->pbFormat);

867 CoTaskMemFree(type);

868 type = NULL;

869 if (!fmt_info)

870 // default format somehow invalid, can't continue with this pin

871 goto end;

872 fmt_info = NULL;

873 }

874 }

875

876 // NB: some devices (e.g. Logitech C920) expose each video format twice:

877 // both a format containing a VIDEOINFOHEADER and a format containing

878 // a VIDEOINFOHEADER2. We want, if possible, to select a format with a

879 // VIDEOINFOHEADER2, as this potentially provides more info about the

880 // format. So, if in the iteration below we have found a matching format,

881 // but it is a VIDEOINFOHEADER, keep looking for a matching format that

882 // exposes contains a VIDEOINFOHEADER2. Fall back to the VIDEOINFOHEADER

883 // format if no corresponding VIDEOINFOHEADER2 is found when we finish

884 // iterating.

885 for (i = 0; i < n && !format_set; i++) {

886 struct dshow_format_info *fmt_info = NULL;

887 r = IAMStreamConfig_GetStreamCaps(config, i, &type, (void *) caps);

888 if (r != S_OK)

889 goto next;

890 #if DSHOWDEBUG

891 ff_print_AM_MEDIA_TYPE(type);

892 #endif

893

894 fmt_info = dshow_get_format_info(type);

895 if (!fmt_info)

896 goto next;

897

898 if (devtype == VideoDevice) {

899 VIDEO_STREAM_CONFIG_CAPS *vcaps = caps;

900 BITMAPINFOHEADER *bih;

901 int64_t *fr;

902 #if DSHOWDEBUG

903 ff_print_VIDEO_STREAM_CONFIG_CAPS(vcaps);

904 #endif

905

906 if (fmt_info->devtype != VideoDevice)

907 goto next;

908

909 if (IsEqualGUID(&type->formattype, &FORMAT_VideoInfo)) {

910 VIDEOINFOHEADER *v = (void *) type->pbFormat;

911 fr = &v->AvgTimePerFrame;

912 bih = &v->bmiHeader;

913 wait_for_better = 1;

914 } else if (IsEqualGUID(&type->formattype, &FORMAT_VideoInfo2)) {

915 VIDEOINFOHEADER2 *v = (void *) type->pbFormat;

916 fr = &v->AvgTimePerFrame;

917 bih = &v->bmiHeader;

918 wait_for_better = 0;

919 }

920

921 if (!pformat_set) {

922 const char *chroma = av_chroma_location_name(fmt_info->chroma_loc);

923 if (fmt_info->pix_fmt == AV_PIX_FMT_NONE) {

924 const AVCodec *codec = avcodec_find_decoder(fmt_info->codec_id);

925 if (fmt_info->codec_id == AV_CODEC_ID_NONE || !codec) {

926 av_log(avctx, AV_LOG_INFO, " unknown compression type 0x%X", (int) bih->biCompression);

927 } else {

928 av_log(avctx, AV_LOG_INFO, " vcodec=%s", codec->name);

929 }

930 } else {

931 av_log(avctx, AV_LOG_INFO, " pixel_format=%s", av_get_pix_fmt_name(fmt_info->pix_fmt));

932 }

933 av_log(avctx, AV_LOG_INFO, " min s=%ldx%ld fps=%g max s=%ldx%ld fps=%g",

934 vcaps->MinOutputSize.cx, vcaps->MinOutputSize.cy,

935 1e7 / vcaps->MaxFrameInterval,

936 vcaps->MaxOutputSize.cx, vcaps->MaxOutputSize.cy,

937 1e7 / vcaps->MinFrameInterval);

938

939 if (fmt_info->col_range != AVCOL_RANGE_UNSPECIFIED ||

940 fmt_info->col_space != AVCOL_SPC_UNSPECIFIED ||

941 fmt_info->col_prim != AVCOL_PRI_UNSPECIFIED ||

942 fmt_info->col_trc != AVCOL_TRC_UNSPECIFIED) {

943 const char *range = av_color_range_name(fmt_info->col_range);

944 const char *space = av_color_space_name(fmt_info->col_space);

945 const char *prim = av_color_primaries_name(fmt_info->col_prim);

946 const char *trc = av_color_transfer_name(fmt_info->col_trc);

947 av_log(avctx, AV_LOG_INFO, " (%s, %s/%s/%s",

948 range ? range : "unknown",

949 space ? space : "unknown",

950 prim ? prim : "unknown",

951 trc ? trc : "unknown");

952 if (fmt_info->chroma_loc != AVCHROMA_LOC_UNSPECIFIED)

953 av_log(avctx, AV_LOG_INFO, ", %s", chroma ? chroma : "unknown");

954 av_log(avctx, AV_LOG_INFO, ")");

955 }

956 else if (fmt_info->chroma_loc != AVCHROMA_LOC_UNSPECIFIED)

957 av_log(avctx, AV_LOG_INFO, "(%s)", chroma ? chroma : "unknown");

958

959 av_log(avctx, AV_LOG_INFO, "\n");

960 goto next;

961 }

962 if (requested_video_codec_id != AV_CODEC_ID_RAWVIDEO) {

963 if (requested_video_codec_id != fmt_info->codec_id)

964 goto next;

965 }

966 if (requested_pixel_format != AV_PIX_FMT_NONE &&

967 requested_pixel_format != fmt_info->pix_fmt) {

968 goto next;

969 }

970 if (requested_framerate) {

971 if (requested_framerate > vcaps->MaxFrameInterval ||

972 requested_framerate < vcaps->MinFrameInterval)

973 goto next;

974 *fr = requested_framerate;

975 }

976 if (requested_width && requested_height) {

977 if (requested_width > vcaps->MaxOutputSize.cx ||

978 requested_width < vcaps->MinOutputSize.cx ||

979 requested_height > vcaps->MaxOutputSize.cy ||

980 requested_height < vcaps->MinOutputSize.cy)

981 goto next;

982 bih->biWidth = requested_width;

983 bih->biHeight = requested_height;

984 }

985 } else {

986 WAVEFORMATEX *fx;

987 AUDIO_STREAM_CONFIG_CAPS *acaps = caps;

988 #if DSHOWDEBUG

989 ff_print_AUDIO_STREAM_CONFIG_CAPS(acaps);

990 #endif

991 if (IsEqualGUID(&type->formattype, &FORMAT_WaveFormatEx)) {

992 fx = (void *) type->pbFormat;

993 } else {

994 goto next;

995 }

996 if (!pformat_set) {

997 av_log(

998 avctx,

999 AV_LOG_INFO,

1000 " ch=%2u, bits=%2u, rate=%6lu\n",

1001 fx->nChannels, fx->wBitsPerSample, fx->nSamplesPerSec

1002 );

1003 continue;

1004 }

1005 if (

1006 (ctx->sample_rate && ctx->sample_rate != fx->nSamplesPerSec) ||

1007 (ctx->sample_size && ctx->sample_size != fx->wBitsPerSample) ||

1008 (ctx->channels && ctx->channels != fx->nChannels )

1009 ) {

1010 goto next;

1011 }

1012 }

1013

1014 // found a matching format. Either apply or store

1015 // for safekeeping if we might maybe find a better

1016 // format with more info attached to it (see comment

1017 // above loop)

1018 if (!wait_for_better) {

1019 if (IAMStreamConfig_SetFormat(config, type) != S_OK)

1020 goto next;

1021 format_set = 1;

1022 }

1023 else if (!previous_match_type) {

1024 // store this matching format for possible later use.

1025 // If we have already found a matching format, ignore it

1026 previous_match_type = type;

1027 type = NULL;

1028 }

1029 next:

1030 av_freep(&fmt_info);

1031 if (type && type->pbFormat)

1032 CoTaskMemFree(type->pbFormat);

1033 CoTaskMemFree(type);

1034 type = NULL;

1035 }

1036

1037 // set the pin's format, if wanted

1038 if (pformat_set && !format_set) {

1039 if (previous_match_type) {

1040 // previously found a matching VIDEOINFOHEADER format and stored

1041 // it for safe keeping. Searching further for a matching

1042 // VIDEOINFOHEADER2 format yielded nothing. So set the pin's

1043 // format based on the VIDEOINFOHEADER format.

1044 // NB: this never applies to an audio format because

1045 // previous_match_type always NULL in that case

1046 if (IAMStreamConfig_SetFormat(config, previous_match_type) == S_OK)

1047 format_set = 1;

1048 }

1049 else if (use_default) {

1050 // default format returned by device apparently was not contained

1051 // in the capabilities of any of the formats returned by the device

1052 // (sic?). Fall back to directly setting the default format

1053 dshow_get_default_format(pin, config, devtype, &type);

1054 if (IAMStreamConfig_SetFormat(config, type) == S_OK)

1055 format_set = 1;

1056 if (type && type->pbFormat)

1057 CoTaskMemFree(type->pbFormat);

1058 CoTaskMemFree(type);

1059 type = NULL;

1060 }

1061 }

1062

1063 end:

1064 if (previous_match_type && previous_match_type->pbFormat)

1065 CoTaskMemFree(previous_match_type->pbFormat);

1066 CoTaskMemFree(previous_match_type);

1067 IAMStreamConfig_Release(config);

1068 av_free(caps);

1069 if (pformat_set)

1070 *pformat_set = format_set;

1071 }

1072

1073 /**

1074 * Set audio device buffer size in milliseconds (which can directly impact

1075 * latency, depending on the device).

1076 */

1077 static int

1078 dshow_set_audio_buffer_size(AVFormatContext *avctx, IPin *pin)

1079 {

1080 struct dshow_ctx *ctx = avctx->priv_data;

1081 IAMBufferNegotiation *buffer_negotiation = NULL;

1082 ALLOCATOR_PROPERTIES props = { -1, -1, -1, -1 };

1083 IAMStreamConfig *config = NULL;

1084 AM_MEDIA_TYPE *type = NULL;

1085 int ret = AVERROR(EIO);

1086

1087 if (IPin_QueryInterface(pin, &IID_IAMStreamConfig, (void **) &config) != S_OK)

1088 goto end;

1089 if (IAMStreamConfig_GetFormat(config, &type) != S_OK)

1090 goto end;

1091 if (!IsEqualGUID(&type->formattype, &FORMAT_WaveFormatEx))

1092 goto end;

1093

1094 props.cbBuffer = (((WAVEFORMATEX *) type->pbFormat)->nAvgBytesPerSec)

1095 * ctx->audio_buffer_size / 1000;

1096

1097 if (IPin_QueryInterface(pin, &IID_IAMBufferNegotiation, (void **) &buffer_negotiation) != S_OK)

1098 goto end;

1099 if (IAMBufferNegotiation_SuggestAllocatorProperties(buffer_negotiation, &props) != S_OK)

1100 goto end;

1101

1102 ret = 0;

1103

1104 end:

1105 if (buffer_negotiation)

1106 IAMBufferNegotiation_Release(buffer_negotiation);

1107 if (type) {

1108 if (type->pbFormat)

1109 CoTaskMemFree(type->pbFormat);

1110 CoTaskMemFree(type);

1111 }

1112 if (config)

1113 IAMStreamConfig_Release(config);

1114

1115 return ret;

1116 }

1117

1118 /**

1119 * Pops up a user dialog allowing them to adjust properties for the given filter, if possible.

1120 */

1121 void

1122 ff_dshow_show_filter_properties(IBaseFilter *device_filter, AVFormatContext *avctx) {

1123 ISpecifyPropertyPages *property_pages = NULL;

1124 IUnknown *device_filter_iunknown = NULL;

1125 HRESULT hr;

1126 FILTER_INFO filter_info = {0}; /* a warning on this line is false positive GCC bug 53119 AFAICT */

1127 CAUUID ca_guid = {0};

1128

1129 hr = IBaseFilter_QueryInterface(device_filter, &IID_ISpecifyPropertyPages, (void **)&property_pages);

1130 if (hr != S_OK) {

1131 av_log(avctx, AV_LOG_WARNING, "requested filter does not have a property page to show");

1132 goto end;

1133 }

1134 hr = IBaseFilter_QueryFilterInfo(device_filter, &filter_info);

1135 if (hr != S_OK) {

1136 goto fail;

1137 }

1138 hr = IBaseFilter_QueryInterface(device_filter, &IID_IUnknown, (void **)&device_filter_iunknown);

1139 if (hr != S_OK) {

1140 goto fail;

1141 }

1142 hr = ISpecifyPropertyPages_GetPages(property_pages, &ca_guid);

1143 if (hr != S_OK) {

1144 goto fail;

1145 }

1146 hr = OleCreatePropertyFrame(NULL, 0, 0, filter_info.achName, 1, &device_filter_iunknown, ca_guid.cElems,

1147 ca_guid.pElems, 0, 0, NULL);

1148 if (hr != S_OK) {

1149 goto fail;

1150 }

1151 goto end;

1152 fail:

1153 av_log(avctx, AV_LOG_ERROR, "Failure showing property pages for filter");

1154 end:

1155 if (property_pages)

1156 ISpecifyPropertyPages_Release(property_pages);

1157 if (device_filter_iunknown)

1158 IUnknown_Release(device_filter_iunknown);

1159 if (filter_info.pGraph)

1160 IFilterGraph_Release(filter_info.pGraph);

1161 if (ca_guid.pElems)

1162 CoTaskMemFree(ca_guid.pElems);

1163 }

1164

1165 /**

1166 * Cycle through available pins using the device_filter device, of type

1167 * devtype, retrieve the first output pin and return the pointer to the

1168 * object found in *ppin.

1169 * If ppin is NULL, cycle through all pins listing audio/video capabilities.

1170 */

1171 static int

1172 dshow_cycle_pins(AVFormatContext *avctx, enum dshowDeviceType devtype,

1173 enum dshowSourceFilterType sourcetype, IBaseFilter *device_filter, IPin **ppin)

1174 {

1175 struct dshow_ctx *ctx = avctx->priv_data;

1176 IEnumPins *pins = 0;

1177 IPin *device_pin = NULL;

1178 IPin *pin;

1179 int r;

1180

1181 const char *devtypename = (devtype == VideoDevice) ? "video" : "audio only";

1182 const char *sourcetypename = (sourcetype == VideoSourceDevice) ? "video" : "audio";

1183

1184 int set_format = dshow_should_set_format(avctx, devtype);

1185 int format_set = 0;

1186 int should_show_properties = (devtype == VideoDevice) ? ctx->show_video_device_dialog : ctx->show_audio_device_dialog;

1187

1188 if (should_show_properties)

1189 ff_dshow_show_filter_properties(device_filter, avctx);

1190

1191 r = IBaseFilter_EnumPins(device_filter, &pins);

1192 if (r != S_OK) {

1193 av_log(avctx, AV_LOG_ERROR, "Could not enumerate pins.\n");

1194 return AVERROR(EIO);

1195 }

1196

1197 if (!ppin) {

1198 av_log(avctx, AV_LOG_INFO, "DirectShow %s device options (from %s devices)\n",

1199 devtypename, sourcetypename);

1200 }

1201

1202 while (!device_pin && IEnumPins_Next(pins, 1, &pin, NULL) == S_OK) {

1203 IKsPropertySet *p = NULL;

1204 PIN_INFO info = {0};

1205 GUID category;

1206 DWORD r2;

1207 char *name_buf = NULL;

1208 wchar_t *pin_id = NULL;

1209 char *pin_buf = NULL;

1210 char *desired_pin_name = devtype == VideoDevice ? ctx->video_pin_name : ctx->audio_pin_name;

1211

1212 IPin_QueryPinInfo(pin, &info);

1213 IBaseFilter_Release(info.pFilter);

1214

1215 if (info.dir != PINDIR_OUTPUT)

1216 goto next;

1217 if (IPin_QueryInterface(pin, &IID_IKsPropertySet, (void **) &p) != S_OK)

1218 goto next;

1219 if (IKsPropertySet_Get(p, &AMPROPSETID_Pin, AMPROPERTY_PIN_CATEGORY,

1220 NULL, 0, &category, sizeof(GUID), &r2) != S_OK)

1221 goto next;

1222 if (!IsEqualGUID(&category, &PIN_CATEGORY_CAPTURE))

1223 goto next;

1224 name_buf = dup_wchar_to_utf8(info.achName);

1225

1226 r = IPin_QueryId(pin, &pin_id);

1227 if (r != S_OK) {

1228 av_log(avctx, AV_LOG_ERROR, "Could not query pin id\n");

1229 return AVERROR(EIO);

1230 }

1231 pin_buf = dup_wchar_to_utf8(pin_id);

1232

1233 if (!ppin) {

1234 av_log(avctx, AV_LOG_INFO, " Pin \"%s\" (alternative pin name \"%s\")\n", name_buf, pin_buf);

1235 dshow_cycle_formats(avctx, devtype, pin, NULL);

1236 goto next;

1237 }

1238

1239 if (desired_pin_name) {

1240 if(strcmp(name_buf, desired_pin_name) && strcmp(pin_buf, desired_pin_name)) {

1241 av_log(avctx, AV_LOG_DEBUG, "skipping pin \"%s\" (\"%s\") != requested \"%s\"\n",

1242 name_buf, pin_buf, desired_pin_name);

1243 goto next;

1244 }

1245 }

1246

1247 // will either try to find format matching options supplied by user

1248 // or try to open default format. Successful if returns with format_set==1

1249 dshow_cycle_formats(avctx, devtype, pin, &format_set);

1250 if (!format_set) {

1251 goto next;

1252 }

1253

1254 if (devtype == AudioDevice && ctx->audio_buffer_size) {

1255 if (dshow_set_audio_buffer_size(avctx, pin) < 0) {

1256 av_log(avctx, AV_LOG_ERROR, "unable to set audio buffer size %d to pin, using pin anyway...", ctx->audio_buffer_size);

1257 }

1258 }

1259

1260 if (format_set) {

1261 device_pin = pin;

1262 av_log(avctx, AV_LOG_DEBUG, "Selecting pin %s on %s\n", name_buf, devtypename);

1263 }

1264 next:

1265 if (p)

1266 IKsPropertySet_Release(p);

1267 if (device_pin != pin)

1268 IPin_Release(pin);

1269 av_free(name_buf);

1270 av_free(pin_buf);

1271 if (pin_id)

1272 CoTaskMemFree(pin_id);

1273 }

1274

1275 IEnumPins_Release(pins);

1276

1277 if (ppin) {

1278 if (set_format && !format_set) {

1279 av_log(avctx, AV_LOG_ERROR, "Could not set %s options\n", devtypename);

1280 return AVERROR(EIO);

1281 }

1282 if (!device_pin) {

1283 av_log(avctx, AV_LOG_ERROR,

1284 "Could not find output pin from %s capture device.\n", devtypename);

1285 return AVERROR(EIO);

1286 }

1287 *ppin = device_pin;

1288 }

1289

1290 return 0;

1291 }

1292

1293 /**

1294 * List options for device with type devtype, source filter type sourcetype

1295 *

1296 * @param devenum device enumerator used for accessing the device

1297 */

1298 static int

1299 dshow_list_device_options(AVFormatContext *avctx, ICreateDevEnum *devenum,

1300 enum dshowDeviceType devtype, enum dshowSourceFilterType sourcetype)

1301 {

1302 struct dshow_ctx *ctx = avctx->priv_data;

1303 IBaseFilter *device_filter = NULL;

1304 char *device_unique_name = NULL;

1305 int r;

1306

1307 if ((r = dshow_cycle_devices(avctx, devenum, devtype, sourcetype, &device_filter, &device_unique_name, NULL)) < 0)

1308 return r;

1309 ctx->device_filter[devtype] = device_filter;

1310 ctx->device_unique_name[devtype] = device_unique_name;

1311 if ((r = dshow_cycle_pins(avctx, devtype, sourcetype, device_filter, NULL)) < 0)

1312 return r;

1313 return 0;

1314 }

1315

1316 static int

1317 dshow_open_device(AVFormatContext *avctx, ICreateDevEnum *devenum,

1318 enum dshowDeviceType devtype, enum dshowSourceFilterType sourcetype)

1319 {

1320 struct dshow_ctx *ctx = avctx->priv_data;

1321 IBaseFilter *device_filter = NULL;

1322 char *device_filter_unique_name = NULL;

1323 IGraphBuilder *graph = ctx->graph;

1324 IPin *device_pin = NULL;

1325 DShowPin *capture_pin = NULL;

1326 DShowFilter *capture_filter = NULL;

1327 ICaptureGraphBuilder2 *graph_builder2 = NULL;

1328 int ret = AVERROR(EIO);

1329 int r;

1330 IStream *ifile_stream = NULL;

1331 IStream *ofile_stream = NULL;

1332 IPersistStream *pers_stream = NULL;

1333 enum dshowDeviceType otherDevType = (devtype == VideoDevice) ? AudioDevice : VideoDevice;

1334

1335 const wchar_t *filter_name[2] = { L "Audio capture filter", L "Video capture filter" };

1336

1337

1338 if ( ((ctx->audio_filter_load_file) && (strlen(ctx->audio_filter_load_file)>0) && (sourcetype == AudioSourceDevice)) ||

1339 ((ctx->video_filter_load_file) && (strlen(ctx->video_filter_load_file)>0) && (sourcetype == VideoSourceDevice)) ) {

1340 HRESULT hr;

1341 char *filename = NULL;

1342

1343 if (sourcetype == AudioSourceDevice)

1344 filename = ctx->audio_filter_load_file;

1345 else

1346 filename = ctx->video_filter_load_file;

1347

1348 hr = SHCreateStreamOnFile ((LPCSTR) filename, STGM_READ, &ifile_stream);

1349 if (S_OK != hr) {

1350 av_log(avctx, AV_LOG_ERROR, "Could not open capture filter description file.\n");

1351 goto error;

1352 }

1353

1354 hr = OleLoadFromStream(ifile_stream, &IID_IBaseFilter, (void **) &device_filter);

1355 if (hr != S_OK) {

1356 av_log(avctx, AV_LOG_ERROR, "Could not load capture filter from file.\n");

1357 goto error;

1358 }

1359

1360 if (sourcetype == AudioSourceDevice)

1361 av_log(avctx, AV_LOG_INFO, "Audio-");

1362 else

1363 av_log(avctx, AV_LOG_INFO, "Video-");

1364 av_log(avctx, AV_LOG_INFO, "Capture filter loaded successfully from file \"%s\".\n", filename);

1365 } else {

1366

1367 if ((r = dshow_cycle_devices(avctx, devenum, devtype, sourcetype, &device_filter, &device_filter_unique_name, NULL)) < 0) {

1368 ret = r;

1369 goto error;

1370 }

1371 }

1372 if (ctx->device_filter[otherDevType]) {

1373 // avoid adding add two instances of the same device to the graph, one for video, one for audio

1374 // a few devices don't support this (could also do this check earlier to avoid double crossbars, etc. but they seem OK)

1375 if (strcmp(device_filter_unique_name, ctx->device_unique_name[otherDevType]) == 0) {

1376 av_log(avctx, AV_LOG_DEBUG, "reusing previous graph capture filter... %s\n", device_filter_unique_name);

1377 IBaseFilter_Release(device_filter);

1378 device_filter = ctx->device_filter[otherDevType];

1379 IBaseFilter_AddRef(ctx->device_filter[otherDevType]);

1380 } else {

1381 av_log(avctx, AV_LOG_DEBUG, "not reusing previous graph capture filter %s != %s\n", device_filter_unique_name, ctx->device_unique_name[otherDevType]);

1382 }

1383 }

1384

1385 ctx->device_filter [devtype] = device_filter;

1386 ctx->device_unique_name [devtype] = device_filter_unique_name;

1387

1388 r = IGraphBuilder_AddFilter(graph, device_filter, NULL);

1389 if (r != S_OK) {

1390 av_log(avctx, AV_LOG_ERROR, "Could not add device filter to graph.\n");

1391 goto error;

1392 }

1393

1394 if ((r = dshow_cycle_pins(avctx, devtype, sourcetype, device_filter, &device_pin)) < 0) {

1395 ret = r;

1396 goto error;

1397 }

1398

1399 ctx->device_pin[devtype] = device_pin;

1400

1401 capture_filter = ff_dshow_filter_Create(avctx, callback, devtype);

1402 if (!capture_filter) {

1403 av_log(avctx, AV_LOG_ERROR, "Could not create grabber filter.\n");

1404 goto error;

1405 }

1406 ctx->capture_filter[devtype] = capture_filter;

1407

1408 if ( ((ctx->audio_filter_save_file) && (strlen(ctx->audio_filter_save_file)>0) && (sourcetype == AudioSourceDevice)) ||

1409 ((ctx->video_filter_save_file) && (strlen(ctx->video_filter_save_file)>0) && (sourcetype == VideoSourceDevice)) ) {

1410

1411 HRESULT hr;

1412 char *filename = NULL;

1413

1414 if (sourcetype == AudioSourceDevice)

1415 filename = ctx->audio_filter_save_file;

1416 else

1417 filename = ctx->video_filter_save_file;

1418

1419 hr = SHCreateStreamOnFile ((LPCSTR) filename, STGM_CREATE | STGM_READWRITE, &ofile_stream);

1420 if (S_OK != hr) {

1421 av_log(avctx, AV_LOG_ERROR, "Could not create capture filter description file.\n");

1422 goto error;

1423 }

1424

1425 hr = IBaseFilter_QueryInterface(device_filter, &IID_IPersistStream, (void **) &pers_stream);

1426 if (hr != S_OK) {

1427 av_log(avctx, AV_LOG_ERROR, "Query for IPersistStream failed.\n");

1428 goto error;

1429 }

1430

1431 hr = OleSaveToStream(pers_stream, ofile_stream);

1432 if (hr != S_OK) {

1433 av_log(avctx, AV_LOG_ERROR, "Could not save capture filter \n");

1434 goto error;

1435 }

1436

1437 hr = IStream_Commit(ofile_stream, STGC_DEFAULT);

1438 if (S_OK != hr) {

1439 av_log(avctx, AV_LOG_ERROR, "Could not commit capture filter data to file.\n");

1440 goto error;

1441 }

1442

1443 if (sourcetype == AudioSourceDevice)

1444 av_log(avctx, AV_LOG_INFO, "Audio-");

1445 else

1446 av_log(avctx, AV_LOG_INFO, "Video-");

1447 av_log(avctx, AV_LOG_INFO, "Capture filter saved successfully to file \"%s\".\n", filename);

1448 }

1449

1450 r = IGraphBuilder_AddFilter(graph, (IBaseFilter *) capture_filter,

1451 filter_name[devtype]);

1452 if (r != S_OK) {

1453 av_log(avctx, AV_LOG_ERROR, "Could not add capture filter to graph\n");

1454 goto error;

1455 }

1456

1457 ff_dshow_pin_AddRef(capture_filter->pin);

1458 capture_pin = capture_filter->pin;

1459 ctx->capture_pin[devtype] = capture_pin;

1460

1461 r = CoCreateInstance(&CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER,

1462 &IID_ICaptureGraphBuilder2, (void **) &graph_builder2);

1463 if (r != S_OK) {

1464 av_log(avctx, AV_LOG_ERROR, "Could not create CaptureGraphBuilder2\n");

1465 goto error;

1466 }

1467 ICaptureGraphBuilder2_SetFiltergraph(graph_builder2, graph);

1468 if (r != S_OK) {

1469 av_log(avctx, AV_LOG_ERROR, "Could not set graph for CaptureGraphBuilder2\n");

1470 goto error;

1471 }

1472

1473 r = ICaptureGraphBuilder2_RenderStream(graph_builder2, NULL, NULL, (IUnknown *) device_pin, NULL /* no intermediate filter */,

1474 (IBaseFilter *) capture_filter); /* connect pins, optionally insert intermediate filters like crossbar if necessary */

1475

1476 if (r != S_OK) {

1477 av_log(avctx, AV_LOG_ERROR, "Could not RenderStream to connect pins\n");

1478 goto error;

1479 }

1480

1481 r = ff_dshow_try_setup_crossbar_options(graph_builder2, device_filter, devtype, avctx);

1482

1483 if (r != S_OK) {

1484 av_log(avctx, AV_LOG_ERROR, "Could not setup CrossBar\n");

1485 goto error;

1486 }

1487

1488 ret = 0;

1489

1490 error:

1491 if (graph_builder2 != NULL)

1492 ICaptureGraphBuilder2_Release(graph_builder2);

1493

1494 if (pers_stream)

1495 IPersistStream_Release(pers_stream);

1496

1497 if (ifile_stream)

1498 IStream_Release(ifile_stream);

1499

1500 if (ofile_stream)

1501 IStream_Release(ofile_stream);

1502

1503 return ret;

1504 }

1505

1506 static enum AVCodecID waveform_codec_id(enum AVSampleFormat sample_fmt)

1507 {

1508 switch (sample_fmt) {

1509 case AV_SAMPLE_FMT_U8: return AV_CODEC_ID_PCM_U8;

1510 case AV_SAMPLE_FMT_S16: return AV_CODEC_ID_PCM_S16LE;

1511 case AV_SAMPLE_FMT_S32: return AV_CODEC_ID_PCM_S32LE;

1512 default: return AV_CODEC_ID_NONE; /* Should never happen. */

1513 }

1514 }

1515

1516 static enum AVSampleFormat sample_fmt_bits_per_sample(int bits)

1517 {

1518 switch (bits) {

1519 case 8: return AV_SAMPLE_FMT_U8;

1520 case 16: return AV_SAMPLE_FMT_S16;

1521 case 32: return AV_SAMPLE_FMT_S32;

1522 default: return AV_SAMPLE_FMT_NONE; /* Should never happen. */

1523 }

1524 }

1525

1526 static int

1527 dshow_add_device(AVFormatContext *avctx,

1528 enum dshowDeviceType devtype)

1529 {

1530 struct dshow_ctx *ctx = avctx->priv_data;

1531 AM_MEDIA_TYPE type;

1532 AVCodecParameters *par;

1533 AVStream *st;

1534 struct dshow_format_info *fmt_info = NULL;

1535 int ret = AVERROR(EIO);

1536

1537 type.pbFormat = NULL;

1538

1539 st = avformat_new_stream(avctx, NULL);

1540 if (!st) {

1541 ret = AVERROR(ENOMEM);

1542 goto error;

1543 }

1544 st->id = devtype;

1545

1546 ctx->capture_filter[devtype]->stream_index = st->index;

1547

1548 ff_dshow_pin_ConnectionMediaType(ctx->capture_pin[devtype], &type);

1549 fmt_info = dshow_get_format_info(&type);

1550 if (!fmt_info) {

1551 ret = AVERROR(EIO);

1552 goto error;

1553 }

1554

1555 par = st->codecpar;

1556 if (devtype == VideoDevice) {

1557 BITMAPINFOHEADER *bih = NULL;

1558 AVRational time_base;

1559

1560 if (IsEqualGUID(&type.formattype, &FORMAT_VideoInfo)) {

1561 VIDEOINFOHEADER *v = (void *) type.pbFormat;

1562 time_base = (AVRational) { v->AvgTimePerFrame, 10000000 };

1563 bih = &v->bmiHeader;

1564 } else if (IsEqualGUID(&type.formattype, &FORMAT_VideoInfo2)) {

1565 VIDEOINFOHEADER2 *v = (void *) type.pbFormat;

1566 time_base = (AVRational) { v->AvgTimePerFrame, 10000000 };

1567 bih = &v->bmiHeader;

1568 }

1569 if (!bih) {

1570 av_log(avctx, AV_LOG_ERROR, "Could not get media type.\n");

1571 goto error;

1572 }

1573

1574 st->avg_frame_rate = av_inv_q(time_base);

1575 st->r_frame_rate = av_inv_q(time_base);

1576

1577 par->codec_type = AVMEDIA_TYPE_VIDEO;

1578 par->width = fmt_info->width;

1579 par->height = fmt_info->height;

1580 par->codec_tag = bih->biCompression;

1581 par->format = fmt_info->pix_fmt;

1582 if (bih->biCompression == MKTAG('H', 'D', 'Y', 'C')) {

1583 av_log(avctx, AV_LOG_DEBUG, "attempt to use full range for HDYC...\n");

1584 par->color_range = AVCOL_RANGE_MPEG; // just in case it needs this...

1585 }

1586 par->color_range = fmt_info->col_range;

1587 par->color_space = fmt_info->col_space;

1588 par->color_primaries = fmt_info->col_prim;

1589 par->color_trc = fmt_info->col_trc;

1590 par->chroma_location = fmt_info->chroma_loc;

1591 par->codec_id = fmt_info->codec_id;

1592 if (par->codec_id == AV_CODEC_ID_RAWVIDEO) {

1593 if (bih->biCompression == BI_RGB || bih->biCompression == BI_BITFIELDS) {

1594 par->bits_per_coded_sample = bih->biBitCount;

1595 if (par->height < 0) {

1596 par->height *= -1;

1597 } else {

1598 par->extradata = av_malloc(9 + AV_INPUT_BUFFER_PADDING_SIZE);

1599 if (par->extradata) {

1600 par->extradata_size = 9;

1601 memcpy(par->extradata, "BottomUp", 9);

1602 }

1603 }

1604 }

1605 } else {

1606 if (par->codec_id == AV_CODEC_ID_NONE) {

1607 av_log(avctx, AV_LOG_ERROR, "Unknown compression type. "

1608 "Please report type 0x%X.\n", (int) bih->biCompression);

1609 ret = AVERROR_PATCHWELCOME;

1610 goto error;

1611 }

1612 par->bits_per_coded_sample = bih->biBitCount;

1613 }

1614 } else {

1615 if (!IsEqualGUID(&type.formattype, &FORMAT_WaveFormatEx)) {

1616 av_log(avctx, AV_LOG_ERROR, "Could not get media type.\n");

1617 goto error;

1618 }

1619

1620 par->codec_type = AVMEDIA_TYPE_AUDIO;

1621 par->format = sample_fmt_bits_per_sample(fmt_info->sample_size);

1622 par->codec_id = waveform_codec_id(par->format);

1623 par->sample_rate = fmt_info->sample_rate;

1624 par->channels = fmt_info->channels;

1625 }

1626

1627 avpriv_set_pts_info(st, 64, 1, 10000000);

1628

1629 ret = 0;

1630

1631 error:

1632 av_freep(&fmt_info);

1633 if (type.pbFormat)

1634 CoTaskMemFree(type.pbFormat);

1635 return ret;

1636 }

1637

1638 static int parse_device_name(AVFormatContext *avctx)

1639 {

1640 struct dshow_ctx *ctx = avctx->priv_data;

1641 char **device_name = ctx->device_name;

1642 char *name = av_strdup(avctx->url);

1643 char *tmp = name;

1644 int ret = 1;

1645 char *type;

1646

1647 while ((type = strtok(tmp, "="))) {

1648 char *token = strtok(NULL, ":");

1649 tmp = NULL;

1650

1651 if (!strcmp(type, "video")) {

1652 device_name[0] = token;

1653 } else if (!strcmp(type, "audio")) {

1654 device_name[1] = token;

1655 } else {

1656 device_name[0] = NULL;

1657 device_name[1] = NULL;

1658 break;

1659 }

1660 }

1661

1662 if (!device_name[0] && !device_name[1]) {

1663 ret = 0;

1664 } else {

1665 if (device_name[0])

1666 device_name[0] = av_strdup(device_name[0]);

1667 if (device_name[1])

1668 device_name[1] = av_strdup(device_name[1]);

1669 }

1670

1671 av_free(name);

1672 return ret;

1673 }

1674

1675 static int dshow_read_header(AVFormatContext *avctx)

1676 {

1677 struct dshow_ctx *ctx = avctx->priv_data;

1678 IGraphBuilder *graph = NULL;

1679 ICreateDevEnum *devenum = NULL;

1680 IMediaControl *control = NULL;

1681 IMediaEvent *media_event = NULL;

1682 HANDLE media_event_handle;

1683 HANDLE proc;

1684 int ret = AVERROR(EIO);

1685 int r;

1686

1687 CoInitialize(0);

1688

1689 if (!ctx->list_devices && !parse_device_name(avctx)) {

1690 av_log(avctx, AV_LOG_ERROR, "Malformed dshow input string.\n");

1691 goto error;

1692 }

1693

1694 ctx->video_codec_id = avctx->video_codec_id ? avctx->video_codec_id

1695 : AV_CODEC_ID_RAWVIDEO;

1696 if (ctx->pixel_format != AV_PIX_FMT_NONE) {

1697 if (ctx->video_codec_id != AV_CODEC_ID_RAWVIDEO) {

1698 av_log(avctx, AV_LOG_ERROR, "Pixel format may only be set when "

1699 "video codec is not set or set to rawvideo\n");

1700 ret = AVERROR(EINVAL);

1701 goto error;

1702 }

1703 }

1704 if (ctx->framerate) {

1705 r = av_parse_video_rate(&ctx->requested_framerate, ctx->framerate);

1706 if (r < 0) {

1707 av_log(avctx, AV_LOG_ERROR, "Could not parse framerate '%s'.\n", ctx->framerate);

1708 goto error;

1709 }

1710 }

1711

1712 r = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,

1713 &IID_IGraphBuilder, (void **) &graph);

1714 if (r != S_OK) {

1715 av_log(avctx, AV_LOG_ERROR, "Could not create capture graph.\n");

1716 goto error;

1717 }

1718 ctx->graph = graph;

1719

1720 r = CoCreateInstance(&CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,

1721 &IID_ICreateDevEnum, (void **) &devenum);

1722 if (r != S_OK) {

1723 av_log(avctx, AV_LOG_ERROR, "Could not enumerate system devices.\n");

1724 goto error;

1725 }

1726

1727 if (ctx->list_devices) {

1728 dshow_cycle_devices(avctx, devenum, VideoDevice, VideoSourceDevice, NULL, NULL, NULL);

1729 dshow_cycle_devices(avctx, devenum, AudioDevice, AudioSourceDevice, NULL, NULL, NULL);

1730 ret = AVERROR_EXIT;

1731 goto error;

1732 }

1733 if (ctx->list_options) {

1734 if (ctx->device_name[VideoDevice])

1735 if ((r = dshow_list_device_options(avctx, devenum, VideoDevice, VideoSourceDevice))) {

1736 ret = r;

1737 goto error;

1738 }

1739 if (ctx->device_name[AudioDevice]) {

1740 if (dshow_list_device_options(avctx, devenum, AudioDevice, AudioSourceDevice)) {

1741 /* show audio options from combined video+audio sources as fallback */

1742 if ((r = dshow_list_device_options(avctx, devenum, AudioDevice, VideoSourceDevice))) {

1743 ret = r;

1744 goto error;

1745 }

1746 }

1747 }

1748 // don't exit yet, allow it to list crossbar options in dshow_open_device

1749 }

1750 if (ctx->device_name[VideoDevice]) {

1751 if ((r = dshow_open_device(avctx, devenum, VideoDevice, VideoSourceDevice)) < 0 ||

1752 (r = dshow_add_device(avctx, VideoDevice)) < 0) {

1753 ret = r;

1754 goto error;

1755 }

1756 }

1757 if (ctx->device_name[AudioDevice]) {

1758 if ((r = dshow_open_device(avctx, devenum, AudioDevice, AudioSourceDevice)) < 0 ||

1759 (r = dshow_add_device(avctx, AudioDevice)) < 0) {

1760 av_log(avctx, AV_LOG_INFO, "Searching for audio device within video devices for %s\n", ctx->device_name[AudioDevice]);

1761 /* see if there's a video source with an audio pin with the given audio name */

1762 if ((r = dshow_open_device(avctx, devenum, AudioDevice, VideoSourceDevice)) < 0 ||

1763 (r = dshow_add_device(avctx, AudioDevice)) < 0) {

1764 ret = r;

1765 goto error;

1766 }

1767 }

1768 }

1769 if (ctx->list_options) {

1770 /* allow it to list crossbar options in dshow_open_device */

1771 ret = AVERROR_EXIT;

1772 goto error;

1773 }

1774 ctx->curbufsize[0] = 0;

1775 ctx->curbufsize[1] = 0;

1776 ctx->mutex = CreateMutex(NULL, 0, NULL);

1777 if (!ctx->mutex) {

1778 av_log(avctx, AV_LOG_ERROR, "Could not create Mutex\n");

1779 goto error;

1780 }

1781 ctx->event[1] = CreateEvent(NULL, 1, 0, NULL);

1782 if (!ctx->event[1]) {

1783 av_log(avctx, AV_LOG_ERROR, "Could not create Event\n");

1784 goto error;

1785 }

1786

1787 r = IGraphBuilder_QueryInterface(graph, &IID_IMediaControl, (void **) &control);

1788 if (r != S_OK) {

1789 av_log(avctx, AV_LOG_ERROR, "Could not get media control.\n");

1790 goto error;

1791 }

1792 ctx->control = control;

1793

1794 r = IGraphBuilder_QueryInterface(graph, &IID_IMediaEvent, (void **) &media_event);

1795 if (r != S_OK) {

1796 av_log(avctx, AV_LOG_ERROR, "Could not get media event.\n");

1797 goto error;

1798 }

1799 ctx->media_event = media_event;

1800

1801 r = IMediaEvent_GetEventHandle(media_event, (void *) &media_event_handle);

1802 if (r != S_OK) {

1803 av_log(avctx, AV_LOG_ERROR, "Could not get media event handle.\n");

1804 goto error;

1805 }

1806 proc = GetCurrentProcess();

1807 r = DuplicateHandle(proc, media_event_handle, proc, &ctx->event[0],

1808 0, 0, DUPLICATE_SAME_ACCESS);

1809 if (!r) {

1810 av_log(avctx, AV_LOG_ERROR, "Could not duplicate media event handle.\n");

1811 goto error;

1812 }

1813

1814 r = IMediaControl_Run(control);

1815 if (r == S_FALSE) {

1816 OAFilterState pfs;

1817 r = IMediaControl_GetState(control, 0, &pfs);

1818 }

1819 if (r != S_OK) {

1820 av_log(avctx, AV_LOG_ERROR, "Could not run graph (sometimes caused by a device already in use by other application)\n");

1821 goto error;

1822 }

1823

1824 ret = 0;

1825

1826 error:

1827

1828 if (devenum)

1829 ICreateDevEnum_Release(devenum);

1830

1831 if (ret < 0)

1832 dshow_read_close(avctx);

1833

1834 return ret;

1835 }

1836

1837 /**

1838 * Checks media events from DirectShow and returns -1 on error or EOF. Also

1839 * purges all events that might be in the event queue to stop the trigger

1840 * of event notification.

1841 */

1842 static int dshow_check_event_queue(IMediaEvent *media_event)

1843 {

1844 LONG_PTR p1, p2;

1845 long code;

1846 int ret = 0;

1847

1848 while (IMediaEvent_GetEvent(media_event, &code, &p1, &p2, 0) != E_ABORT) {

1849 if (code == EC_COMPLETE || code == EC_DEVICE_LOST || code == EC_ERRORABORT)

1850 ret = -1;

1851 IMediaEvent_FreeEventParams(media_event, code, p1, p2);

1852 }

1853

1854 return ret;

1855 }

1856

1857 static int dshow_read_packet(AVFormatContext *s, AVPacket *pkt)

1858 {

1859 struct dshow_ctx *ctx = s->priv_data;

1860 PacketListEntry *pktl = NULL;

1861

1862 while (!ctx->eof && !pktl) {

1863 WaitForSingleObject(ctx->mutex, INFINITE);

1864 pktl = ctx->pktl;

1865 if (pktl) {

1866 *pkt = pktl->pkt;

1867 ctx->pktl = ctx->pktl->next;

1868 av_free(pktl);

1869 ctx->curbufsize[pkt->stream_index] -= pkt->size;

1870 }

1871 ResetEvent(ctx->event[1]);

1872 ReleaseMutex(ctx->mutex);

1873 if (!pktl) {

1874 if (dshow_check_event_queue(ctx->media_event) < 0) {

1875 ctx->eof = 1;

1876 } else if (s->flags & AVFMT_FLAG_NONBLOCK) {

1877 return AVERROR(EAGAIN);

1878 } else {

1879 WaitForMultipleObjects(2, ctx->event, 0, INFINITE);

1880 }

1881 }

1882 }

1883

1884 return ctx->eof ? AVERROR(EIO) : pkt->size;

1885 }

1886

1887 #define OFFSET(x) offsetof(struct dshow_ctx, x)

1888 #define DEC AV_OPT_FLAG_DECODING_PARAM

1889 static const AVOption options[] = {

1890 { "video_size", "set video size given a string such as 640x480 or hd720.", OFFSET(requested_width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, DEC },

1891 { "pixel_format", "set video pixel format", OFFSET(pixel_format), AV_OPT_TYPE_PIXEL_FMT, {.i64 = AV_PIX_FMT_NONE}, -1, INT_MAX, DEC },

1892 { "framerate", "set video frame rate", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },

1893 { "sample_rate", "set audio sample rate", OFFSET(sample_rate), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, DEC },

1894 { "sample_size", "set audio sample size", OFFSET(sample_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 16, DEC },

1895 { "channels", "set number of audio channels, such as 1 or 2", OFFSET(channels), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, DEC },

1896 { "audio_buffer_size", "set audio device buffer latency size in milliseconds (default is the device's default)", OFFSET(audio_buffer_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, DEC },

1897 { "list_devices", "list available devices", OFFSET(list_devices), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, DEC },

1898 { "list_options", "list available options for specified device", OFFSET(list_options), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, DEC },

1899 { "video_device_number", "set video device number for devices with same name (starts at 0)", OFFSET(video_device_number), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, DEC },

1900 { "audio_device_number", "set audio device number for devices with same name (starts at 0)", OFFSET(audio_device_number), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, DEC },

1901 { "video_pin_name", "select video capture pin by name", OFFSET(video_pin_name),AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },

1902 { "audio_pin_name", "select audio capture pin by name", OFFSET(audio_pin_name),AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },

1903 { "crossbar_video_input_pin_number", "set video input pin number for crossbar device", OFFSET(crossbar_video_input_pin_number), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, DEC },

1904 { "crossbar_audio_input_pin_number", "set audio input pin number for crossbar device", OFFSET(crossbar_audio_input_pin_number), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, DEC },

1905 { "show_video_device_dialog", "display property dialog for video capture device", OFFSET(show_video_device_dialog), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DEC },

1906 { "show_audio_device_dialog", "display property dialog for audio capture device", OFFSET(show_audio_device_dialog), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DEC },

1907 { "show_video_crossbar_connection_dialog", "display property dialog for crossbar connecting pins filter on video device", OFFSET(show_video_crossbar_connection_dialog), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DEC },

1908 { "show_audio_crossbar_connection_dialog", "display property dialog for crossbar connecting pins filter on audio device", OFFSET(show_audio_crossbar_connection_dialog), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DEC },

1909 { "show_analog_tv_tuner_dialog", "display property dialog for analog tuner filter", OFFSET(show_analog_tv_tuner_dialog), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DEC },

1910 { "show_analog_tv_tuner_audio_dialog", "display property dialog for analog tuner audio filter", OFFSET(show_analog_tv_tuner_audio_dialog), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DEC },

1911 { "audio_device_load", "load audio capture filter device (and properties) from file", OFFSET(audio_filter_load_file), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },

1912 { "audio_device_save", "save audio capture filter device (and properties) to file", OFFSET(audio_filter_save_file), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },

1913 { "video_device_load", "load video capture filter device (and properties) from file", OFFSET(video_filter_load_file), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },

1914 { "video_device_save", "save video capture filter device (and properties) to file", OFFSET(video_filter_save_file), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },

1915 { "use_video_device_timestamps", "use device instead of wallclock timestamps for video frames", OFFSET(use_video_device_timestamps), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, DEC },

1916 { NULL },

1917 };

1918

1919 static const AVClass dshow_class = {

1920 .class_name = "dshow indev",

1921 .item_name = av_default_item_name,

1922 .option = options,

1923 .version = LIBAVUTIL_VERSION_INT,

1924 .category = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,

1925 };

1926

1927 const AVInputFormat ff_dshow_demuxer = {

1928 .name = "dshow",

1929 .long_name = NULL_IF_CONFIG_SMALL("DirectShow capture"),

1930 .priv_data_size = sizeof(struct dshow_ctx),

1931 .read_header = dshow_read_header,

1932 .read_packet = dshow_read_packet,

1933 .read_close = dshow_read_close,

1934 .get_device_list= dshow_get_device_list,

1935 .flags = AVFMT_NOFILE | AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH | AVFMT_NO_BYTE_SEEK,

1936 .priv_class = &dshow_class,

1937 };

AVCOL_PRI_RESERVED

@ AVCOL_PRI_RESERVED

Definition: pixfmt.h:473

avformat_get_riff_video_tags

const struct AVCodecTag * avformat_get_riff_video_tags(void)

Definition: riff.c:622

error

static void error(const char *err)

Definition: target_bsf_fuzzer.c:31

AV_CODEC_ID_PCM_S16LE

@ AV_CODEC_ID_PCM_S16LE

Definition: codec_id.h:314

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: avpacket.c:424

AVCodec

AVCodec.

Definition: codec.h:202

av_codec_get_id

enum AVCodecID av_codec_get_id(const struct AVCodecTag *const *tags, unsigned int tag)

Get the AVCodecID for the given codec tag tag.

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

dshow_ctx::show_audio_crossbar_connection_dialog

int show_audio_crossbar_connection_dialog

Definition: dshow_capture.h:310

AVCodecParameters::extradata

uint8_t * extradata

Extra binary data needed for initializing the decoder, codec-dependent.

Definition: codec_par.h:74

AVPixelFormat

Pixel format.

Definition: pixfmt.h:64

name

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name

Definition: writing_filters.txt:88

AVFMT_NO_BYTE_SEEK

#define AVFMT_NO_BYTE_SEEK

Format does not allow seeking by bytes.

Definition: avformat.h:483

dshow_format_info::height

int height

Definition: dshow.c:684

dshow_open_device

static int dshow_open_device(AVFormatContext *avctx, ICreateDevEnum *devenum, enum dshowDeviceType devtype, enum dshowSourceFilterType sourcetype)

Definition: dshow.c:1317

const char * r

Definition: vf_curves.c:116

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

opt.h

avformat_new_stream

AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)

Add a new stream to a media file.

Definition: utils.c:768

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:56

dshow_ctx::list_devices

int list_devices

Definition: dshow_capture.h:301

space

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated space

Definition: undefined.txt:4

AVColorTransferCharacteristic

Color Transfer Characteristic.

Definition: pixfmt.h:494

dshow_get_format_info

static struct dshow_format_info * dshow_get_format_info(AM_MEDIA_TYPE *type)

Definition: dshow.c:692

dshow_ctx::requested_width

int requested_width

Definition: dshow_capture.h:341

AVCodecParameters

This struct describes the properties of an encoded stream.

Definition: codec_par.h:52

VideoDevice

@ VideoDevice

Definition: dshow_capture.h:63

dshow_color_primaries

static enum AVColorPrimaries dshow_color_primaries(DXVA2_ExtendedFormat *fmt_info)

Definition: dshow.c:130

AVCodecParameters::color_space

enum AVColorSpace color_space

Definition: codec_par.h:149

ff_dshow_pin_Release

unsigned long WINAPI ff_dshow_pin_Release(DShowPin *)

dshow_ctx::media_event

IMediaEvent * media_event

Definition: dshow_capture.h:335

AVCOL_TRC_LINEAR

@ AVCOL_TRC_LINEAR

"Linear transfer characteristics"

Definition: pixfmt.h:503

dshow_capture.h

AVDeviceInfo::device_name

char * device_name

device name, format depends on device

Definition: avdevice.h:458

dshow_ctx::video_filter_save_file

char * video_filter_save_file

Definition: dshow_capture.h:316

DEC

#define DEC

Definition: dshow.c:1888

AV_CODEC_ID_RAWVIDEO

@ AV_CODEC_ID_RAWVIDEO

Definition: codec_id.h:63

ff_print_VIDEO_STREAM_CONFIG_CAPS

void ff_print_VIDEO_STREAM_CONFIG_CAPS(const VIDEO_STREAM_CONFIG_CAPS *caps)

Definition: dshow_common.c:85

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:26

pixdesc.h

index

fg index

Definition: ffmpeg_filter.c:167

uint8_t w

Definition: llviddspenc.c:38

AVCOL_RANGE_JPEG

@ AVCOL_RANGE_JPEG

Full range content.

Definition: pixfmt.h:597

dshow_read_close

static int dshow_read_close(AVFormatContext *s)

Definition: dshow.c:238

AVPacket::data

uint8_t * data

Definition: packet.h:373

shall_we_drop

static int shall_we_drop(AVFormatContext *s, int index, enum dshowDeviceType devtype)

Definition: dshow.c:322

dshow_class

static const AVClass dshow_class

Definition: dshow.c:1919

AVOption

AVOption.

Definition: opt.h:247

AVCOL_TRC_UNSPECIFIED

@ AVCOL_TRC_UNSPECIFIED

Definition: pixfmt.h:497

chroma

static av_always_inline void chroma(WaveformContext *s, AVFrame *in, AVFrame *out, int component, int intensity, int offset_y, int offset_x, int column, int mirror, int jobnr, int nb_jobs)

Definition: vf_waveform.c:1634

AVStream::avg_frame_rate

AVRational avg_frame_rate

Average framerate.

Definition: avformat.h:1015

AV_PIX_FMT_MONOWHITE

@ AV_PIX_FMT_MONOWHITE

Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.

Definition: pixfmt.h:75

AVCOL_TRC_BT2020_12

@ AVCOL_TRC_BT2020_12

ITU-R BT2020 for 12-bit system.

Definition: pixfmt.h:510