用directshow 获取摄像头名称

最新推荐文章于 2024-06-24 17:24:39 发布
最新推荐文章于 2024-06-24 17:24:39 发布
阅读量1.8k 收藏 1
点赞数
分类专栏： h264相关
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiongying789/article/details/52943491
版权

CameraInfo.cpp


#include "CameraInfoDef.h"
#include "CameraInfo.h";
const struct PixelFormatTag *avpriv_get_raw_pix_fmt_tags(void);
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc);
CameraInfoForUsb g_cameraInfo = {0};
const PixelFormatTag  ff_raw_pix_fmt_tags[] = {
    { AV_PIX_FMT_YUV420P, MKTAG('I', '4', '2', '0') }, /* Planar formats */
    { AV_PIX_FMT_YUV420P, MKTAG('I', 'Y', 'U', 'V') },
    { AV_PIX_FMT_YUV420P, MKTAG('Y', 'V', '1', '2') },
    { AV_PIX_FMT_YUV410P, MKTAG('Y', 'U', 'V', '9') },
    { AV_PIX_FMT_YUV410P, MKTAG('Y', 'V', 'U', '9') },
    { AV_PIX_FMT_YUV411P, MKTAG('Y', '4', '1', 'B') },
    { AV_PIX_FMT_YUV422P, MKTAG('Y', '4', '2', 'B') },
    { AV_PIX_FMT_YUV422P, MKTAG('P', '4', '2', '2') },
    { AV_PIX_FMT_YUV422P, MKTAG('Y', 'V', '1', '6') },
    /* yuvjXXX formats are deprecated hacks specific to libav*,
       they are identical to yuvXXX  */
    { AV_PIX_FMT_YUVJ420P, MKTAG('I', '4', '2', '0') }, /* Planar formats */
    { AV_PIX_FMT_YUVJ420P, MKTAG('I', 'Y', 'U', 'V') },
    { AV_PIX_FMT_YUVJ420P, MKTAG('Y', 'V', '1', '2') },
    { AV_PIX_FMT_YUVJ422P, MKTAG('Y', '4', '2', 'B') },
    { AV_PIX_FMT_YUVJ422P, MKTAG('P', '4', '2', '2') },
    { AV_PIX_FMT_GRAY8,    MKTAG('Y', '8', '0', '0') },
    { AV_PIX_FMT_GRAY8,    MKTAG('Y', '8', ' ', ' ') },

    { AV_PIX_FMT_YUYV422, MKTAG('Y', 'U', 'Y', '2') }, /* Packed formats */
    { AV_PIX_FMT_YUYV422, MKTAG('Y', '4', '2', '2') },
    { AV_PIX_FMT_YUYV422, MKTAG('V', '4', '2', '2') },
    { AV_PIX_FMT_YUYV422, MKTAG('V', 'Y', 'U', 'Y') },
    { AV_PIX_FMT_YUYV422, MKTAG('Y', 'U', 'N', 'V') },
    { AV_PIX_FMT_YVYU422, MKTAG('Y', 'V', 'Y', 'U') }, /* Philips */
    { AV_PIX_FMT_UYVY422, MKTAG('U', 'Y', 'V', 'Y') },
    { AV_PIX_FMT_UYVY422, MKTAG('H', 'D', 'Y', 'C') },
    { AV_PIX_FMT_UYVY422, MKTAG('U', 'Y', 'N', 'V') },
    { AV_PIX_FMT_UYVY422, MKTAG('U', 'Y', 'N', 'Y') },
    { AV_PIX_FMT_UYVY422, MKTAG('u', 'y', 'v', '1') },
    { AV_PIX_FMT_UYVY422, MKTAG('2', 'V', 'u', '1') },
    { AV_PIX_FMT_UYVY422, MKTAG('A', 'V', 'R', 'n') }, /* Avid AVI Codec 1:1 */
    { AV_PIX_FMT_UYVY422, MKTAG('A', 'V', '1', 'x') }, /* Avid 1:1x */
    { AV_PIX_FMT_UYVY422, MKTAG('A', 'V', 'u', 'p') },
    { AV_PIX_FMT_UYVY422, MKTAG('V', 'D', 'T', 'Z') }, /* SoftLab-NSK VideoTizer */
    { AV_PIX_FMT_UYVY422, MKTAG('a', 'u', 'v', '2') },
    { AV_PIX_FMT_UYVY422, MKTAG('c', 'y', 'u', 'v') }, /* CYUV is also Creative YUV */
    { AV_PIX_FMT_UYYVYY411, MKTAG('Y', '4', '1', '1') },
    { AV_PIX_FMT_GRAY8,   MKTAG('G', 'R', 'E', 'Y') },
    { AV_PIX_FMT_NV12,    MKTAG('N', 'V', '1', '2') },
    { AV_PIX_FMT_NV21,    MKTAG('N', 'V', '2', '1') },

    /* nut */
    { AV_PIX_FMT_RGB555LE, MKTAG('R', 'G', 'B', 15) },
    { AV_PIX_FMT_BGR555LE, MKTAG('B', 'G', 'R', 15) },
    { AV_PIX_FMT_RGB565LE, MKTAG('R', 'G', 'B', 16) },
    { AV_PIX_FMT_BGR565LE, MKTAG('B', 'G', 'R', 16) },
    { AV_PIX_FMT_RGB555BE, MKTAG(15 , 'B', 'G', 'R') },
    { AV_PIX_FMT_BGR555BE, MKTAG(15 , 'R', 'G', 'B') },
    { AV_PIX_FMT_RGB565BE, MKTAG(16 , 'B', 'G', 'R') },
    { AV_PIX_FMT_BGR565BE, MKTAG(16 , 'R', 'G', 'B') },
    { AV_PIX_FMT_RGB444LE, MKTAG('R', 'G', 'B', 12) },
    { AV_PIX_FMT_BGR444LE, MKTAG('B', 'G', 'R', 12) },
    { AV_PIX_FMT_RGB444BE, MKTAG(12 , 'B', 'G', 'R') },
    { AV_PIX_FMT_BGR444BE, MKTAG(12 , 'R', 'G', 'B') },
    { AV_PIX_FMT_RGBA64LE, MKTAG('R', 'B', 'A', 64 ) },
    { AV_PIX_FMT_BGRA64LE, MKTAG('B', 'R', 'A', 64 ) },
    { AV_PIX_FMT_RGBA64BE, MKTAG(64 , 'R', 'B', 'A') },
    { AV_PIX_FMT_BGRA64BE, MKTAG(64 , 'B', 'R', 'A') },
    { AV_PIX_FMT_RGBA,     MKTAG('R', 'G', 'B', 'A') },
    { AV_PIX_FMT_RGB0,     MKTAG('R', 'G', 'B',  0 ) },
    { AV_PIX_FMT_BGRA,     MKTAG('B', 'G', 'R', 'A') },
    { AV_PIX_FMT_BGR0,     MKTAG('B', 'G', 'R',  0 ) },
    { AV_PIX_FMT_ABGR,     MKTAG('A', 'B', 'G', 'R') },
    { AV_PIX_FMT_0BGR,     MKTAG( 0 , 'B', 'G', 'R') },
    { AV_PIX_FMT_ARGB,     MKTAG('A', 'R', 'G', 'B') },
    { AV_PIX_FMT_0RGB,     MKTAG( 0 , 'R', 'G', 'B') },
    { AV_PIX_FMT_RGB24,    MKTAG('R', 'G', 'B', 24 ) },
    { AV_PIX_FMT_BGR24,    MKTAG('B', 'G', 'R', 24 ) },
    { AV_PIX_FMT_YUV411P,  MKTAG('4', '1', '1', 'P') },
    { AV_PIX_FMT_YUV422P,  MKTAG('4', '2', '2', 'P') },
    { AV_PIX_FMT_YUVJ422P, MKTAG('4', '2', '2', 'P') },
    { AV_PIX_FMT_YUV440P,  MKTAG('4', '4', '0', 'P') },
    { AV_PIX_FMT_YUVJ440P, MKTAG('4', '4', '0', 'P') },
    { AV_PIX_FMT_YUV444P,  MKTAG('4', '4', '4', 'P') },
    { AV_PIX_FMT_YUVJ444P, MKTAG('4', '4', '4', 'P') },
    { AV_PIX_FMT_MONOWHITE,MKTAG('B', '1', 'W', '0') },
    { AV_PIX_FMT_MONOBLACK,MKTAG('B', '0', 'W', '1') },
    { AV_PIX_FMT_BGR8,     MKTAG('B', 'G', 'R',  8 ) },
    { AV_PIX_FMT_RGB8,     MKTAG('R', 'G', 'B',  8 ) },
    { AV_PIX_FMT_BGR4,     MKTAG('B', 'G', 'R',  4 ) },
    { AV_PIX_FMT_RGB4,     MKTAG('R', 'G', 'B',  4 ) },
    { AV_PIX_FMT_RGB4_BYTE,MKTAG('B', '4', 'B', 'Y') },
    { AV_PIX_FMT_BGR4_BYTE,MKTAG('R', '4', 'B', 'Y') },
    { AV_PIX_FMT_RGB48LE,  MKTAG('R', 'G', 'B', 48 ) },
    { AV_PIX_FMT_RGB48BE,  MKTAG( 48, 'R', 'G', 'B') },
    { AV_PIX_FMT_BGR48LE,  MKTAG('B', 'G', 'R', 48 ) },
    { AV_PIX_FMT_BGR48BE,  MKTAG( 48, 'B', 'G', 'R') },
    { AV_PIX_FMT_GRAY16LE,    MKTAG('Y', '1',  0 , 16 ) },
    { AV_PIX_FMT_GRAY16BE,    MKTAG(16 ,  0 , '1', 'Y') },
    { AV_PIX_FMT_YUV420P10LE, MKTAG('Y', '3', 11 , 10 ) },
    { AV_PIX_FMT_YUV420P10BE, MKTAG(10 , 11 , '3', 'Y') },
    { AV_PIX_FMT_YUV422P10LE, MKTAG('Y', '3', 10 , 10 ) },
    { AV_PIX_FMT_YUV422P10BE, MKTAG(10 , 10 , '3', 'Y') },
    { AV_PIX_FMT_YUV444P10LE, MKTAG('Y', '3',  0 , 10 ) },
    { AV_PIX_FMT_YUV444P10BE, MKTAG(10 ,  0 , '3', 'Y') },
    { AV_PIX_FMT_YUV420P12LE, MKTAG('Y', '3', 11 , 12 ) },
    { AV_PIX_FMT_YUV420P12BE, MKTAG(12 , 11 , '3', 'Y') },
    { AV_PIX_FMT_YUV422P12LE, MKTAG('Y', '3', 10 , 12 ) },
    { AV_PIX_FMT_YUV422P12BE, MKTAG(12 , 10 , '3', 'Y') },
    { AV_PIX_FMT_YUV444P12LE, MKTAG('Y', '3',  0 , 12 ) },
    { AV_PIX_FMT_YUV444P12BE, MKTAG(12 ,  0 , '3', 'Y') },
    { AV_PIX_FMT_YUV420P14LE, MKTAG('Y', '3', 11 , 14 ) },
    { AV_PIX_FMT_YUV420P14BE, MKTAG(14 , 11 , '3', 'Y') },
    { AV_PIX_FMT_YUV422P14LE, MKTAG('Y', '3', 10 , 14 ) },
    { AV_PIX_FMT_YUV422P14BE, MKTAG(14 , 10 , '3', 'Y') },
    { AV_PIX_FMT_YUV444P14LE, MKTAG('Y', '3',  0 , 14 ) },
    { AV_PIX_FMT_YUV444P14BE, MKTAG(14 ,  0 , '3', 'Y') },
    { AV_PIX_FMT_YUV420P16LE, MKTAG('Y', '3', 11 , 16 ) },
    { AV_PIX_FMT_YUV420P16BE, MKTAG(16 , 11 , '3', 'Y') },
    { AV_PIX_FMT_YUV422P16LE, MKTAG('Y', '3', 10 , 16 ) },
    { AV_PIX_FMT_YUV422P16BE, MKTAG(16 , 10 , '3', 'Y') },
    { AV_PIX_FMT_YUV444P16LE, MKTAG('Y', '3',  0 , 16 ) },
    { AV_PIX_FMT_YUV444P16BE, MKTAG(16 ,  0 , '3', 'Y') },
    { AV_PIX_FMT_YUVA420P,    MKTAG('Y', '4', 11 ,  8 ) },
    { AV_PIX_FMT_YUVA422P,    MKTAG('Y', '4', 10 ,  8 ) },
    { AV_PIX_FMT_YUVA444P,    MKTAG('Y', '4',  0 ,  8 ) },
    { AV_PIX_FMT_YA8,         MKTAG('Y', '2',  0 ,  8 ) },

    { AV_PIX_FMT_YUVA420P9LE,  MKTAG('Y', '4', 11 ,  9 ) },
    { AV_PIX_FMT_YUVA420P9BE,  MKTAG( 9 , 11 , '4', 'Y') },
    { AV_PIX_FMT_YUVA422P9LE,  MKTAG('Y', '4', 10 ,  9 ) },
    { AV_PIX_FMT_YUVA422P9BE,  MKTAG( 9 , 10 , '4', 'Y') },
    { AV_PIX_FMT_YUVA444P9LE,  MKTAG('Y', '4',  0 ,  9 ) },
    { AV_PIX_FMT_YUVA444P9BE,  MKTAG( 9 ,  0 , '4', 'Y') },
    { AV_PIX_FMT_YUVA420P10LE, MKTAG('Y', '4', 11 , 10 ) },
    { AV_PIX_FMT_YUVA420P10BE, MKTAG(10 , 11 , '4', 'Y') },
    { AV_PIX_FMT_YUVA422P10LE, MKTAG('Y', '4', 10 , 10 ) },
    { AV_PIX_FMT_YUVA422P10BE, MKTAG(10 , 10 , '4', 'Y') },
    { AV_PIX_FMT_YUVA444P10LE, MKTAG('Y', '4',  0 , 10 ) },
    { AV_PIX_FMT_YUVA444P10BE, MKTAG(10 ,  0 , '4', 'Y') },
    { AV_PIX_FMT_YUVA420P16LE, MKTAG('Y', '4', 11 , 16 ) },
    { AV_PIX_FMT_YUVA420P16BE, MKTAG(16 , 11 , '4', 'Y') },
    { AV_PIX_FMT_YUVA422P16LE, MKTAG('Y', '4', 10 , 16 ) },
    { AV_PIX_FMT_YUVA422P16BE, MKTAG(16 , 10 , '4', 'Y') },
    { AV_PIX_FMT_YUVA444P16LE, MKTAG('Y', '4',  0 , 16 ) },
    { AV_PIX_FMT_YUVA444P16BE, MKTAG(16 ,  0 , '4', 'Y') },

    { AV_PIX_FMT_GBRP,         MKTAG('G', '3', 00 ,  8 ) },
    { AV_PIX_FMT_GBRP9LE,      MKTAG('G', '3', 00 ,  9 ) },
    { AV_PIX_FMT_GBRP9BE,      MKTAG( 9 , 00 , '3', 'G') },
    { AV_PIX_FMT_GBRP10LE,     MKTAG('G', '3', 00 , 10 ) },
    { AV_PIX_FMT_GBRP10BE,     MKTAG(10 , 00 , '3', 'G') },
    { AV_PIX_FMT_GBRP12LE,     MKTAG('G', '3', 00 , 12 ) },
    { AV_PIX_FMT_GBRP12BE,     MKTAG(12 , 00 , '3', 'G') },
    { AV_PIX_FMT_GBRP14LE,     MKTAG('G', '3', 00 , 14 ) },
    { AV_PIX_FMT_GBRP14BE,     MKTAG(14 , 00 , '3', 'G') },
    { AV_PIX_FMT_GBRP16LE,     MKTAG('G', '3', 00 , 16 ) },
    { AV_PIX_FMT_GBRP16BE,     MKTAG(16 , 00 , '3', 'G') },

    { AV_PIX_FMT_XYZ12LE,      MKTAG('X', 'Y', 'Z' , 36 ) },
    { AV_PIX_FMT_XYZ12BE,      MKTAG(36 , 'Z' , 'Y', 'X') },

    { AV_PIX_FMT_BAYER_BGGR8,    MKTAG(0xBA, 'B', 'G', 8   ) },
    { AV_PIX_FMT_BAYER_BGGR16LE, MKTAG(0xBA, 'B', 'G', 16  ) },
    { AV_PIX_FMT_BAYER_BGGR16BE, MKTAG(16  , 'G', 'B', 0xBA) },
    { AV_PIX_FMT_BAYER_RGGB8,    MKTAG(0xBA, 'R', 'G', 8   ) },
    { AV_PIX_FMT_BAYER_RGGB16LE, MKTAG(0xBA, 'R', 'G', 16  ) },
    { AV_PIX_FMT_BAYER_RGGB16BE, MKTAG(16  , 'G', 'R', 0xBA) },
    { AV_PIX_FMT_BAYER_GBRG8,    MKTAG(0xBA, 'G', 'B', 8   ) },
    { AV_PIX_FMT_BAYER_GBRG16LE, MKTAG(0xBA, 'G', 'B', 16  ) },
    { AV_PIX_FMT_BAYER_GBRG16BE, MKTAG(16,   'B', 'G', 0xBA) },
    { AV_PIX_FMT_BAYER_GRBG8,    MKTAG(0xBA, 'G', 'R', 8   ) },
    { AV_PIX_FMT_BAYER_GRBG16LE, MKTAG(0xBA, 'G', 'R', 16  ) },
    { AV_PIX_FMT_BAYER_GRBG16BE, MKTAG(16,   'R', 'G', 0xBA) },

    /* quicktime */
    { AV_PIX_FMT_YUV420P, MKTAG('R', '4', '2', '0') }, /* Radius DV YUV PAL */
    { AV_PIX_FMT_YUV411P, MKTAG('R', '4', '1', '1') }, /* Radius DV YUV NTSC */
    { AV_PIX_FMT_UYVY422, MKTAG('2', 'v', 'u', 'y') },
    { AV_PIX_FMT_UYVY422, MKTAG('2', 'V', 'u', 'y') },
    { AV_PIX_FMT_UYVY422, MKTAG('A', 'V', 'U', 'I') }, /* FIXME merge both fields */
    { AV_PIX_FMT_UYVY422, MKTAG('b', 'x', 'y', 'v') },
    { AV_PIX_FMT_YUYV422, MKTAG('y', 'u', 'v', '2') },
    { AV_PIX_FMT_YUYV422, MKTAG('y', 'u', 'v', 's') },
    { AV_PIX_FMT_YUYV422, MKTAG('D', 'V', 'O', 'O') }, /* Digital Voodoo SD 8 Bit */
    { AV_PIX_FMT_RGB555LE,MKTAG('L', '5', '5', '5') },
    { AV_PIX_FMT_RGB565LE,MKTAG('L', '5', '6', '5') },
    { AV_PIX_FMT_RGB565BE,MKTAG('B', '5', '6', '5') },
    { AV_PIX_FMT_BGR24,   MKTAG('2', '4', 'B', 'G') },
    { AV_PIX_FMT_BGR24,   MKTAG('b', 'x', 'b', 'g') },
    { AV_PIX_FMT_BGRA,    MKTAG('B', 'G', 'R', 'A') },
    { AV_PIX_FMT_RGBA,    MKTAG('R', 'G', 'B', 'A') },
    { AV_PIX_FMT_RGB24,   MKTAG('b', 'x', 'r', 'g') },
    { AV_PIX_FMT_ABGR,    MKTAG('A', 'B', 'G', 'R') },
    { AV_PIX_FMT_GRAY16BE,MKTAG('b', '1', '6', 'g') },
    { AV_PIX_FMT_RGB48BE, MKTAG('b', '4', '8', 'r') },

    /* special */
    { AV_PIX_FMT_RGB565LE,MKTAG( 3 ,  0 ,  0 ,  0 ) }, /* flipped RGB565LE */
    { AV_PIX_FMT_YUV444P, MKTAG('Y', 'V', '2', '4') }, /* YUV444P, swapped UV */

    { AV_PIX_FMT_NONE, 0 },
};
AVPixFmtDescriptor g_av_pix_fmt_descriptors[AV_PIX_FMT_NB] ;

