static int compare_fourcc(DWORD fcc1, DWORD fcc2)
{
char fcc_str1[4];
char fcc_str2[4];
fourcc_to_string(fcc_str1, fcc1);
fourcc_to_string(fcc_str2, fcc2);
return strncasecmp(fcc_str1, fcc_str2, 4);
}
static inline const char *wine_dbgstr_fcc( DWORD fcc )
{
char fcc_str[5];
fourcc_to_string(fcc_str, fcc);
fcc_str[4] = '\0';
/* Last byte may be ' ' in some cases like "DIB " */
if (isalnum(fcc_str[0]) && isalnum(fcc_str[1]) && isalnum(fcc_str[2])
&& (isalnum(fcc_str[3]) || isspace(fcc_str[3])))
return wine_dbg_sprintf("%s", fcc_str);
return wine_dbg_sprintf("0x%08x", fcc);
}
void err_cb (const riff_chunkv_t * chunk_path_ptr, FILE * f, uint64_t position, riff_result_t err, void * cookie) {
riff_chunk_t cur;
char buf[5];
int i;
for(i=0;i<VEC_SIZE(*chunk_path_ptr);i++) {
cur = VEC_GET(*chunk_path_ptr, i);
fourcc_to_string(cur.fourcc, buf);
printf("%s:", buf);
}
cur = VEC_TOP(*chunk_path_ptr);
printf(" %" PRIu64 " - %" PRIu64 "\n", cur.pos_head, cur.pos_end);
}
riff_cbresult_t chunk_cb (const riff_chunkv_t * chunk_path_ptr, FILE * f, uint64_t position, void * cookie) {
riff_chunk_t cur;
char buf[5];
int i;
cur = VEC_TOP(*chunk_path_ptr);
fourcc_to_string(cur.fourcc, buf);
assert(cur.pos_content == position);
for(i=0; i<VEC_SIZE(skipv); i++) {
if(VEC_GET(skipv, i) == VEC_TOP(*chunk_path_ptr).fourcc) {
printf("Skipping: %s\n", buf);
return RIFF_SKIP_CHUNK;
}
}
for(i=0; i<VEC_SIZE(stopv); i++) {
if(VEC_GET(stopv, i) == VEC_TOP(*chunk_path_ptr).fourcc) {
printf("Stoping: %s\n", buf);
return RIFF_STOP;
}
}
for(i=0; i<VEC_SIZE(readv); i++) {
if(VEC_GET(readv, i) == VEC_TOP(*chunk_path_ptr).fourcc) {
printf("Reading: %s\n", buf);
for(; position < cur.pos_end; position++) {
fgetc(f);
}
return RIFF_CHUNK_READ;
}
}
for(i=0;i<VEC_SIZE(*chunk_path_ptr);i++) {
cur = VEC_GET(*chunk_path_ptr, i);
fourcc_to_string(cur.fourcc, buf);
printf("%s:", buf);
}
cur = VEC_TOP(*chunk_path_ptr);
printf(" %" PRIu64 " - %" PRIu64 "\n", cur.pos_head, cur.pos_end);
return RIFF_CONTINUE; /* go print subchunks */
}
int My_Video_Device::init(const char* device_name)
{
string device = device_name; /* "/dev/video0"; */
Video_Capture dev;
try
{
dev.init ( device );
}
catch( std::exception& e )
{
cerr << e.what() << endl;
return -1;
}
// dump supported formats/sizes/fps
vector< v4l2_fmtdesc > fmts = dev.get_formats();
My_Device_Info info;
for( size_t i = 0; i < fmts.size(); ++i )
{
const v4l2_fmtdesc& fmt = fmts[i];
info.pixelformat = fourcc_to_string(fmt.pixelformat);
if( fmt.flags & V4L2_FMT_FLAG_COMPRESSED )
info._flag = 'C';
if( fmt.flags & V4L2_FMT_FLAG_EMULATED )
info._flag = 'E';
else
info._flag = 'N';
vector< v4l2_frmsizeenum > sizes = dev.get_sizes( fmt );
for( size_t j = 0; j < sizes.size(); ++j )
{
const v4l2_frmsizeenum& size = sizes[j];
info._width = size.discrete.width;
info._height = size.discrete.height;
vector< v4l2_frmivalenum > intervals = dev.get_intervals( fmt, size );
for( size_t k = 0; k < intervals.size(); ++k )
{
const v4l2_frmivalenum& interval = intervals[k];
info._fps = interval.discrete.denominator;
_my_device_info.push_back(info);
}
}
}
return 0;
}
static BOOL enum_drivers(DWORD fccType, enum_handler_t handler, void* param)
{
CHAR buf[2048], fccTypeStr[5], *s;
DWORD i, cnt = 0, lRet;
BOOL result = FALSE;
HKEY hKey;
fourcc_to_string(fccTypeStr, fccType);
fccTypeStr[4] = '.';
/* first, go through the registry entries */
lRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE, HKLM_DRIVERS32, 0, KEY_QUERY_VALUE, &hKey);
if (lRet == ERROR_SUCCESS)
{
DWORD name, data, type;
i = 0;
for (;;)
{
name = 10;
data = sizeof buf - name;
lRet = RegEnumValueA(hKey, i++, buf, &name, 0, &type, (LPBYTE)(buf+name), &data);
if (lRet == ERROR_NO_MORE_ITEMS) break;
if (lRet != ERROR_SUCCESS) continue;
if (name != 9 || strncasecmp(buf, fccTypeStr, 5)) continue;
buf[name] = '=';
if ((result = handler(buf, cnt++, param))) break;
}
RegCloseKey( hKey );
}
if (result) return result;
/* if that didn't work, go through the values in system.ini */
if (GetPrivateProfileSectionA("drivers32", buf, sizeof(buf), "system.ini"))
{
for (s = buf; *s; s += strlen(s) + 1)
{
TRACE("got %s\n", s);
if (strncasecmp(s, fccTypeStr, 5) || s[9] != '=') continue;
if ((result = handler(s, cnt++, param))) break;
}
}
return result;
}
static BOOL enum_drivers(DWORD fccType, enum_handler_t handler, void* param)
{
char fccTypeStr[4];
char name_buf[10];
char buf[2048];
DWORD i, cnt = 0, lRet;
BOOL result = FALSE;
HKEY hKey;
fourcc_to_string(fccTypeStr, fccType);
/* first, go through the registry entries */
lRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE, HKLM_DRIVERS32, 0, KEY_QUERY_VALUE, &hKey);
if (lRet == ERROR_SUCCESS)
{
i = 0;
for (;;)
{
DWORD name_len = 10, driver_len = 128;
lRet = RegEnumValueA(hKey, i++, name_buf, &name_len, 0, 0, (BYTE *)buf, &driver_len);
if (lRet == ERROR_NO_MORE_ITEMS) break;
if (name_len != 9 || name_buf[4] != '.') continue;
if (fccType && strncasecmp(name_buf, fccTypeStr, 4)) continue;
if ((result = handler(name_buf, buf, cnt++, param))) break;
}
RegCloseKey( hKey );
}
if (result) return result;
/* if that didn't work, go through the values in system.ini */
if (GetPrivateProfileSectionA("drivers32", buf, sizeof(buf), "system.ini"))
{
char *s;
for (s = buf; *s; s += strlen(s) + 1)
{
if (s[4] != '.' || s[9] != '=') continue;
if (fccType && strncasecmp(s, fccTypeStr, 4)) continue;
if ((result = handler(s, s + 10, cnt++, param))) break;
}
}
return result;
}
/***********************************************************************
* ICOpen [MSVFW32.@]
* Opens an installable compressor. Return special handle.
*/
HIC VFWAPI ICOpen(DWORD fccType, DWORD fccHandler, UINT wMode)
{
WCHAR codecname[10];
ICOPEN icopen;
HDRVR hdrv;
WINE_HIC* whic;
static const WCHAR drv32W[] = {'d','r','i','v','e','r','s','3','2','\0'};
reg_driver* driver;
TRACE("(%s,%s,0x%08x)\n", wine_dbgstr_fcc(fccType), wine_dbgstr_fcc(fccHandler), wMode);
/* Check if there is a registered driver that matches */
driver = reg_driver_list;
while(driver)
if (!compare_fourcc(fccType, driver->fccType) &&
!compare_fourcc(fccHandler, driver->fccHandler))
break;
else
driver = driver->next;
if (driver && driver->proc)
/* The driver has been registered at runtime with its driverproc */
return ICOpenFunction(fccType, fccHandler, wMode, driver->proc);
/* Well, lParam2 is in fact a LPVIDEO_OPEN_PARMS, but it has the
* same layout as ICOPEN
*/
icopen.dwSize = sizeof(ICOPEN);
icopen.fccType = fccType;
icopen.fccHandler = fccHandler;
icopen.dwVersion = 0x00001000; /* FIXME */
icopen.dwFlags = wMode;
icopen.dwError = 0;
icopen.pV1Reserved = NULL;
icopen.pV2Reserved = NULL;
icopen.dnDevNode = 0; /* FIXME */
if (!driver) {
/* The driver is registered in the registry */
fourcc_to_string(codecname, fccType);
codecname[4] = '.';
fourcc_to_string(codecname + 5, fccHandler);
codecname[9] = '\0';
hdrv = OpenDriver(codecname, drv32W, (LPARAM)&icopen);
if (!hdrv)
return 0;
} else {
/* The driver has been registered at runtime with its name */
hdrv = OpenDriver(driver->name, NULL, (LPARAM)&icopen);
if (!hdrv)
return 0;
}
whic = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_HIC));
if (!whic)
{
CloseDriver(hdrv, 0, 0);
return FALSE;
}
whic->hdrv = hdrv;
whic->driverproc = NULL;
whic->type = fccType;
whic->handler = fccHandler;
while (MSVIDEO_GetHicPtr((HIC)(ULONG_PTR)IC_HandleRef) != NULL) IC_HandleRef++;
whic->hic = (HIC)(ULONG_PTR)IC_HandleRef++;
whic->next = MSVIDEO_FirstHic;
MSVIDEO_FirstHic = whic;
TRACE("=> %p\n", whic->hic);
return whic->hic;
}
/***********************************************************************
* ICOpen [MSVFW32.@]
* Opens an installable compressor. Return special handle.
*/
HIC VFWAPI ICOpen(DWORD fccType, DWORD fccHandler, UINT wMode)
{
WCHAR codecname[10];
ICOPEN icopen;
HDRVR hdrv;
WINE_HIC* whic;
static const WCHAR drv32W[] = {'d','r','i','v','e','r','s','3','2','\0'};
reg_driver* driver;
TRACE("(%s,%s,0x%08x)\n", wine_dbgstr_fcc(fccType), wine_dbgstr_fcc(fccHandler), wMode);
if (!fccHandler) /* No specific handler, return the first valid for wMode */
{
HIC local;
ICINFO info;
DWORD loop = 0;
info.dwSize = sizeof(info);
while(ICInfo(fccType, loop++, &info))
{
/* Ensure fccHandler is not 0x0 because we will recurse on ICOpen */
if(!info.fccHandler)
continue;
local = ICOpen(fccType, info.fccHandler, wMode);
if (local != 0)
{
TRACE("Returning %s as default handler for %s\n",
wine_dbgstr_fcc(info.fccHandler), wine_dbgstr_fcc(fccType));
return local;
}
}
}
/* Check if there is a registered driver that matches */
driver = reg_driver_list;
while(driver)
if (!compare_fourcc(fccType, driver->fccType) &&
!compare_fourcc(fccHandler, driver->fccHandler)) {
fccType = driver->fccType;
fccHandler = driver->fccHandler;
break;
} else
driver = driver->next;
if (driver && driver->proc)
/* The driver has been registered at runtime with its driverproc */
return ICOpenFunction(fccType, fccHandler, wMode, driver->proc);
/* Well, lParam2 is in fact a LPVIDEO_OPEN_PARMS, but it has the
* same layout as ICOPEN
*/
icopen.dwSize = sizeof(ICOPEN);
icopen.fccType = fccType;
icopen.fccHandler = fccHandler;
icopen.dwVersion = 0x00001000; /* FIXME */
icopen.dwFlags = wMode;
icopen.dwError = 0;
icopen.pV1Reserved = NULL;
icopen.pV2Reserved = NULL;
icopen.dnDevNode = 0; /* FIXME */
if (!driver) {
/* normalize to lower case as in 'vidc' */
((char*)&fccType)[0] = tolower(((char*)&fccType)[0]);
((char*)&fccType)[1] = tolower(((char*)&fccType)[1]);
((char*)&fccType)[2] = tolower(((char*)&fccType)[2]);
((char*)&fccType)[3] = tolower(((char*)&fccType)[3]);
icopen.fccType = fccType;
/* Seek the driver in the registry */
fourcc_to_string(codecname, fccType);
codecname[4] = '.';
fourcc_to_string(codecname + 5, fccHandler);
codecname[9] = '\0';
hdrv = OpenDriver(codecname, drv32W, (LPARAM)&icopen);
if (!hdrv)
return 0;
} else {
/* The driver has been registered at runtime with its name */
hdrv = OpenDriver(driver->name, NULL, (LPARAM)&icopen);
if (!hdrv)
return 0;
}
whic = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_HIC));
if (!whic)
{
CloseDriver(hdrv, 0, 0);
return FALSE;
}
whic->hdrv = hdrv;
whic->driverproc = NULL;
whic->type = fccType;
whic->handler = fccHandler;
while (MSVIDEO_GetHicPtr((HIC)(ULONG_PTR)IC_HandleRef) != NULL) IC_HandleRef++;
whic->hic = (HIC)(ULONG_PTR)IC_HandleRef++;
whic->next = MSVIDEO_FirstHic;
MSVIDEO_FirstHic = whic;
TRACE("=> %p\n", whic->hic);
return whic->hic;
}