void init_av_pix_fmt_descriptors()
{
	g_av_pix_fmt_descriptors[AV_PIX_FMT_YUV420P].name = "yuv420p";
	g_av_pix_fmt_descriptors[AV_PIX_FMT_YUV420P].nb_components = 3;
	g_av_pix_fmt_descriptors[AV_PIX_FMT_YUV420P].log2_chroma_w = 1;
	g_av_pix_fmt_descriptors[AV_PIX_FMT_YUV420P].log2_chroma_h = 1;
	//av_pix_fmt_descriptors[AV_PIX_FMT_YUV420P].comp = {{ 0, 0, 1, 0, 7 },        /* Y */{ 1, 0, 1, 0, 7 },        /* U */{ 2, 0, 1, 0, 7 },        /* V */};
	g_av_pix_fmt_descriptors[AV_PIX_FMT_YUV420P].flags = AV_PIX_FMT_FLAG_PLANAR;

	g_av_pix_fmt_descriptors[AV_PIX_FMT_YUYV422].name = "yuyv422";
	g_av_pix_fmt_descriptors[AV_PIX_FMT_YUYV422].nb_components = 3;
	g_av_pix_fmt_descriptors[AV_PIX_FMT_YUYV422].log2_chroma_w = 1;
	g_av_pix_fmt_descriptors[AV_PIX_FMT_YUYV422].log2_chroma_h = 0;
	//	 av_pix_fmt_descriptors[AV_PIX_FMT_YUYV422].comp = {{ 0, 1, 1, 0, 7 },        /* Y */{ 0, 3, 2, 0, 7 },        /* U */{ 0, 3, 4, 0, 7 },        /* V */};



	g_av_pix_fmt_descriptors[AV_PIX_FMT_YVYU422].name = "yvyu422";
	g_av_pix_fmt_descriptors[AV_PIX_FMT_YVYU422].nb_components = 3;
	g_av_pix_fmt_descriptors[AV_PIX_FMT_YVYU422].log2_chroma_w = 1;
	g_av_pix_fmt_descriptors[AV_PIX_FMT_YVYU422].log2_chroma_h = 0;
	//              av_pix_fmt_descriptors[AV_PIX_FMT_YVYU422].comp = {{ 0, 1, 1, 0, 7 },        /* Y */{ 0, 3, 2, 0, 7 },        /* V */{ 0, 3, 4, 0, 7 },        /* U */};

	g_av_pix_fmt_descriptors[AV_PIX_FMT_RGB24].name = "rgb24";
	g_av_pix_fmt_descriptors[AV_PIX_FMT_RGB24].nb_components = 3;
	g_av_pix_fmt_descriptors[AV_PIX_FMT_RGB24].log2_chroma_w = 0;
	g_av_pix_fmt_descriptors[AV_PIX_FMT_RGB24] .log2_chroma_h = 0;
	//              av_pix_fmt_descriptors[AV_PIX_FMT_RGB24].comp = {{ 0, 2, 1, 0, 7 },        /* R */{ 0, 2, 2, 0, 7 },        /* G */{ 0, 2, 3, 0, 7 },        /* B */};
	g_av_pix_fmt_descriptors[AV_PIX_FMT_RGB24].flags = AV_PIX_FMT_FLAG_RGB;







}

static char *dup_wchar_to_utf8(wchar_t *w)
{
	char *s = NULL;
	int l = WideCharToMultiByte(CP_UTF8, 0, w, -1, 0, 0, 0, 0);
	s = (char *) malloc(l *sizeof(char));
	if (s)
		WideCharToMultiByte(CP_UTF8, 0, w, -1, s, l, 0, 0);
	return s;
}
enum AVPixelFormat dshow_pixfmt( unsigned long biCompression, unsigned short biBitCount)
{
	switch(biCompression) {
	/*case BI_BITFIELDS:
	case BI_RGB:*/
	case 0L:
	case 3L:
		switch(biBitCount) { /* 1-8 are untested */
	case 1:
		return AV_PIX_FMT_MONOWHITE;
	case 4:
		return AV_PIX_FMT_RGB4;
	case 8:
		return AV_PIX_FMT_RGB8;
	case 16:
		return AV_PIX_FMT_RGB555;
	case 24:
		return AV_PIX_FMT_BGR24;
	case 32:
		return AV_PIX_FMT_0RGB32;
		}
	}
	return avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), biCompression); // all others

}
int  dshow_cycle_formats_camera( IPin *pin)
{  
	PixelInfo tmpPixelInfo = {0};
	IAMStreamConfig *config = NULL;
	int i, n, size;
	void *caps = NULL;
	 HRESULT hr = S_OK; 
	 AM_MEDIA_TYPE *type = NULL;
	if (pin->QueryInterface( IID_IAMStreamConfig, (void **) &config) != S_OK)
		return -1;
	if (config->GetNumberOfCapabilities( &n, &size) != S_OK)
		goto end;


	 caps = malloc(size);
	 if (!caps)
		 goto end;
	 for (i = 0; i < n; i++)
	 {
		 memset(&tmpPixelInfo, 0 , sizeof(PixelInfo));
		 hr= config->GetStreamCaps( i, &type, (BYTE *) caps);
		 if (hr != S_OK)
		 {
			 printf("error !!!11-1\n");
			goto next;;
		 }
		VIDEO_STREAM_CONFIG_CAPS *vcaps = (VIDEO_STREAM_CONFIG_CAPS *)caps;

		BITMAPINFOHEADER *bih;
		INT64 *fr;
		if (IsEqualGUID(type->formattype, FORMAT_VideoInfo)) {
			VIDEOINFOHEADER *v = (VIDEOINFOHEADER *) type->pbFormat;
			fr = &v->AvgTimePerFrame;
			bih = &v->bmiHeader;
		}/* else if (IsEqualGUID(&type->formattype, &FORMAT_VideoInfo2)) {
			VIDEOINFOHEADER2 *v = (void *) type->pbFormat;
			fr = &v->AvgTimePerFrame;
			bih = &v->bmiHeader;
		}*/ else {
			goto next;
		}
		enum AVPixelFormat pix_fmt = dshow_pixfmt(bih->biCompression, bih->biBitCount);
		if (pix_fmt == AV_PIX_FMT_NONE) 
		{
			 goto next;
		}
		else
		{
//			printf( "  pixel_format=%s", av_get_pix_fmt_name(pix_fmt));
			strcpy(tmpPixelInfo.formatName,av_get_pix_fmt_name(pix_fmt) );


		}

	/*	if (type->subtype == MEDIASUBTYPE_YV12 || 
			type->subtype == MEDIASUBTYPE_RGB565 || 
			type->subtype == MEDIASUBTYPE_UYVY )  */   
		{                
			           
			//printf( "index = %d, width = %d, height = %d\n",i,  vcaps->MaxOutputSize.cx,  vcaps->MaxOutputSize.cy); 
	/*		printf( "  min s=%ldx%ld fps=%g max s=%ldx%ld fps=%g\n",
				vcaps->MinOutputSize.cx, vcaps->MinOutputSize.cy,
			   1e7 / vcaps->MaxFrameInterval,
				vcaps->MaxOutputSize.cx, vcaps->MaxOutputSize.cy,
				  1e7 /vcaps->MinFrameInterval);*/
			// to correct the value;              
	

		}            
		tmpPixelInfo.caps = *vcaps;

		g_cameraInfo.nCameraInfo[g_cameraInfo.nCount].formatInfo.push_back(tmpPixelInfo);
		
next:
	 if (type->pbFormat)
		 CoTaskMemFree(type->pbFormat);
		 CoTaskMemFree(type);
	 }

end:
	 config->Release();
	 if (caps)
		 free(caps);
	 
	return 0;
}
int getCameraOtherInfo(IBaseFilter *device_filter)
{
	HRESULT hr; 
	IPin *device_pin = NULL;
	IEnumPins *pins = 0;
	hr = device_filter->EnumPins(&pins);
	if (FAILED(hr)) 
	{
		return -1;
	}
	IPin *pin;
	while (pins->Next(1, &pin, NULL) == S_OK)
	{
		IKsPropertySet *p = NULL;
		IEnumMediaTypes *types = NULL;
		PIN_INFO info = {0};
		AM_MEDIA_TYPE *type;
		GUID category;
		DWORD r2;
		pin->QueryPinInfo(&info);
		info.pFilter->Release();
		if (info.dir != PINDIR_OUTPUT)
			goto next;
		if (pin->QueryInterface( IID_IKsPropertySet, (void **) &p) != S_OK)
			goto next;
		if (p->Get( AMPROPSETID_Pin, AMPROPERTY_PIN_CATEGORY,
			NULL, 0, &category, sizeof(GUID), &r2) != S_OK)
			goto next;
		if (!IsEqualGUID(category, PIN_CATEGORY_CAPTURE))
			goto next;


		char *buf = dup_wchar_to_utf8(info.achName);

	//	printf( " Pin \"%s\"\n", buf);
		dshow_cycle_formats_camera(pin);





		free(buf);



next:

		if (p)
		{
			p->Release();
		}
		if (device_pin != pin)
		{
			pin->Release();
		}

	}
	pins->Release();



}
const struct PixelFormatTag *avpriv_get_raw_pix_fmt_tags(void)
{
	return ff_raw_pix_fmt_tags;
}
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags,
									   unsigned int fourcc)
{
	while (tags->pix_fmt >= 0) {
		if (tags->fourcc == fourcc)
			return tags->pix_fmt;
		tags++;
	}
	return AV_PIX_FMT_NONE;
}


 

int get_all_CameraInfo (void )
{
	HRESULT hr;  
	IGraphBuilder *m_pGraphBuilder;  
	int i =0;
	//Create the filter graph   
	if (FAILED(CoInitialize(NULL)))    //初始化COM库
	{  

		return -1;  
	} 
	hr = CoCreateInstance(CLSID_FilterGraph,NULL,CLSCTX_INPROC_SERVER,  
		IID_IGraphBuilder,(LPVOID*)&m_pGraphBuilder);   /*建立滤镜管理器*/
	if (FAILED(hr))
	{
		return -1;
	}

	ICreateDevEnum *pDevEnum;  
	hr = CoCreateInstance(CLSID_SystemDeviceEnum,NULL,CLSCTX_INPROC_SERVER,  
		IID_ICreateDevEnum,(LPVOID*)&pDevEnum); /*创建枚举器组件*/
	if (FAILED(hr)) 
	{
		return -1;
	}

	IEnumMoniker *classenum = NULL;

	const GUID *device_guid[1] = { &CLSID_VideoInputDeviceCategory};
	int r;

	hr = pDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,&classenum, 0);   /*指定某一类型设备*/
	if (hr == S_FALSE)  
	{  
		hr = VFW_E_NOT_FOUND;  
		return hr;  
	}  


	classenum->Reset();  
	unsigned long cFetched;  
	IMoniker *m = NULL;
	//	清空全局变量
	g_cameraInfo.nCount =0;
	for(int j =0 ;j< MAX_CAMERAS_NUM; j++)
	{

		vector <PixelInfo>().swap(g_cameraInfo.nCameraInfo[j].formatInfo);
		memset(g_cameraInfo.nCameraInfo[j].cameraName, 0,strlen(g_cameraInfo.nCameraInfo[j].cameraName));


	}

	i = 0;
	while (hr=classenum->Next(1,&m,&cFetched),hr == S_OK)
	{
		IPropertyBag *bag = NULL;
		char *buf = NULL;
		VARIANT var;

		hr = m->BindToStorage(0,0,IID_IPropertyBag,(LPVOID*)&bag); //获取设备名字 

		if (FAILED(hr)) 
			goto fail1;

		var.vt = VT_BSTR;
		hr = bag->Read(L"FriendlyName",&var,NULL);  //检索过滤器的友好名字
		if (FAILED(hr)) 
			goto fail1;

		buf = dup_wchar_to_utf8(var.bstrVal);

	//	printf( " \"%s\"\n", buf);
		g_cameraInfo.nCount = i;
		strcpy(g_cameraInfo.nCameraInfo[i].cameraName, buf);

fail1:
		if (buf)
			free(buf);
		if (bag)

			bag->Release(); 


		IBaseFilter *device_filter = NULL;

		m->BindToObject( 0, 0, IID_IBaseFilter,  (LPVOID*)&device_filter); //生成绑定到设备的filter


		if (NULL != device_filter)
		{
			getCameraOtherInfo(device_filter);
		}
		i++;

	}
	
	g_cameraInfo.nCount = i;
	classenum->Release();
	pDevEnum->Release();
	m_pGraphBuilder->Release();
	CoUninitialize();

	return 0;
}





CameraInfoForUsb *getCameraInfoForUsb()
{

	static int nflag=1;

	if (nflag)
	{
		get_all_CameraInfo ();
		nflag =0;
	}
	return &g_cameraInfo;
}

void show_CamerInfo()
{
	
	CameraInfoForUsb *pCameraInfo = getCameraInfoForUsb();
	if (pCameraInfo->nCount == 0)
	{
		printf("there no camera connect pc\n");
		return ;
	}

	printf("there is %d cameras connect pc\n", pCameraInfo->nCount );


	for (int i =0; i < pCameraInfo->nCount; i++)
	{

		printf( " \"%s\"\n", pCameraInfo->nCameraInfo[i].cameraName);
		for (int j =0; j <pCameraInfo->nCameraInfo[i].formatInfo.size(); j++)
		{
			printf( "  pixel_format=%s", pCameraInfo->nCameraInfo[i].formatInfo[j].formatName);

			printf( "  min s=%ldx%ld fps=%g max s=%ldx%ld fps=%g\n",
				pCameraInfo->nCameraInfo[i].formatInfo[j].caps.MinOutputSize.cx,pCameraInfo->nCameraInfo[i].formatInfo[j].caps.MinOutputSize.cy,
				1e7 / pCameraInfo->nCameraInfo[i].formatInfo[j].caps.MaxFrameInterval,
				pCameraInfo->nCameraInfo[i].formatInfo[j].caps.MaxOutputSize.cx, pCameraInfo->nCameraInfo[i].formatInfo[j].caps.MaxOutputSize.cy,
				1e7 /pCameraInfo->nCameraInfo[i].formatInfo[j].caps.MinFrameInterval);
		}

	}

	

}

int getCameraDevNum ()
{

	CameraInfoForUsb *pCameraInfo = getCameraInfoForUsb();
	return pCameraInfo->nCount;
}


char * getCameraNameByIndex(int nIndex)
{
	CameraInfoForUsb *pCameraInfo = getCameraInfoForUsb();
	

	return pCameraInfo->nCameraInfo[nIndex-1].cameraName;

}
<span style="font-family:Arial;BACKGROUND-COLOR: #ffffff"></span>

 


CameraInfoDef.h

#ifndef getCameraInfo_h_
#define getCameraInfo_h_

#include <vector>


extern  "C"
{

#include "libavformat/avformat.h"
#include "libavutil/pixdesc.h"

#include "SDL.h"
};

#include "DShow.h"

using namespace std;

#define  MAX_CAMERAS_NUM 16

typedef struct PixelFormatTag {
	enum AVPixelFormat pix_fmt;
	unsigned int fourcc;
} PixelFormatTag;


typedef struct 
{
	char formatName[32];
	VIDEO_STREAM_CONFIG_CAPS caps;
}PixelInfo;
typedef struct 
{
	char cameraName[64];
	vector <PixelInfo> formatInfo;
}cameraInfo;


typedef struct  
{
	int nCount;
	cameraInfo nCameraInfo[MAX_CAMERAS_NUM];
}CameraInfoForUsb;


CameraInfoForUsb *getCameraInfoForUsb();

#endif
　

 


main.cpp

　
int main(int argc, char *argv[])
{
	char devName[64];
	int nIndex =0;
	strcpy(devName, "video=");
	init_av_pix_fmt_descriptors();
	show_CamerInfo();
	int nDevCnt = getCameraDevNum();
	if (nDevCnt == 0)
	{
		printf("error : no camera device\n");

		return -1;
	}
	if (nDevCnt == 1)
	{
		printf("there is only one camera connect pc \n");
	}
	else
	{
		printf("please in put the num camera you choose and must <= %d\n", nDevCnt);

	}
	scanf("%d", &nIndex);

	if (nIndex<=0 || nIndex > nDevCnt)
	{
		printf("error : what you put is invalid\n");

		return -1;
	}

	strcat(devName, getCameraNameByIndex(nIndex));



	 
	return 0;
}


　 
xiongy789
关注
专栏目录
FFmpeg入门详解之114：DirectShow读取摄像头数据
福优学苑@音视频+流媒体
11-02 1628
DirectShow GraphEdit(graphedt.exe)来进行分析：在上图中可以直观的看到播放这个媒体文件的基本模块，七个模块按广度顺序：读文件模块， 解复用模块， 视频解码模块， 音频解码音频， 颜色空间转换模块，视频显示模块，音频播放模块。按照DirectShow的称呼， 一个模块叫做一个filter(过滤器)，模块的输入输出口叫做pin（管脚）， 有input pin 和output pin两种；
opecv2.3+directshow操作多个摄像头配置
genganpeng的专栏
05-09 2533
1、  下载地directshow，http://download.csdn.net/download/yangalbert/4184472 2、  到opencv中文官网下载，http://www.opencv.org.cn/index.php/使用DirectShow采集图像其中的下载代码和例程 3、  配置opencv2.3 1 下载安装VS2010、OpenCV2.3，并解压缩Ope
用VB6实现的基于directshow.net的摄像头拍摄实例
01-28
这个东西我也找得蛮辛苦的.所以,给我一些积分奖励我一下吧.网络上是很难找到用vb实现directshownet的,当然你可以去找一些收费的控件,不过比较便宜的也要收你几百块钱人民币吧.而且,还学不到什么东西.
DirectShow过滤器开发-NV12解压缩过滤器
h3974的博客
06-22 381
介绍NV12解压缩过滤器的开发。
获取摄像头个数和名字
qqwangfan的专栏
04-10 4403
使用qt的QCameraInfo::availableCameras()一直获取到的摄像头个数都是0(本机上共有5个摄像头)，使用qt自带的例子获取摄像头列表又获取得到，不知哪里出了问题。无奈只能网上查找。以下使用directshow获取摄像头个数和摄像头名字：里面的代码可下载来使用，只是里面有个包含的头文件#include 必须工程包含opencv的目录才能打开，否则编译不通过。但是单单获取摄像
VC 打开摄像头 (使用DirectShow)
08-27
通过使用MFC中的CImage和DirectShow来打开摄像头，预览并保存图像。 代码不再维护。 通过使用MFC中的CImage和DirectShow来打开摄像头，预览并保存图像。 代码不再维护。
C#.NET使用DirectShowLib进行摄像头捕捉示例 VS2012
06-08
C#.NET使用DirectShowLib进行摄像头捕捉示例 VS2012下开发带DirectShowLib库
PC摄像头枚举器源代码
04-25
基于DictShow,可以枚举PC上所有摄像头的名称，支持的所有颜色空间，以及每种颜色空间所支持的分辨率。VC6工程。
QT+vs+directshow获取摄像头名称及其支持的分辨率
06-20
在实现“QT+VS+DirectShow获取摄像头名称及其支持的分辨率”时，你需要： 1. **集成QT与DirectShow**：首先，你需要在Visual Studio 2013中配置QT支持，这通常通过安装QT插件（如Qt VS Tools）完成。然后，为了使用...
win10下在VS2015采用Qt+DirectShow打开多个USB摄像头并录制视频
05-10
在Windows10的系统中，采用VS2015的开发环境，用Qt+DirectShow库实现了打开多个USB摄像头，把采集到的视频用Qt显示出来，并用DirectShow库实现了视频录制并保存； 并实现了每隔30s保存一个视频；方便视频的存储；...
directshow摄像头视频捕捉
05-17
源过滤器负责从设备（如摄像头）获取数据，转换过滤器用于处理数据（如编码、解码），而渲染过滤器则将数据展示到屏幕上或保存到文件中。 1. **创建DirectShow项目** 在VS2010中，选择“新建项目”，然后在MFC类别...
opencv摄像机名称及id获取，以及串口名称获取
07-05
c++，得到opencv打开摄像头id号及名称
Opencv3获取电脑上多个摄像头的名称和编号
07-07
这是一个通过C++获取电脑上连接的多个摄像头的名称和编号，方便opencv开发的时候直接通过摄像头编号获取对应摄像头的数据，也方便直播开发获取摄像头名称。
directshow 预览摄像头
01-13
`video_capture` 类是一个实现这一功能的关键，它提供了获取摄像头名称并进行预览的接口。 首先，我们要了解DirectShow的工作原理。DirectShow通过构建一种图形数据流模型（GraphBuilder）来处理媒体流，这个模型由...
DirectShow过滤器开发-NV12压缩过滤器
最新发布
h3974的博客
06-24 239
介绍NV12压缩过滤器的开发。
FFmpeg视频解码中的YUV420P格式
热门推荐
老王的技术博客
05-30 2万+
参考文章 在做基于FFmpeg解码的视频播放时，需要涉及到帧数据存储的YUV与RGB格式，所以了解了一下，参考下述博文。 https://blog.csdn.net/lanxiaziyi/article/details/74139729#avframe-%E4%B8%8E-yuv420%E9%82%A3%E4%BA%9B%E4%BA%8B 发展史 视网膜存在三种视锥细胞，分别含有对红...
ffmpeg中的像素格式是如何存储的(AVPixFmtDescriptor)
靑い空゛
06-19 1818
ffmpeg中的像素格式是如何存储的 ffmpeg的像素存储方式描述主要定义在了pexdesc.h中,下面看看这个结构体. /** * Descriptor that unambiguously describes how the bits of a pixel are * stored in the up to 4 data planes of an image. It also stores the * subsampling factors and number of components.
Onvif协议客户端开发（7）--获取前端摄像头的名称
数据迷宫
10-04 1万+
获取前端摄像头的名称 一、介绍 摄像头的名称可能是标注摄像头位置，因此获取摄像头的名称对于对接前端摄像头是一个必须的流程。 在此作者通过Onvif协议获取前端摄像头OSD的信息获取到前端摄像头的名称，这种办法可能存在一些问题：比如如果前端摄像头有设置名称但是没有显示在界面，那通过Onvif协议获取的摄像头名称就会失败。或许还有其他问题，暂时还没遇到。如果有其他途径获取前端摄像头名称，方便的话知会一...
Windows下用DirectShow查找摄像头（含分辨率）和麦克风
架构和代码
08-07 7691
在视频聊天、视频会议、在线监控和视频展台等项目中，需要查找出本地电脑上连接的所有摄像头，网上流传比较多的方式是ffmpeg的方式，这种方式可以跨平台，不同的平台下调用不同的库。这种方式在控制台直接打印了摄像头的信息，无法（或者说我暂时没找到）在内存中获取，因此直接采用了DirectShow的方式，DirectShow枚举IMoniker和Ipin。因为网上的文档，不是特别详尽，所以...
directshow控制uvc摄像头
07-14
通过使用 DirectShow 提供的功能，我们能够打开摄像头设备，显示实时视频流，捕获图像，并控制摄像头的参数和属性。 ### 回答3： DirectShow是一个用于视频和音频捕获、处理和播放的多媒体框架。UVC（USB Video ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值