March 2020 - Wine-Devel - list.winehq.org

[PATCH] mshtml: Use stricmp() instead of _strnicmp(..., -1).
by Paul Gofman March 27, 2020

March 27, 2020

Signed-off-by: Paul Gofman <gofmanp(a)gmail.com> --- dlls/mshtml/nsio.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/mshtml/nsio.c b/dlls/mshtml/nsio.c index 0201ab5c47..7c8f029b4a 100644 --- a/dlls/mshtml/nsio.c +++ b/dlls/mshtml/nsio.c @@ -1180,7 +1180,7 @@ static nsresult NSAPI nsChannel_SetRequestMethod(nsIHttpChannel *iface, nsACString_GetData(aRequestMethod, &method); for(i=0; i < ARRAY_SIZE(request_method_strings); i++) { - if(!_strnicmp(method, request_method_strings[i], -1)) { + if(!stricmp(method, request_method_strings[i])) { This->request_method = i; return NS_OK; } -- 2.25.1

2 1

[PATCH] msvcp90: Add std:_XLgamma implementation.
by Piotr Caban March 27, 2020

March 27, 2020

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=48806 Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msvcp100/msvcp100.spec | 6 +++--- dlls/msvcp110/msvcp110.spec | 6 +++--- dlls/msvcp120/msvcp120.spec | 6 +++--- dlls/msvcp120_app/msvcp120_app.spec | 6 +++--- dlls/msvcp140/msvcp140.spec | 6 +++--- dlls/msvcp90/math.c | 33 +++++++++++++++++++++++++++++ dlls/msvcp90/msvcp90.spec | 6 +++--- 7 files changed, 51 insertions(+), 18 deletions(-)

1 0

[PATCH v3 1/6] mountmgr: Determine and store the filesystem type, label, and serial.
by Zebediah Figura March 27, 2020

March 27, 2020

Copied with minimal adaptation from kernel32/volume.c Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- v3: fix test failures... I *think* this is the best approach to implementing FileFsVolumeInformation and FileFsAttributeInformation, but given the (necessarily) different nature of Wine to Windows and the difficulty of using host libraries from ntdll directly, I'm not as confident as I might otherwise be. Part of the goal here is to reimplement is_same_file() using Win32 API functions. My original idea was to use FileIdInformation, which seems quite similar: we return a volume and file ID pair. However, to do that, we need to return the volume's actual serial number [1]. mountmgr *seems* like the right place to store this information, from a purely semantic sense. It does mean we have to add more fields to an internal ioctl, but given aed088df11 I'm led to believe this is nevertheless the preferred approach. Moreover, storing this information in mountmgr means we have the ability to derive the serial or label from disk management libraries (udisks2, Disk Arbitration, etc.) in the case that we can't calculate it ourselves (e.g. for an ext4 host partition). Note that for the proposed implementation of is_same_file() to work, we need a different serial number to be returned for each Unix drive—including those that aren't mapped to a DOS device. This necessitates patch 3/6, or something similar. On the other hand, since we treat volumes like C: as separate volumes, i.e. ordinary directories linked as DOS devices, we need to be able to identify the correct volume by path, hence find_dos_device() in patch 4/6. The other way I can think of to do this is to centralize the logic in ntdll (i.e. move it from kernel32), and forgo relying on mountmgr. The problem with this is that we need to retrieve the Unix device file from the file, which as far as I can tell is not really possible without relying on some complex platform-specific trickery. Alternatively, we could ask mountmgr for the Unix device and then do the calculations in ntdll. It's not clear to me that's any worse than the current approach, except that we lose the ability to derive the label or serial from disk management libraries. The code in kernel32 is not particularly pretty, but I figured it was a better use of my time not to obsessively clean it up... This series does not actually include the code that assigns a default serial, but my plan is to derive it from the UUID in the case that we don't have a true 4-byte serial. I'm not sure of the best way to do this, though, so suggestions are welcome... [1] https://www.winehq.org/pipermail/wine-devel/2020-March/161123.html dlls/mountmgr.sys/device.c | 598 +++++++++++++++++++++++++++++++++++++ 1 file changed, 598 insertions(+) diff --git a/dlls/mountmgr.sys/device.c b/dlls/mountmgr.sys/device.c index 0ca2d42517a..1459386f06c 100644 --- a/dlls/mountmgr.sys/device.c +++ b/dlls/mountmgr.sys/device.c @@ -71,6 +71,16 @@ static const WCHAR target_id_keyW[] = {'T','a','r','g','e','t',' ','I','d',' ',' static const WCHAR lun_keyW[] = {'L','o','g','i','c','a','l',' ','U','n','i','t',' ','I','d',' ','%','d',0}; static const WCHAR devnameW[] = {'D','e','v','i','c','e','N','a','m','e',0}; +enum fs_type +{ + FS_ERROR, /* error accessing the device */ + FS_UNKNOWN, /* unknown file system */ + FS_FAT1216, + FS_FAT32, + FS_ISO9660, + FS_UDF /* For reference [E] = Ecma-167.pdf, [U] = udf260.pdf */ +}; + struct disk_device { enum device_type type; /* drive type */ @@ -90,6 +100,9 @@ struct volume unsigned int ref; /* ref count */ GUID guid; /* volume uuid */ struct mount_point *mount; /* Volume{xxx} mount point */ + WCHAR label[256]; /* volume label */ + DWORD serial; /* volume serial number */ + enum fs_type fs_type; /* file system type */ }; struct dos_drive @@ -204,6 +217,510 @@ static void send_notify( int drive, int code ) WM_DEVICECHANGE, code, (LPARAM)&info ); } +#define BLOCK_SIZE 2048 +#define SUPERBLOCK_SIZE BLOCK_SIZE + +#define CDFRAMES_PERSEC 75 +#define CDFRAMES_PERMIN (CDFRAMES_PERSEC * 60) +#define FRAME_OF_ADDR(a) ((a)[1] * CDFRAMES_PERMIN + (a)[2] * CDFRAMES_PERSEC + (a)[3]) +#define FRAME_OF_TOC(toc, idx) FRAME_OF_ADDR((toc)->TrackData[(idx) - (toc)->FirstTrack].Address) + +#define GETWORD(buf,off) MAKEWORD(buf[(off)],buf[(off+1)]) +#define GETLONG(buf,off) MAKELONG(GETWORD(buf,off),GETWORD(buf,off+2)) + +static int open_volume_file( const struct volume *volume, const char *file ) +{ + const char *unix_mount = volume->device->unix_mount; + char *path; + int fd; + + if (!unix_mount) return -1; + + if (unix_mount[0] == '/') + { + if (!(path = HeapAlloc( GetProcessHeap(), 0, strlen( unix_mount ) + 1 + strlen( file ) + 1 ))) + return -1; + + strcpy( path, unix_mount ); + } + else + { + const char *config_dir = wine_get_config_dir(); + + if (!(path = HeapAlloc( GetProcessHeap(), 0, strlen( config_dir ) + + strlen("/dosdevices/") + strlen(unix_mount) + 1 + strlen( file ) + 1 ))) + return -1; + + strcpy( path, config_dir ); + strcat( path, "/dosdevices/" ); + strcat( path, unix_mount ); + } + strcat( path, "/" ); + strcat( path, file ); + + fd = open( path, O_RDONLY ); + HeapFree( GetProcessHeap(), 0, path ); + return fd; +} + +/* get the label by reading it from a file at the root of the filesystem */ +static void get_filesystem_label( struct volume *volume ) +{ + int fd; + ssize_t size; + char buffer[256], *p; + + volume->label[0] = 0; + + if ((fd = open_volume_file( volume, ".windows-label" )) == -1) + return; + size = read( fd, buffer, sizeof(buffer) ); + close( fd ); + + p = buffer + size; + while (p > buffer && (p[-1] == ' ' || p[-1] == '\r' || p[-1] == '\n')) p--; + *p = 0; + if (!MultiByteToWideChar( CP_UNIXCP, 0, buffer, -1, volume->label, ARRAY_SIZE(volume->label) )) + volume->label[ARRAY_SIZE(volume->label) - 1] = 0; +} + +/* get the serial number by reading it from a file at the root of the filesystem */ +static void get_filesystem_serial( struct volume *volume ) +{ + int fd; + ssize_t size; + char buffer[32]; + + volume->serial = 0; + + if ((fd = open_volume_file( volume, ".windows-serial" )) == -1) + return; + size = read( fd, buffer, sizeof(buffer) ); + close( fd ); + + if (size < 0) return; + buffer[size] = 0; + volume->serial = strtoul( buffer, NULL, 16 ); +} + + +/****************************************************************** + * VOLUME_FindCdRomDataBestVoldesc + */ +static DWORD VOLUME_FindCdRomDataBestVoldesc( HANDLE handle ) +{ + BYTE cur_vd_type, max_vd_type = 0; + BYTE buffer[0x800]; + DWORD size, offs, best_offs = 0, extra_offs = 0; + + for (offs = 0x8000; offs <= 0x9800; offs += 0x800) + { + /* if 'CDROM' occurs at position 8, this is a pre-iso9660 cd, and + * the volume label is displaced forward by 8 + */ + if (SetFilePointer( handle, offs, NULL, FILE_BEGIN ) != offs) break; + if (!ReadFile( handle, buffer, sizeof(buffer), &size, NULL )) break; + if (size != sizeof(buffer)) break; + /* check for non-ISO9660 signature */ + if (!memcmp( buffer + 11, "ROM", 3 )) extra_offs = 8; + cur_vd_type = buffer[extra_offs]; + if (cur_vd_type == 0xff) /* voldesc set terminator */ + break; + if (cur_vd_type > max_vd_type) + { + max_vd_type = cur_vd_type; + best_offs = offs + extra_offs; + } + } + return best_offs; +} + + +/*********************************************************************** + * VOLUME_ReadFATSuperblock + */ +static enum fs_type VOLUME_ReadFATSuperblock( HANDLE handle, BYTE *buff ) +{ + DWORD size; + + /* try a fixed disk, with a FAT partition */ + if (SetFilePointer( handle, 0, NULL, FILE_BEGIN ) != 0 || + !ReadFile( handle, buff, SUPERBLOCK_SIZE, &size, NULL )) + { + if (GetLastError() == ERROR_BAD_DEV_TYPE) return FS_UNKNOWN; /* not a real device */ + return FS_ERROR; + } + + if (size < SUPERBLOCK_SIZE) return FS_UNKNOWN; + + /* FIXME: do really all FAT have their name beginning with + * "FAT" ? (At least FAT12, FAT16 and FAT32 have :) + */ + if (!memcmp(buff+0x36, "FAT", 3) || !memcmp(buff+0x52, "FAT", 3)) + { + /* guess which type of FAT we have */ + int reasonable; + unsigned int sectors, + sect_per_fat, + total_sectors, + num_boot_sectors, + num_fats, + num_root_dir_ents, + bytes_per_sector, + sectors_per_cluster, + nclust; + sect_per_fat = GETWORD(buff, 0x16); + if (!sect_per_fat) sect_per_fat = GETLONG(buff, 0x24); + total_sectors = GETWORD(buff, 0x13); + if (!total_sectors) + total_sectors = GETLONG(buff, 0x20); + num_boot_sectors = GETWORD(buff, 0x0e); + num_fats = buff[0x10]; + num_root_dir_ents = GETWORD(buff, 0x11); + bytes_per_sector = GETWORD(buff, 0x0b); + sectors_per_cluster = buff[0x0d]; + /* check if the parameters are reasonable and will not cause + * arithmetic errors in the calculation */ + reasonable = num_boot_sectors < total_sectors && + num_fats < 16 && + bytes_per_sector >= 512 && bytes_per_sector % 512 == 0 && + sectors_per_cluster >= 1; + if (!reasonable) return FS_UNKNOWN; + sectors = total_sectors - num_boot_sectors - num_fats * sect_per_fat - + (num_root_dir_ents * 32 + bytes_per_sector - 1) / bytes_per_sector; + nclust = sectors / sectors_per_cluster; + if ((buff[0x42] == 0x28 || buff[0x42] == 0x29) && + !memcmp(buff+0x52, "FAT", 3)) return FS_FAT32; + if (nclust < 65525) + { + if ((buff[0x26] == 0x28 || buff[0x26] == 0x29) && + !memcmp(buff+0x36, "FAT", 3)) + return FS_FAT1216; + } + } + return FS_UNKNOWN; +} + + +/*********************************************************************** + * VOLUME_ReadCDBlock + */ +static BOOL VOLUME_ReadCDBlock( HANDLE handle, BYTE *buff, INT offs ) +{ + DWORD size, whence = offs >= 0 ? FILE_BEGIN : FILE_END; + + if (SetFilePointer( handle, offs, NULL, whence ) != offs || + !ReadFile( handle, buff, SUPERBLOCK_SIZE, &size, NULL ) || + size != SUPERBLOCK_SIZE) + return FALSE; + + return TRUE; +} + + +/*********************************************************************** + * VOLUME_ReadCDSuperblock + */ +static enum fs_type VOLUME_ReadCDSuperblock( HANDLE handle, BYTE *buff ) +{ + int i; + DWORD offs; + + /* Check UDF first as UDF and ISO9660 structures can coexist on the same medium + * Starting from sector 16, we may find : + * - a CD-ROM Volume Descriptor Set (ISO9660) containing one or more Volume Descriptors + * - an Extended Area (UDF) -- [E] 2/8.3.1 and [U] 2.1.7 + * There is no explicit end so read 16 sectors and then give up */ + for( i=16; i<16+16; i++) + { + if (!VOLUME_ReadCDBlock(handle, buff, i*BLOCK_SIZE)) + continue; + + /* We are supposed to check "BEA01", "NSR0x" and "TEA01" IDs + verify tag checksum + * but we assume the volume is well-formatted */ + if (!memcmp(&buff[1], "BEA01", 5)) return FS_UDF; + } + + offs = VOLUME_FindCdRomDataBestVoldesc( handle ); + if (!offs) return FS_UNKNOWN; + + if (!VOLUME_ReadCDBlock(handle, buff, offs)) + return FS_ERROR; + + /* check for the iso9660 identifier */ + if (!memcmp(&buff[1], "CD001", 5)) return FS_ISO9660; + return FS_UNKNOWN; +} + + +/************************************************************************** + * UDF_Find_PVD + * Find the Primary Volume Descriptor + */ +static BOOL UDF_Find_PVD( HANDLE handle, BYTE pvd[] ) +{ + unsigned int i; + DWORD offset; + INT locations[] = { 256, -1, -257, 512 }; + + for(i=0; i<ARRAY_SIZE(locations); i++) + { + if (!VOLUME_ReadCDBlock(handle, pvd, locations[i]*BLOCK_SIZE)) + return FALSE; + + /* Tag Identifier of Anchor Volume Descriptor Pointer is 2 -- [E] 3/10.2.1 */ + if (pvd[0]==2 && pvd[1]==0) + { + /* Tag location (Uint32) at offset 12, little-endian */ + offset = pvd[20 + 0]; + offset |= pvd[20 + 1] << 8; + offset |= pvd[20 + 2] << 16; + offset |= pvd[20 + 3] << 24; + offset *= BLOCK_SIZE; + + if (!VOLUME_ReadCDBlock(handle, pvd, offset)) + return FALSE; + + /* Check for the Primary Volume Descriptor Tag Id -- [E] 3/10.1.1 */ + if (pvd[0]!=1 || pvd[1]!=0) + return FALSE; + + /* 8 or 16 bits per character -- [U] 2.1.1 */ + if (!(pvd[24]==8 || pvd[24]==16)) + return FALSE; + + return TRUE; + } + } + + return FALSE; +} + + +/************************************************************************** + * VOLUME_GetSuperblockLabel + */ +static void VOLUME_GetSuperblockLabel( struct volume *volume, HANDLE handle, const BYTE *superblock ) +{ + const BYTE *label_ptr = NULL; + DWORD label_len; + + switch (volume->fs_type) + { + case FS_ERROR: + label_len = 0; + break; + case FS_UNKNOWN: + get_filesystem_label( volume ); + return; + case FS_FAT1216: + label_ptr = superblock + 0x2b; + label_len = 11; + break; + case FS_FAT32: + label_ptr = superblock + 0x47; + label_len = 11; + break; + case FS_ISO9660: + { + BYTE ver = superblock[0x5a]; + + if (superblock[0x58] == 0x25 && superblock[0x59] == 0x2f && /* Unicode ID */ + ((ver == 0x40) || (ver == 0x43) || (ver == 0x45))) + { /* yippee, unicode */ + unsigned int i; + + for (i = 0; i < 16; i++) + volume->label[i] = (superblock[40+2*i] << 8) | superblock[41+2*i]; + volume->label[i] = 0; + while (i && volume->label[i-1] == ' ') volume->label[--i] = 0; + return; + } + label_ptr = superblock + 40; + label_len = 32; + break; + } + case FS_UDF: + { + BYTE pvd[BLOCK_SIZE]; + + if(!UDF_Find_PVD(handle, pvd)) + { + label_len = 0; + break; + } + + /* [E] 3/10.1.4 and [U] 2.1.1 */ + if(pvd[24]==8) + { + label_ptr = pvd + 24 + 1; + label_len = pvd[24+32-1]; + break; + } + else + { + unsigned int i; + + label_len = 1 + pvd[24+32-1]; + for (i = 0; i < label_len; i += 2) + volume->label[i/2] = (pvd[24+1+i] << 8) | pvd[24+1+i+1]; + volume->label[label_len] = 0; + return; + } + } + } + if (label_len) RtlMultiByteToUnicodeN( volume->label, sizeof(volume->label) - sizeof(WCHAR), + &label_len, (const char *)label_ptr, label_len ); + label_len /= sizeof(WCHAR); + volume->label[label_len] = 0; + while (label_len && volume->label[label_len-1] == ' ') volume->label[--label_len] = 0; +} + + +/************************************************************************** + * UDF_Find_FSD_Sector + * Find the File Set Descriptor used to compute the serial of a UDF volume + */ +static int UDF_Find_FSD_Sector( HANDLE handle, BYTE block[] ) +{ + int i, PVD_sector, PD_sector, PD_length; + + if(!UDF_Find_PVD(handle,block)) + goto default_sector; + + /* Retrieve the tag location of the PVD -- [E] 3/7.2 */ + PVD_sector = block[12 + 0]; + PVD_sector |= block[12 + 1] << 8; + PVD_sector |= block[12 + 2] << 16; + PVD_sector |= block[12 + 3] << 24; + + /* Find the Partition Descriptor */ + for(i=PVD_sector+1; ; i++) + { + if(!VOLUME_ReadCDBlock(handle, block, i*BLOCK_SIZE)) + goto default_sector; + + /* Partition Descriptor Tag Id -- [E] 3/10.5.1 */ + if(block[0]==5 && block[1]==0) + break; + + /* Terminating Descriptor Tag Id -- [E] 3/10.9.1 */ + if(block[0]==8 && block[1]==0) + goto default_sector; + } + + /* Find the partition starting location -- [E] 3/10.5.8 */ + PD_sector = block[188 + 0]; + PD_sector |= block[188 + 1] << 8; + PD_sector |= block[188 + 2] << 16; + PD_sector |= block[188 + 3] << 24; + + /* Find the partition length -- [E] 3/10.5.9 */ + PD_length = block[192 + 0]; + PD_length |= block[192 + 1] << 8; + PD_length |= block[192 + 2] << 16; + PD_length |= block[192 + 3] << 24; + + for(i=PD_sector; i<PD_sector+PD_length; i++) + { + if(!VOLUME_ReadCDBlock(handle, block, i*BLOCK_SIZE)) + goto default_sector; + + /* File Set Descriptor Tag Id -- [E] 3/14.1.1 */ + if(block[0]==0 && block[1]==1) + return i; + } + +default_sector: + WARN("FSD sector not found, serial may be incorrect\n"); + return 257; +} + + +/************************************************************************** + * VOLUME_GetSuperblockSerial + */ +static void VOLUME_GetSuperblockSerial( struct volume *volume, HANDLE handle, const BYTE *superblock ) +{ + int FSD_sector; + BYTE block[BLOCK_SIZE]; + + switch (volume->fs_type) + { + case FS_ERROR: + break; + case FS_UNKNOWN: + get_filesystem_serial( volume ); + break; + case FS_FAT1216: + volume->serial = GETLONG( superblock, 0x27 ); + break; + case FS_FAT32: + volume->serial = GETLONG( superblock, 0x43 ); + break; + case FS_UDF: + FSD_sector = UDF_Find_FSD_Sector(handle, block); + if (!VOLUME_ReadCDBlock(handle, block, FSD_sector*BLOCK_SIZE)) + break; + superblock = block; + /* fallthrough */ + case FS_ISO9660: + { + BYTE sum[4]; + int i; + + sum[0] = sum[1] = sum[2] = sum[3] = 0; + for (i = 0; i < 2048; i += 4) + { + /* DON'T optimize this into DWORD !! (breaks overflow) */ + sum[0] += superblock[i+0]; + sum[1] += superblock[i+1]; + sum[2] += superblock[i+2]; + sum[3] += superblock[i+3]; + } + /* + * OK, another braindead one... argh. Just believe it. + * Me$$ysoft chose to reverse the serial number in NT4/W2K. + * It's true and nobody will ever be able to change it. + */ + if ((GetVersion() & 0x80000000) || volume->fs_type == FS_UDF) + volume->serial = (sum[3] << 24) | (sum[2] << 16) | (sum[1] << 8) | sum[0]; + else + volume->serial = (sum[0] << 24) | (sum[1] << 16) | (sum[2] << 8) | sum[3]; + } + } +} + + +/************************************************************************** + * VOLUME_GetAudioCDSerial + */ +static DWORD VOLUME_GetAudioCDSerial( const CDROM_TOC *toc ) +{ + DWORD serial = 0; + int i; + + for (i = 0; i <= toc->LastTrack - toc->FirstTrack; i++) + serial += ((toc->TrackData[i].Address[1] << 16) | + (toc->TrackData[i].Address[2] << 8) | + toc->TrackData[i].Address[3]); + + /* + * dwStart, dwEnd collect the beginning and end of the disc respectively, in + * frames. + * There it is collected for correcting the serial when there are less than + * 3 tracks. + */ + if (toc->LastTrack - toc->FirstTrack + 1 < 3) + { + DWORD dwStart = FRAME_OF_TOC(toc, toc->FirstTrack); + DWORD dwEnd = FRAME_OF_TOC(toc, toc->LastTrack + 1); + serial += dwEnd - dwStart; + } + return serial; +} + + /* create the disk device for a given volume */ static NTSTATUS create_disk_device( enum device_type type, struct disk_device **device_ret ) { @@ -473,6 +990,72 @@ static struct volume *find_matching_volume( const char *udi, const char *device, return NULL; } +static BOOL get_volume_device_info( struct volume *volume ) +{ + const char *unix_device = volume->device->unix_device; + ANSI_STRING unix_name; + UNICODE_STRING nt_name; + OBJECT_ATTRIBUTES attr; + HANDLE handle; + NTSTATUS ret; + CDROM_TOC toc; + DWORD size; + BYTE superblock[SUPERBLOCK_SIZE]; + IO_STATUS_BLOCK io; + + if (!unix_device) + return FALSE; + + RtlInitAnsiString( &unix_name, unix_device ); + if ((ret = wine_unix_to_nt_file_name( &unix_name, &nt_name ))) + { + ERR("Failed to convert %s to NT, status %#x\n", debugstr_a(unix_device), ret); + return FALSE; + } + + InitializeObjectAttributes( &attr, &nt_name, OBJ_CASE_INSENSITIVE, 0, NULL ); + if ((ret = NtOpenFile( &handle, GENERIC_READ | SYNCHRONIZE, &attr, &io, FILE_SHARE_READ | FILE_SHARE_WRITE, + FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT ))) + { + WARN("Failed to open %s, status %#x\n", debugstr_a(unix_device), ret); + RtlFreeUnicodeString( &nt_name ); + return FALSE; + } + + if (DeviceIoControl( handle, IOCTL_CDROM_READ_TOC, NULL, 0, &toc, sizeof(toc), &size, 0 )) + { + if (!(toc.TrackData[0].Control & 0x04)) /* audio track */ + { + static const WCHAR audiocdW[] = {'A','u','d','i','o',' ','C','D',0}; + TRACE( "%s: found audio CD\n", debugstr_a(unix_device) ); + lstrcpynW( volume->label, audiocdW, ARRAY_SIZE(volume->label) ); + volume->serial = VOLUME_GetAudioCDSerial( &toc ); + volume->fs_type = FS_ISO9660; + CloseHandle( handle ); + return TRUE; + } + volume->fs_type = VOLUME_ReadCDSuperblock( handle, superblock ); + } + else + { + volume->fs_type = VOLUME_ReadFATSuperblock( handle, superblock ); + if (volume->fs_type == FS_UNKNOWN) volume->fs_type = VOLUME_ReadCDSuperblock( handle, superblock ); + } + + TRACE( "%s: found fs type %d\n", debugstr_a(unix_device), volume->fs_type ); + if (volume->fs_type == FS_ERROR) + { + CloseHandle( handle ); + return FALSE; + } + + VOLUME_GetSuperblockLabel( volume, handle, superblock ); + VOLUME_GetSuperblockSerial( volume, handle, superblock ); + + CloseHandle( handle ); + return TRUE; +} + /* change the information for an existing volume */ static NTSTATUS set_volume_info( struct volume *volume, struct dos_drive *drive, const char *device, const char *mount_point, enum device_type type, const GUID *guid ) @@ -506,6 +1089,21 @@ static NTSTATUS set_volume_info( struct volume *volume, struct dos_drive *drive, disk_device->unix_device = strdupA( device ); disk_device->unix_mount = strdupA( mount_point ); + if (!get_volume_device_info( volume )) + { + if (volume->device->type == DEVICE_CDROM) + volume->fs_type = FS_ISO9660; + else if (volume->device->type == DEVICE_DVD) + volume->fs_type = FS_UDF; + else + volume->fs_type = FS_UNKNOWN; + + get_filesystem_label( volume ); + get_filesystem_serial( volume ); + } + + TRACE("fs_type %#x, label %s, serial %08x\n", volume->fs_type, debugstr_w(volume->label), volume->serial); + if (guid && memcmp( &volume->guid, guid, sizeof(volume->guid) )) { volume->guid = *guid; -- 2.25.1

1 5

[PATCH] ddraw: Reserve extra space for video memory surfaces in compatibility mode.
by Paul Gofman March 27, 2020

March 27, 2020

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=48788 Some old apps write surface data past the end of locked space. That used to work on early ddraw hardware as locked surface provided direct access to video memory mapped to CPU address space and such access could often go without issues. Currently ddraw on Windows allocates bigger buffers for video memory surfaces when 8 or 16 bit display mode is requested. Signed-off-by: Paul Gofman <gofmanp(a)gmail.com> --- dlls/ddraw/ddraw_private.h | 2 ++ dlls/ddraw/surface.c | 60 ++++++++++++++++++++++++++++++++++++-- 2 files changed, 59 insertions(+), 3 deletions(-) diff --git a/dlls/ddraw/ddraw_private.h b/dlls/ddraw/ddraw_private.h index f4fe970a61..83e3ee10c0 100644 --- a/dlls/ddraw/ddraw_private.h +++ b/dlls/ddraw/ddraw_private.h @@ -219,6 +219,8 @@ struct ddraw_texture struct ddraw_surface *root; struct wined3d_device *wined3d_device; + + void *texture_memory; }; HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_desc, diff --git a/dlls/ddraw/surface.c b/dlls/ddraw/surface.c index 9850a1e8c9..f48a9a467b 100644 --- a/dlls/ddraw/surface.c +++ b/dlls/ddraw/surface.c @@ -5832,8 +5832,11 @@ static const struct wined3d_parent_ops ddraw_surface_wined3d_parent_ops = static void STDMETHODCALLTYPE ddraw_texture_wined3d_object_destroyed(void *parent) { - TRACE("parent %p.\n", parent); + struct ddraw_texture *texture = parent; + TRACE("texture %p, texture_memory %p.\n", texture, texture->texture_memory); + + heap_free(texture->texture_memory); heap_free(parent); } @@ -5847,18 +5850,50 @@ static HRESULT CDECL ddraw_reset_enum_callback(struct wined3d_resource *resource return DD_OK; } +static HRESULT ddraw_surface_reserve_memory(struct wined3d_texture *wined3d_texture) +{ + static const unsigned int extra_size = 0x10000; + + struct ddraw_texture *texture = wined3d_texture_get_parent(wined3d_texture); + struct wined3d_resource_desc desc; + unsigned int pitch, slice_pitch; + HRESULT hr; + + wined3d_resource_get_desc(wined3d_texture_get_resource(wined3d_texture), &desc); + if (!(texture->texture_memory = heap_alloc_zero(desc.size + extra_size))) + { + ERR("Out of memory.\n"); + return E_OUTOFMEMORY; + } + TRACE("texture->texture_memory %p.\n", texture->texture_memory); + + wined3d_texture_get_pitch(wined3d_texture, 0, &pitch, &slice_pitch); + + if (FAILED(hr = wined3d_texture_update_desc(wined3d_texture, + desc.width, desc.height, desc.format, + WINED3D_MULTISAMPLE_NONE, 0, texture->texture_memory, pitch))) + { + heap_free(texture->texture_memory); + texture->texture_memory = NULL; + } + + return hr; +} + HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_desc, struct ddraw_surface **surface, IUnknown *outer_unknown, unsigned int version) { struct wined3d_sub_resource_desc wined3d_mip_desc; struct ddraw_surface *root, *mip, **attach; struct wined3d_resource_desc wined3d_desc; + DDPIXELFORMAT wined3d_display_mode_format; struct wined3d_texture *wined3d_texture; struct wined3d_display_mode mode; DDSURFACEDESC2 *desc, *mip_desc; struct ddraw_texture *texture; unsigned int layers = 1; unsigned int pitch = 0; + BOOL reserve_memory; UINT levels, i, j; HRESULT hr; @@ -5879,6 +5914,7 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_ if (!(texture = heap_alloc(sizeof(*texture)))) return E_OUTOFMEMORY; + texture->texture_memory = NULL; texture->version = version; texture->surface_desc = *surface_desc; desc = &texture->surface_desc; @@ -6020,12 +6056,14 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_ return hr_ddraw_from_wined3d(hr); } + wined3d_display_mode_format.dwSize = sizeof(wined3d_display_mode_format); + ddrawformat_from_wined3dformat(&wined3d_display_mode_format, mode.format_id); + /* No pixelformat given? Use the current screen format. */ if (!(desc->dwFlags & DDSD_PIXELFORMAT)) { desc->dwFlags |= DDSD_PIXELFORMAT; - desc->u4.ddpfPixelFormat.dwSize = sizeof(desc->u4.ddpfPixelFormat); - ddrawformat_from_wined3dformat(&desc->u4.ddpfPixelFormat, mode.format_id); + desc->u4.ddpfPixelFormat = wined3d_display_mode_format; } wined3d_desc.resource_type = WINED3D_RTYPE_TEXTURE_2D; @@ -6434,6 +6472,16 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_ goto fail; } + reserve_memory = !(desc->dwFlags & DDSD_LPSURFACE) + && desc->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY + && wined3d_display_mode_format.u1.dwRGBBitCount <= 16; + + if (reserve_memory && FAILED(hr = ddraw_surface_reserve_memory(wined3d_texture))) + { + ERR("Failed to reserve surface memory, hr %#x.\n", hr); + goto fail; + } + if (desc->dwFlags & DDSD_BACKBUFFERCOUNT) { unsigned int count = desc->u5.dwBackBufferCount; @@ -6487,6 +6535,12 @@ HRESULT ddraw_surface_create(struct ddraw *ddraw, const DDSURFACEDESC2 *surface_ wined3d_texture_set_color_key(wined3d_texture, DDCKEY_SRCBLT, (struct wined3d_color_key *)&desc->ddckCKSrcBlt); + if (reserve_memory && FAILED(hr = ddraw_surface_reserve_memory(wined3d_texture))) + { + hr = hr_ddraw_from_wined3d(hr); + goto fail; + } + *attach = last; attach = &last->complex_array[0]; } -- 2.25.1

1 0

[PATCH 4/4] webservices: Support WS_CHARSET_UTF16LE for buffer input.
by Hans Leidekker March 27, 2020

March 27, 2020

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/webservices/reader.c | 85 +++++++++++++++++++++++---------- dlls/webservices/tests/reader.c | 2 +- 2 files changed, 61 insertions(+), 26 deletions(-) diff --git a/dlls/webservices/reader.c b/dlls/webservices/reader.c index 0d0e7d09f0..ffa789fb6e 100644 --- a/dlls/webservices/reader.c +++ b/dlls/webservices/reader.c @@ -395,7 +395,7 @@ struct reader WS_READ_CALLBACK input_cb; void *input_cb_state; struct xmlbuf *input_buf; - const unsigned char *input_data; + unsigned char *input_conv; ULONG input_size; ULONG text_conv_offset; unsigned char *stream_buf; @@ -519,6 +519,7 @@ static void free_reader( struct reader *reader ) clear_prefixes( reader->prefixes, reader->nb_prefixes ); heap_free( reader->prefixes ); heap_free( reader->stream_buf ); + heap_free( reader->input_conv ); reader->cs.DebugInfo->Spare[0] = 0; DeleteCriticalSection( &reader->cs ); @@ -6893,18 +6894,40 @@ static WS_CHARSET detect_charset( const unsigned char *data, ULONG size, ULONG * return ret; } -static void set_input_buffer( struct reader *reader, const unsigned char *data, ULONG size ) +static HRESULT utf16le_to_utf8( const unsigned char *data, ULONG size, unsigned char **buf, ULONG *buflen ) +{ + if (size % sizeof(WCHAR)) return E_INVALIDARG; + *buflen = WideCharToMultiByte( CP_UTF8, 0, (const WCHAR *)data, size / sizeof(WCHAR), NULL, 0, NULL, NULL ); + if (!(*buf = heap_alloc( *buflen ))) return E_OUTOFMEMORY; + WideCharToMultiByte( CP_UTF8, 0, (const WCHAR *)data, size / sizeof(WCHAR), (char *)*buf, *buflen, NULL, NULL ); + return S_OK; +} + +static HRESULT set_input_buffer( struct reader *reader, const unsigned char *data, ULONG size ) { reader->input_type = WS_XML_READER_INPUT_TYPE_BUFFER; reader->input_buf = NULL; - reader->input_data = data; - reader->input_size = size; - reader->read_size = reader->input_size; - reader->read_pos = 0; - reader->read_bufptr = reader->input_data; + if (reader->input_enc == WS_XML_READER_ENCODING_TYPE_TEXT && reader->input_charset == WS_CHARSET_UTF16LE) + { + unsigned char *buf; + ULONG buflen; + HRESULT hr; + + if ((hr = utf16le_to_utf8( data, size, &buf, &buflen )) != S_OK) return hr; + heap_free( reader->input_conv ); + reader->read_bufptr = reader->input_conv = buf; + reader->read_size = reader->input_size = buflen; + } + else + { + reader->read_bufptr = data; + reader->read_size = reader->input_size = size; + } + reader->read_pos = 0; reader->text_conv_offset = 0; + return S_OK; } static void set_input_stream( struct reader *reader, WS_READ_CALLBACK callback, void *state ) @@ -6913,7 +6936,6 @@ static void set_input_stream( struct reader *reader, WS_READ_CALLBACK callback, reader->input_cb = callback; reader->input_cb_state = state; reader->input_buf = NULL; - reader->input_data = reader->stream_buf; reader->input_size = STREAM_BUFSIZE; if (reader->read_pos >= reader->read_size) reader->read_size = 0; @@ -6922,9 +6944,8 @@ static void set_input_stream( struct reader *reader, WS_READ_CALLBACK callback, memmove( reader->stream_buf, reader->stream_buf + reader->read_pos, reader->read_size - reader->read_pos ); reader->read_size -= reader->read_pos; } - reader->read_pos = 0; - reader->read_bufptr = reader->input_data; - + reader->read_pos = 0; + reader->read_bufptr = reader->stream_buf; reader->text_conv_offset = 0; } @@ -6997,7 +7018,8 @@ HRESULT WINAPI WsSetInput( WS_XML_READER *handle, const WS_XML_READER_ENCODING * case WS_XML_READER_INPUT_TYPE_BUFFER: { const WS_XML_READER_BUFFER_INPUT *buf = (const WS_XML_READER_BUFFER_INPUT *)input; - set_input_buffer( reader, (const unsigned char *)buf->encodedData + offset, buf->encodedDataSize - offset ); + hr = set_input_buffer( reader, (const unsigned char *)buf->encodedData + offset, buf->encodedDataSize - offset ); + if (hr != S_OK) goto done; break; } case WS_XML_READER_INPUT_TYPE_STREAM: @@ -7026,22 +7048,35 @@ done: return hr; } -static void set_input_xml_buffer( struct reader *reader, struct xmlbuf *buf ) +static HRESULT set_input_xml_buffer( struct reader *reader, struct xmlbuf *xmlbuf ) { reader->input_type = WS_XML_READER_INPUT_TYPE_BUFFER; - reader->input_buf = buf; - reader->input_enc = buf->encoding; - reader->input_charset = buf->charset; - reader->input_data = buf->bytes.bytes; - reader->input_size = buf->bytes.length; - reader->dict_static = buf->dict_static; - reader->dict = buf->dict; - - reader->read_size = reader->input_size; - reader->read_pos = 0; - reader->read_bufptr = reader->input_data; + reader->input_buf = xmlbuf; + reader->input_enc = xmlbuf->encoding; + reader->input_charset = xmlbuf->charset; + reader->dict_static = xmlbuf->dict_static; + reader->dict = xmlbuf->dict; + + if (reader->input_enc == WS_XML_READER_ENCODING_TYPE_TEXT && reader->input_charset == WS_CHARSET_UTF16LE) + { + unsigned char *buf; + ULONG buflen; + HRESULT hr; + if ((hr = utf16le_to_utf8( xmlbuf->bytes.bytes, xmlbuf->bytes.length, &buf, &buflen )) != S_OK) return hr; + heap_free( reader->input_conv ); + reader->read_bufptr = reader->input_conv = buf; + reader->read_size = reader->input_size = buflen; + } + else + { + reader->read_bufptr = xmlbuf->bytes.bytes; + reader->read_size = reader->input_size = xmlbuf->bytes.length; + } + + reader->read_pos = 0; reader->text_conv_offset = 0; + return S_OK; } /************************************************************************** @@ -7078,7 +7113,7 @@ HRESULT WINAPI WsSetInputToBuffer( WS_XML_READER *handle, WS_XML_BUFFER *buffer, } if ((hr = init_reader( reader )) != S_OK) goto done; - set_input_xml_buffer( reader, xmlbuf ); + if ((hr = set_input_xml_buffer( reader, xmlbuf )) != S_OK) goto done; if (!(node = alloc_node( WS_XML_NODE_TYPE_BOF ))) hr = E_OUTOFMEMORY; else read_insert_bof( reader, node ); diff --git a/dlls/webservices/tests/reader.c b/dlls/webservices/tests/reader.c index 4b9b589d8d..7d56ebccd5 100644 --- a/dlls/webservices/tests/reader.c +++ b/dlls/webservices/tests/reader.c @@ -524,7 +524,7 @@ static void test_WsSetInput(void) found = -1; hr = WsReadToStartElement( reader, NULL, NULL, &found, NULL ); - todo_wine ok( hr == S_OK, "got %08x\n", hr ); + ok( hr == S_OK, "got %08x\n", hr ); if (hr == S_OK) { ok( found == TRUE, "got %d\n", found ); -- 2.20.1

1 0

[PATCH 3/4] webservices: Implement WS_TYPE_ATTRIBUTE_FIELD_MAPPING for the reader.
by Hans Leidekker March 27, 2020

March 27, 2020

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/webservices/reader.c | 45 +++++++++++++++++++----- dlls/webservices/tests/reader.c | 62 +++++++++++++++++++++++++++++++++ 2 files changed, 99 insertions(+), 8 deletions(-) diff --git a/dlls/webservices/reader.c b/dlls/webservices/reader.c index 4d37a38a8a..0d0e7d09f0 100644 --- a/dlls/webservices/reader.c +++ b/dlls/webservices/reader.c @@ -5968,6 +5968,29 @@ static HRESULT read_type_qname( struct reader *reader, WS_TYPE_MAPPING mapping, return S_OK; } +static HRESULT read_type_description( struct reader *reader, WS_TYPE_MAPPING mapping, + const WS_XML_STRING *localname, const WS_XML_STRING *ns, + const WS_STRUCT_DESCRIPTION *desc, WS_READ_OPTION option, + WS_HEAP *heap, void *ret, ULONG size, BOOL *found ) +{ + switch (option) + { + case WS_READ_REQUIRED_POINTER: + case WS_READ_OPTIONAL_POINTER: + { + if (size != sizeof(desc)) return E_INVALIDARG; + *(const WS_STRUCT_DESCRIPTION **)ret = desc; + *found = TRUE; + break; + } + default: + FIXME( "read option %u not supported\n", option ); + return E_NOTIMPL; + } + + return S_OK; +} + static BOOL is_empty_text_node( const struct node *node ) { const WS_XML_TEXT_NODE *text = (const WS_XML_TEXT_NODE *)node; @@ -6165,7 +6188,8 @@ static WS_READ_OPTION get_field_read_option( WS_TYPE type, ULONG options ) } } -static HRESULT read_type_field( struct reader *, const WS_FIELD_DESCRIPTION *, WS_HEAP *, char *, ULONG ); +static HRESULT read_type_field( struct reader *, const WS_STRUCT_DESCRIPTION *, const WS_FIELD_DESCRIPTION *, + WS_HEAP *, char *, ULONG ); static HRESULT read_type_union( struct reader *reader, const WS_UNION_DESCRIPTION *desc, WS_HEAP *heap, void *ret, ULONG size, BOOL *found ) @@ -6193,7 +6217,7 @@ static HRESULT read_type_union( struct reader *reader, const WS_UNION_DESCRIPTIO else { ULONG offset = desc->fields[i]->field.offset; - if ((hr = read_type_field( reader, &desc->fields[i]->field, heap, ret, offset )) != S_OK) return hr; + if ((hr = read_type_field( reader, NULL, &desc->fields[i]->field, heap, ret, offset )) != S_OK) return hr; *(int *)((char *)ret + desc->enumOffset) = desc->fields[i]->value; } @@ -6297,8 +6321,8 @@ static HRESULT read_type_text( struct reader *reader, const WS_FIELD_DESCRIPTION return hr; } -static HRESULT read_type_field( struct reader *reader, const WS_FIELD_DESCRIPTION *desc, WS_HEAP *heap, char *buf, - ULONG offset ) +static HRESULT read_type_field( struct reader *reader, const WS_STRUCT_DESCRIPTION *desc_struct, + const WS_FIELD_DESCRIPTION *desc, WS_HEAP *heap, char *buf, ULONG offset ) { char *ptr; WS_READ_OPTION option; @@ -6323,8 +6347,9 @@ static HRESULT read_type_field( struct reader *reader, const WS_FIELD_DESCRIPTIO switch (desc->mapping) { case WS_TYPE_ATTRIBUTE_FIELD_MAPPING: - FIXME( "WS_TYPE_ATTRIBUTE_FIELD_MAPPING not supported\n" ); - return S_OK; + hr = read_type( reader, WS_ATTRIBUTE_TYPE_MAPPING, desc->type, desc->localName, desc->ns, + desc_struct, option, heap, ptr, size, &found ); + break; case WS_ATTRIBUTE_FIELD_MAPPING: hr = read_type( reader, WS_ATTRIBUTE_TYPE_MAPPING, desc->type, desc->localName, desc->ns, @@ -6424,7 +6449,7 @@ static HRESULT read_type_struct( struct reader *reader, WS_TYPE_MAPPING mapping, for (i = 0; i < desc->fieldCount; i++) { offset = desc->fields[i]->offset; - if ((hr = read_type_field( reader, desc->fields[i], heap, buf, offset )) != S_OK) break; + if ((hr = read_type_field( reader, desc, desc->fields[i], heap, buf, offset )) != S_OK) break; } switch (option) @@ -6651,6 +6676,10 @@ static HRESULT read_type( struct reader *reader, WS_TYPE_MAPPING mapping, WS_TYP hr = read_type_qname( reader, mapping, localname, ns, desc, option, heap, value, size, found ); break; + case WS_DESCRIPTION_TYPE: + hr = read_type_description( reader, mapping, localname, ns, desc, option, heap, value, size, found ); + break; + case WS_STRUCT_TYPE: hr = read_type_struct( reader, mapping, localname, ns, desc, option, heap, value, size, found ); break; @@ -7419,7 +7448,7 @@ static ULONG get_field_size( const WS_FIELD_DESCRIPTION *desc ) static HRESULT read_param( struct reader *reader, const WS_FIELD_DESCRIPTION *desc, WS_HEAP *heap, void *ret ) { if (!ret && !(ret = ws_alloc_zero( heap, get_field_size(desc) ))) return WS_E_QUOTA_EXCEEDED; - return read_type_field( reader, desc, heap, ret, 0 ); + return read_type_field( reader, NULL, desc, heap, ret, 0 ); } static HRESULT read_param_array( struct reader *reader, const WS_FIELD_DESCRIPTION *desc, WS_HEAP *heap, diff --git a/dlls/webservices/tests/reader.c b/dlls/webservices/tests/reader.c index 733ebe3eb1..4b9b589d8d 100644 --- a/dlls/webservices/tests/reader.c +++ b/dlls/webservices/tests/reader.c @@ -6841,6 +6841,67 @@ static void test_stream_input(void) WsFreeReader( reader ); } +static void test_description_type(void) +{ + static WS_XML_STRING ns = {0, NULL}, ns2 = {2, (BYTE *)"ns"}, localname = {1, (BYTE *)"t"}; + static WS_XML_STRING val = {3, (BYTE *)"val"}; + HRESULT hr; + WS_XML_READER *reader; + WS_HEAP *heap; + WS_FIELD_DESCRIPTION f, f2, *fields[2]; + WS_STRUCT_DESCRIPTION s; + struct test + { + const WS_STRUCT_DESCRIPTION *desc; + INT32 val; + } *test; + + hr = WsCreateHeap( 1 << 16, 0, NULL, 0, &heap, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + + hr = WsCreateReader( NULL, 0, &reader, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + + memset( &f, 0, sizeof(f) ); + f.mapping = WS_TYPE_ATTRIBUTE_FIELD_MAPPING; + f.type = WS_DESCRIPTION_TYPE; + fields[0] = &f; + + memset( &f2, 0, sizeof(f2) ); + f2.mapping = WS_ATTRIBUTE_FIELD_MAPPING; + f2.localName = &val; + f2.ns = &ns; + f2.offset = FIELD_OFFSET(struct test, val); + f2.type = WS_INT32_TYPE; + fields[1] = &f2; + + memset( &s, 0, sizeof(s) ); + s.size = sizeof(struct test); + s.alignment = TYPE_ALIGNMENT(struct test); + s.fields = fields; + s.fieldCount = 2; + s.typeLocalName = &localname; + s.typeNs = &ns; + + prepare_struct_type_test( reader, "<t val=\"-1\" xmlns=\"ns\"/>" ); + hr = WsReadToStartElement( reader, &localname, &ns2, NULL, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + + test = NULL; + hr = WsReadType( reader, WS_ELEMENT_TYPE_MAPPING, WS_STRUCT_TYPE, &s, + WS_READ_REQUIRED_POINTER, heap, &test, sizeof(test), NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + ok( test != NULL, "test not set\n" ); + if (test) + { + ok( test->val == -1, "got %d\n", test->val ); + ok( test->desc == &s, "got %p\n", test->desc ); + } + + WsFreeReader( reader ); + WsFreeHeap( heap ); +} + START_TEST(reader) { test_WsCreateError(); @@ -6891,4 +6952,5 @@ START_TEST(reader) test_repeating_element_choice(); test_empty_text_field(); test_stream_input(); + test_description_type(); } -- 2.20.1

1 0

[PATCH 2/4] webservices: Accept empty namespace in attribute type mapping.
by Hans Leidekker March 27, 2020

March 27, 2020

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/webservices/reader.c | 21 ++++++++++++++++++--- dlls/webservices/tests/reader.c | 29 ++++++++++++++++++++++++++++- 2 files changed, 46 insertions(+), 4 deletions(-) diff --git a/dlls/webservices/reader.c b/dlls/webservices/reader.c index 119043f705..4d37a38a8a 100644 --- a/dlls/webservices/reader.c +++ b/dlls/webservices/reader.c @@ -4343,9 +4343,24 @@ static HRESULT get_text( struct reader *reader, WS_TYPE_MAPPING mapping, const W { case WS_ATTRIBUTE_TYPE_MAPPING: { - ULONG index; - if (!(*found = find_attribute( reader, localname, ns, &index ))) return S_OK; - return get_attribute_text( reader, index, ret ); + ULONG i; + WS_XML_ELEMENT_NODE *elem = &reader->current->hdr; + + *found = FALSE; + for (i = 0; i < elem->attributeCount; i++) + { + const WS_XML_STRING *localname2 = elem->attributes[i]->localName; + const WS_XML_STRING *ns2 = elem->attributes[i]->ns; + + if (cmp_name( localname->bytes, localname->length, localname2->bytes, localname2->length )) continue; + if (!ns->length || !cmp_name( ns->bytes, ns->length, ns2->bytes, ns2->length )) + { + *found = TRUE; + break; + } + } + if (!*found) return S_OK; + return get_attribute_text( reader, i, ret ); } case WS_ELEMENT_TYPE_MAPPING: case WS_ELEMENT_CONTENT_TYPE_MAPPING: diff --git a/dlls/webservices/tests/reader.c b/dlls/webservices/tests/reader.c index ef6fd8808e..733ebe3eb1 100644 --- a/dlls/webservices/tests/reader.c +++ b/dlls/webservices/tests/reader.c @@ -2556,7 +2556,8 @@ static void test_cdata(void) static void test_WsFindAttribute(void) { static const char test[] = "<t attr='value' attr2='value2'></t>"; - WS_XML_STRING ns = {0, NULL}, localname = {4, (BYTE *)"attr"}; + static const char test2[] = "<p:t attr='value' p:attr2='value2' xmlns:p=\"ns\"></t>"; + WS_XML_STRING ns = {0, NULL}, ns2 = {2, (BYTE *)"ns"}, localname = {4, (BYTE *)"attr"}; WS_XML_STRING localname2 = {5, (BYTE *)"attr2"}, localname3 = {5, (BYTE *)"attr3"}; WS_XML_READER *reader; ULONG index; @@ -2638,6 +2639,32 @@ static void test_WsFindAttribute(void) ok( hr == S_FALSE, "got %08x\n", hr ); ok( index == ~0u, "got %u\n", index ); + hr = set_input( reader, test2, sizeof(test2) - 1 ); + ok( hr == S_OK, "got %08x\n", hr ); + + hr = WsReadNode( reader, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + + index = 0xdeadbeef; + hr = WsFindAttribute( reader, &localname, &ns, TRUE, &index, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + ok( !index, "got %u\n", index ); + + hr = WsFindAttribute( reader, &localname2, &ns2, TRUE, &index, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + + hr = WsFindAttribute( reader, &localname2, &ns, TRUE, &index, NULL ); + ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr ); + + hr = set_input( reader, test2, sizeof(test2) - 1 ); + ok( hr == S_OK, "got %08x\n", hr ); + + hr = WsReadNode( reader, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + + hr = WsFindAttribute( reader, &localname, &ns2, TRUE, &index, NULL ); + ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr ); + WsFreeReader( reader ); } -- 2.20.1

1 0

[PATCH 1/4] webservices: Read past XML declaration and opening bracket in WsReadStartElement.
by Hans Leidekker March 27, 2020

March 27, 2020

Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/webservices/reader.c | 13 +++++++-- dlls/webservices/tests/reader.c | 48 ++++++++++++++++++++++++++++++++- 2 files changed, 58 insertions(+), 3 deletions(-) diff --git a/dlls/webservices/reader.c b/dlls/webservices/reader.c index f1ce93b7d7..119043f705 100644 --- a/dlls/webservices/reader.c +++ b/dlls/webservices/reader.c @@ -2654,7 +2654,17 @@ static HRESULT read_node_text( struct reader * ); static HRESULT read_startelement_text( struct reader *reader ) { + HRESULT hr; + + if (read_cmp( reader, "<?", 2 ) == S_OK) + { + if ((hr = read_xmldecl( reader )) != S_OK) return hr; + } read_skip_whitespace( reader ); + if (read_cmp( reader, "<", 1 ) == S_OK) + { + if ((hr = read_element_text( reader )) != S_OK) return hr; + } if (read_cmp( reader, "/>", 2 ) == S_OK) { read_skip( reader, 2 ); @@ -3021,8 +3031,7 @@ static HRESULT read_node_text( struct reader *reader ) else if (reader->state == READER_STATE_CDATA) return read_endcdata( reader ); else if (read_cmp( reader, "<?", 2 ) == S_OK) { - hr = read_xmldecl( reader ); - if (FAILED( hr )) return hr; + if ((hr = read_xmldecl( reader )) != S_OK) return hr; } else if (read_cmp( reader, "</", 2 ) == S_OK) return read_endelement_text( reader ); else if (read_cmp( reader, "<![CDATA[", 9 ) == S_OK) return read_startcdata( reader ); diff --git a/dlls/webservices/tests/reader.c b/dlls/webservices/tests/reader.c index 5fb81b5dc8..ef6fd8808e 100644 --- a/dlls/webservices/tests/reader.c +++ b/dlls/webservices/tests/reader.c @@ -31,7 +31,7 @@ static const char data2[] = {0xef,0xbb,0xbf,'<','t','e','x','t','>','t','e','s','t','<','/','t','e','x','t','>',0}; static const char data3[] = - "<?xml version=\"1.0\" encoding=\"utf-8\"?>" + "<?xml version=\"1.0\" encoding=\"utf-8\"?> " "<text>test</TEXT>"; static const char data4[] = @@ -928,6 +928,52 @@ static void test_WsReadStartElement(void) hr = WsReadEndElement( reader, NULL ); ok( hr == WS_E_INVALID_FORMAT, "got %08x\n", hr ); + hr = set_input( reader, data3, sizeof(data3) - 1 ); + ok( hr == S_OK, "got %08x\n", hr ); + + hr = WsReadStartElement( reader, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + + node = NULL; + hr = WsGetReaderNode( reader, &node, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + if (node) + { + WS_XML_TEXT_NODE *text = (WS_XML_TEXT_NODE *)node; + ok( text->node.nodeType == WS_XML_NODE_TYPE_TEXT, "got %u\n", text->node.nodeType ); + ok( text->text != NULL, "text not set\n" ); + if (text->text) + { + WS_XML_UTF8_TEXT *utf8 = (WS_XML_UTF8_TEXT *)text->text; + ok( text->text->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", text->text->textType ); + ok( utf8->value.length == 4, "got %u\n", utf8->value.length ); + ok( !memcmp( utf8->value.bytes, "test", 4 ), "wrong data\n" ); + } + } + + hr = set_input( reader, " <text>test</text>", sizeof(" <text>test</text>") - 1 ); + ok( hr == S_OK, "got %08x\n", hr ); + + hr = WsReadStartElement( reader, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + + node = NULL; + hr = WsGetReaderNode( reader, &node, NULL ); + ok( hr == S_OK, "got %08x\n", hr ); + if (node) + { + WS_XML_TEXT_NODE *text = (WS_XML_TEXT_NODE *)node; + ok( text->node.nodeType == WS_XML_NODE_TYPE_TEXT, "got %u\n", text->node.nodeType ); + ok( text->text != NULL, "text not set\n" ); + if (text->text) + { + WS_XML_UTF8_TEXT *utf8 = (WS_XML_UTF8_TEXT *)text->text; + ok( text->text->textType == WS_XML_TEXT_TYPE_UTF8, "got %u\n", text->text->textType ); + ok( utf8->value.length == 4, "got %u\n", utf8->value.length ); + ok( !memcmp( utf8->value.bytes, "test", 4 ), "wrong data\n" ); + } + } + WsFreeReader( reader ); } -- 2.20.1

1 0

[PATCH] mf: Fix returned session rates when pipeline objects don't support rate control.
by Nikolay Sivov March 27, 2020

March 27, 2020

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/mf/session.c | 58 ++++++++++++++++++++++++++++++++--------------- 1 file changed, 40 insertions(+), 18 deletions(-) diff --git a/dlls/mf/session.c b/dlls/mf/session.c index 2147f70cc8..debb58de4d 100644 --- a/dlls/mf/session.c +++ b/dlls/mf/session.c @@ -2805,28 +2805,41 @@ static ULONG WINAPI session_rate_support_Release(IMFRateSupport *iface) return IMFMediaSession_Release(&session->IMFMediaSession_iface); } -static void session_presentation_object_get_rate(IUnknown *object, MFRATE_DIRECTION direction, +static HRESULT session_presentation_object_get_rate(IUnknown *object, MFRATE_DIRECTION direction, BOOL thin, BOOL fastest, float *result) { IMFRateSupport *rate_support; float rate; + HRESULT hr; - if (SUCCEEDED(MFGetService(object, &MF_RATE_CONTROL_SERVICE, &IID_IMFRateSupport, (void **)&rate_support))) + /* For objects that don't support rate control, it's assumed that only forward direction is allowed, at 1.0f. */ + + if (FAILED(hr = MFGetService(object, &MF_RATE_CONTROL_SERVICE, &IID_IMFRateSupport, (void **)&rate_support))) { - rate = 0.0f; - if (fastest) + if (direction == MFRATE_FORWARD) { - if (SUCCEEDED(IMFRateSupport_GetFastestRate(rate_support, direction, thin, &rate))) - *result = min(fabsf(rate), *result); + *result = 1.0f; + return S_OK; } else - { - if (SUCCEEDED(IMFRateSupport_GetSlowestRate(rate_support, direction, thin, &rate))) - *result = max(fabsf(rate), *result); - } + return MF_E_REVERSE_UNSUPPORTED; + } - IMFRateSupport_Release(rate_support); + rate = 0.0f; + if (fastest) + { + if (SUCCEEDED(hr = IMFRateSupport_GetFastestRate(rate_support, direction, thin, &rate))) + *result = min(fabsf(rate), *result); + } + else + { + if (SUCCEEDED(hr = IMFRateSupport_GetSlowestRate(rate_support, direction, thin, &rate))) + *result = max(fabsf(rate), *result); } + + IMFRateSupport_Release(rate_support); + + return hr; } static HRESULT session_get_presentation_rate(struct media_session *session, MFRATE_DIRECTION direction, @@ -2834,24 +2847,33 @@ static HRESULT session_get_presentation_rate(struct media_session *session, MFRA { struct media_source *source; struct media_sink *sink; + HRESULT hr = E_POINTER; *result = 0.0f; EnterCriticalSection(&session->cs); - LIST_FOR_EACH_ENTRY(source, &session->presentation.sources, struct media_source, entry) + if (session->presentation.topo_status != MF_TOPOSTATUS_INVALID) { - session_presentation_object_get_rate((IUnknown *)source->source, direction, thin, fastest, result); - } + LIST_FOR_EACH_ENTRY(source, &session->presentation.sources, struct media_source, entry) + { + if (FAILED(hr = session_presentation_object_get_rate((IUnknown *)source->source, direction, thin, fastest, result))) + break; + } - LIST_FOR_EACH_ENTRY(sink, &session->presentation.sinks, struct media_sink, entry) - { - session_presentation_object_get_rate((IUnknown *)sink->sink, direction, thin, fastest, result); + if (SUCCEEDED(hr)) + { + LIST_FOR_EACH_ENTRY(sink, &session->presentation.sinks, struct media_sink, entry) + { + if (FAILED(hr = session_presentation_object_get_rate((IUnknown *)sink->sink, direction, thin, fastest, result))) + break; + } + } } LeaveCriticalSection(&session->cs); - return S_OK; + return hr; } static HRESULT WINAPI session_rate_support_GetSlowestRate(IMFRateSupport *iface, MFRATE_DIRECTION direction, -- 2.25.1

1 0

[PATCH] mfplat: Add remaining media type attributes guids.
by Nikolay Sivov March 27, 2020

March 27, 2020

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/mfplat/main.c | 36 +++++++++++++++++++++++++++++++++++- include/mfapi.h | 36 ++++++++++++++++++++++++++++++++++++ 2 files changed, 71 insertions(+), 1 deletion(-) diff --git a/dlls/mfplat/main.c b/dlls/mfplat/main.c index e3cb35d866..889961b8d1 100644 --- a/dlls/mfplat/main.c +++ b/dlls/mfplat/main.c @@ -1559,6 +1559,8 @@ const char *debugstr_attr(const GUID *guid) X(MF_MT_MPEG2_TIMECODE), X(MF_PMP_SERVER_CONTEXT), X(MFT_SUPPORT_DYNAMIC_FORMAT_CHANGE), + X(MF_MT_CUSTOM_VIDEO_PRIMARIES), + X(MF_MT_TIMESTAMP_CAN_BE_DTS), X(MFT_CODEC_MERIT_Attribute), X(MF_TOPOLOGY_PLAYBACK_MAX_DIMS), X(MF_LOW_LATENCY), @@ -1567,13 +1569,19 @@ const char *debugstr_attr(const GUID *guid) X(MF_MT_PIXEL_ASPECT_RATIO), X(MF_TOPOLOGY_ENABLE_XVP_FOR_PLAYBACK), X(MFT_CONNECTED_STREAM_ATTRIBUTE), + X(MF_MT_REALTIME_CONTENT), X(MF_MT_WRAPPED_TYPE), + X(MF_MT_DRM_FLAGS), X(MF_MT_AVG_BITRATE), + X(MF_MT_DECODER_USE_MAX_RESOLUTION), + X(MF_MT_MAX_LUMINANCE_LEVEL), X(MFT_CONNECTED_TO_HW_STREAM), X(MF_SA_D3D_AWARE), + X(MF_MT_MAX_KEYFRAME_SPACING), X(MFT_TRANSFORM_CLSID_Attribute), X(MFT_TRANSFORM_CLSID_Attribute), X(MF_SOURCE_READER_ENABLE_ADVANCED_VIDEO_PROCESSING), + X(MF_MT_AM_FORMAT_TYPE), X(MF_SESSION_APPROX_EVENT_OCCURRENCE_TIME), X(MF_MT_H264_MAX_MB_PER_SEC), X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_MAX_BUFFERS), @@ -1604,6 +1612,7 @@ const char *debugstr_attr(const GUID *guid) X(MF_MT_PALETTE), X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_PROVIDER_DEVICE_ID), X(MF_TOPOLOGY_STATIC_PLAYBACK_OPTIMIZATIONS), + X(MF_MT_GEOMETRIC_APERTURE), X(MF_MT_ORIGINAL_WAVE_FORMAT_TAG), X(MF_MT_DV_AAUX_SRC_PACK_1), X(MF_MT_DEFAULT_STRIDE), @@ -1611,18 +1620,25 @@ const char *debugstr_attr(const GUID *guid) X(MF_TRANSFORM_CATEGORY_Attribute), X(MF_MT_MPEG2_HDCP), X(MF_MT_AUDIO_FLOAT_SAMPLES_PER_SECOND), + X(MF_MT_SPATIAL_AUDIO_MAX_DYNAMIC_OBJECTS), + X(MF_MT_DECODER_MAX_DPB_COUNT), X(MFSampleExtension_ForwardedDecodeUnits), X(MF_MT_DV_AAUX_CTRL_PACK_0), + X(MF_MT_YUV_MATRIX), X(MF_EVENT_SOURCE_TOPOLOGY_CANCELED), + X(MF_MT_MPEG4_CURRENT_SAMPLE_ENTRY), + X(MF_MT_MAX_FRAME_AVERAGE_LUMINANCE_LEVEL), X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_ENDPOINT_ID), X(MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME), X(MF_MT_VIDEO_ROTATION), X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_SYMBOLIC_LINK), X(MF_MT_USER_DATA), + X(MF_MT_MIN_MASTERING_LUMINANCE), X(MF_EVENT_STREAM_METADATA_SYSTEMID), X(MF_MT_AUDIO_CHANNEL_MASK), X(MF_SOURCE_READER_DISCONNECT_MEDIASOURCE_ON_SHUTDOWN), X(MF_READWRITE_DISABLE_CONVERTERS), + X(MF_MT_MINIMUM_DISPLAY_APERTURE), X(MFSampleExtension_Token), X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_CATEGORY), X(MF_MT_AUDIO_VALID_BITS_PER_SAMPLE), @@ -1630,10 +1646,11 @@ const char *debugstr_attr(const GUID *guid) X(MF_DISABLE_FRAME_CORRUPTION_INFO), X(MF_TOPOLOGY_ENUMERATE_SOURCE_TYPES), X(MF_MT_VIDEO_NO_FRAME_ORDERING), + X(MF_MT_VIDEO_CHROMA_SITING), X(MFSampleExtension_3DVideo_SampleFormat), X(MF_MT_H264_RESOLUTION_SCALING), - X(MF_MT_VIDEO_LEVEL), X(MF_MT_MPEG2_LEVEL), + X(MF_MT_VIDEO_LEVEL), X(MF_SAMPLEGRABBERSINK_SAMPLE_TIME_OFFSET), X(MF_MT_SAMPLE_SIZE), X(MF_MT_AAC_PAYLOAD_TYPE), @@ -1654,6 +1671,7 @@ const char *debugstr_attr(const GUID *guid) X(MF_SESSION_GLOBAL_TIME), X(MF_SESSION_QUALITY_MANAGER), X(MF_SESSION_CONTENT_PROTECTION_MANAGER), + X(MF_MT_MPEG4_SAMPLE_DESCRIPTION), X(MF_MT_MPEG_START_TIME_CODE), X(MFT_REMUX_MARK_I_PICTURE_AS_CLEAN_POINT), X(MFT_REMUX_MARK_I_PICTURE_AS_CLEAN_POINT), @@ -1690,6 +1708,7 @@ const char *debugstr_attr(const GUID *guid) X(MF_TRANSFORM_ASYNC), X(MF_TOPONODE_STREAMID), X(MF_TOPONODE_NOSHUTDOWN_ON_REMOVE), + X(MF_MT_VIDEO_LIGHTING), X(MF_SD_MUTUALLY_EXCLUSIVE), X(MF_SD_STREAM_NAME), X(MF_MT_DV_VAUX_SRC_PACK), @@ -1708,6 +1727,7 @@ const char *debugstr_attr(const GUID *guid) X(MF_MT_AUDIO_SAMPLES_PER_BLOCK), X(MFT_ENUM_HARDWARE_URL_Attribute), X(MF_SOURCE_READER_ASYNC_CALLBACK), + X(MF_MT_OUTPUT_BUFFER_NUM), X(MFT_ENCODER_SUPPORTS_CONFIG_EVENT), X(MF_MT_AUDIO_FLAC_MAX_BLOCK_SIZE), X(MFT_FRIENDLY_NAME_Attribute), @@ -1717,6 +1737,7 @@ const char *debugstr_attr(const GUID *guid) X(MFT_INPUT_TYPES_Attributes), X(MF_MT_H264_LAYOUT_PER_STREAM), X(MF_EVENT_SCRUBSAMPLE_TIME), + X(MF_MT_SPATIAL_AUDIO_MAX_METADATA_ITEMS), X(MF_MT_MPEG2_ONE_FRAME_PER_PACKET), X(MF_MT_INTERLACE_MODE), X(MF_MT_VIDEO_RENDERER_EXTENSION_PROFILE), @@ -1724,14 +1745,19 @@ const char *debugstr_attr(const GUID *guid) X(MF_MT_AUDIO_PREFER_WAVEFORMATEX), X(MF_MT_H264_SVC_CAPABILITIES), X(MF_TOPONODE_WORKQUEUE_ITEM_PRIORITY), + X(MF_MT_SPATIAL_AUDIO_OBJECT_METADATA_LENGTH), + X(MF_MT_SPATIAL_AUDIO_OBJECT_METADATA_FORMAT_ID), X(MF_SAMPLEGRABBERSINK_IGNORE_CLOCK), + X(MF_MT_PAN_SCAN_ENABLED), X(MF_MT_DV_VAUX_CTRL_PACK), X(MFSampleExtension_ForwardedDecodeUnitType), X(MF_MT_AUDIO_AVG_BYTES_PER_SECOND), X(MF_SOURCE_READER_MEDIASOURCE_CHARACTERISTICS), + X(MF_MT_SPATIAL_AUDIO_MIN_METADATA_ITEM_OFFSET_SPACING), X(MF_TOPONODE_TRANSFORM_OBJECTID), X(MF_DEVSOURCE_ATTRIBUTE_MEDIA_TYPE), X(MF_EVENT_MFT_INPUT_STREAM_ID), + X(MF_MT_SOURCE_CONTENT_HINT), X(MFT_ENUM_HARDWARE_VENDOR_ID_Attribute), X(MFT_ENUM_TRANSCODE_ONLY_ATTRIBUTE), X(MF_READWRITE_MMCSS_PRIORITY), @@ -1743,6 +1769,8 @@ const char *debugstr_attr(const GUID *guid) X(MF_EVENT_START_PRESENTATION_TIME_AT_OUTPUT), X(MFSampleExtension_DecodeTimestamp), X(MF_MT_VIDEO_H264_NO_FMOASO), + X(MF_MT_AVG_BIT_ERROR_RATE), + X(MF_MT_VIDEO_PRIMARIES), X(MF_SINK_WRITER_DISABLE_THROTTLING), X(MF_MT_H264_RATE_CONTROL_MODES), X(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK), @@ -1750,19 +1778,24 @@ const char *debugstr_attr(const GUID *guid) X(MF_READWRITE_MMCSS_CLASS_AUDIO), X(MF_SOURCE_READER_DISABLE_CAMERA_PLUGINS), X(MF_MT_MPEG4_TRACK_TYPE), + X(MF_MT_PAN_SCAN_APERTURE), X(MF_TOPOLOGY_RESOLUTION_STATUS), X(MF_MT_ORIGINAL_4CC), X(MF_PD_AUDIO_ISVARIABLEBITRATE), X(MF_MT_MPEG2_CONTENT_PACKET), X(MFT_PROCESS_LOCAL_Attribute), X(MFT_PROCESS_LOCAL_Attribute), + X(MF_MT_PAD_CONTROL_FLAGS), + X(MF_MT_VIDEO_NOMINAL_RANGE), X(MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION), X(MF_MT_MPEG_SEQUENCE_HEADER), X(MF_MT_AUDIO_SAMPLES_PER_SECOND), + X(MF_MT_SPATIAL_AUDIO_DATA_PRESENT), X(MF_MT_FRAME_RATE), X(MF_TOPONODE_FLUSH), X(MF_MT_MPEG2_STANDARD), X(MF_TOPONODE_DRAIN), + X(MF_MT_TRANSFER_FUNCTION), X(MF_TOPONODE_MEDIASTART), X(MF_TOPONODE_MEDIASTOP), X(MF_SOURCE_READER_MEDIASOURCE_CONFIG), @@ -1777,6 +1810,7 @@ const char *debugstr_attr(const GUID *guid) X(MF_MT_FORWARD_CUSTOM_SEI), X(MF_TOPONODE_CONNECT_METHOD), X(MFT_OUTPUT_TYPES_Attributes), + X(MF_MT_IMAGE_LOSS_TOLERANT), X(MF_SESSION_REMOTE_SOURCE_MODE), X(MF_MT_DEPTH_VALUE_UNIT), X(MF_MT_AUDIO_NUM_CHANNELS), diff --git a/include/mfapi.h b/include/mfapi.h index 80c9ea3eae..f83b7636fe 100644 --- a/include/mfapi.h +++ b/include/mfapi.h @@ -224,12 +224,30 @@ typedef enum _EAllocationType #include <initguid.h> #endif +DEFINE_GUID(MF_MT_AM_FORMAT_TYPE, 0x73d1072d, 0x1870, 0x4174, 0xa0, 0x63, 0x29, 0xff, 0x4f, 0xf6, 0xc1, 0x1e); +DEFINE_GUID(MF_MT_AVG_BIT_ERROR_RATE, 0x799cabd6, 0x3508, 0x4db4, 0xa3, 0xc7, 0x56, 0x9c, 0xd5, 0x33, 0xde, 0xb1); DEFINE_GUID(MF_MT_AVG_BITRATE, 0x20332624, 0xfb0d, 0x4d9e, 0xbd, 0x0d, 0xcb, 0xf6, 0x78, 0x6c, 0x10, 0x2e); +DEFINE_GUID(MF_MT_CUSTOM_VIDEO_PRIMARIES, 0x47537213, 0x8cfb, 0x4722, 0xaa, 0x34, 0xfb, 0xc9, 0xe2, 0x4d, 0x77, 0xb8); +DEFINE_GUID(MF_MT_DECODER_MAX_DPB_COUNT, 0x67be144c, 0x88b7, 0x4ca9, 0x96, 0x28, 0xc8, 0x08, 0xd5, 0x26, 0x22, 0x17); +DEFINE_GUID(MF_MT_DECODER_USE_MAX_RESOLUTION, 0x4c547c24, 0xaf9a, 0x4f38, 0x96, 0xad, 0x97, 0x87, 0x73, 0xcf, 0x53, 0xe7); +DEFINE_GUID(MF_MT_DRM_FLAGS, 0x8772f323, 0x355a, 0x4cc7, 0xbb, 0x78, 0x6d, 0x61, 0xa0, 0x48, 0xae, 0x82); DEFINE_GUID(MF_MT_FRAME_RATE, 0xc459a2e8, 0x3d2c, 0x4e44, 0xb1, 0x32, 0xfe, 0xe5, 0x15, 0x6c, 0x7b, 0xb0); DEFINE_GUID(MF_MT_FRAME_SIZE, 0x1652c33d, 0xd6b2, 0x4012, 0xb8, 0x34, 0x72, 0x03, 0x08, 0x49, 0xa3, 0x7d); +DEFINE_GUID(MF_MT_GEOMETRIC_APERTURE, 0x66758743, 0x7e5f, 0x400d, 0x98, 0x0a, 0xaa, 0x85, 0x96, 0xc8, 0x56, 0x96); +DEFINE_GUID(MF_MT_IMAGE_LOSS_TOLERANT, 0xed062cf4, 0xe34e, 0x4922, 0xbe, 0x99, 0x93, 0x40, 0x32, 0x13, 0x3d, 0x7c); DEFINE_GUID(MF_MT_INTERLACE_MODE, 0xe2724bb8, 0xe676, 0x4806, 0xb4, 0xb2, 0xa8, 0xd6, 0xef, 0xb4, 0x4c, 0xcd); DEFINE_GUID(MF_MT_MAJOR_TYPE, 0x48eba18e, 0xf8c9, 0x4687, 0xbf, 0x11, 0x0a, 0x74, 0xc9, 0xf9, 0x6a, 0x8f); +DEFINE_GUID(MF_MT_MAX_FRAME_AVERAGE_LUMINANCE_LEVEL, 0x58d4bf57, 0x6f52, 0x4733, 0xa1, 0x95, 0xa9, 0xe2, 0x9e, 0xcf, 0x9e, 0x27); +DEFINE_GUID(MF_MT_MAX_KEYFRAME_SPACING, 0xc16eb52b, 0x73a1, 0x476f, 0x8d, 0x62, 0x83, 0x9d, 0x6a, 0x02, 0x06, 0x52); +DEFINE_GUID(MF_MT_MAX_LUMINANCE_LEVEL, 0x50253128, 0xc110, 0x4de4, 0x98, 0xae, 0x46, 0xa3, 0x24, 0xfa, 0xe6, 0xda); +DEFINE_GUID(MF_MT_MAX_MASTERING_LUMINANCE, 0xd6c6b997, 0x272f, 0x4ca1, 0x8d, 0x00, 0x80, 0x42, 0x11, 0x1a, 0x0f, 0xf6); +DEFINE_GUID(MF_MT_MIN_MASTERING_LUMINANCE, 0x839a4460, 0x4e7e, 0x4b4f, 0xae, 0x79, 0xcc, 0x08, 0x90, 0x5c, 0x7b, 0x27); +DEFINE_GUID(MF_MT_MINIMUM_DISPLAY_APERTURE, 0xd7388766, 0x18fe, 0x48c6, 0xa1, 0x77, 0xee, 0x89, 0x48, 0x67, 0xc8, 0xc4); +DEFINE_GUID(MF_MT_MPEG4_SAMPLE_DESCRIPTION, 0x261e9d83, 0x9529, 0x4b8f, 0xa1, 0x11, 0x8b, 0x9c, 0x95, 0x0a, 0x81, 0xa9); +DEFINE_GUID(MF_MT_MPEG4_CURRENT_SAMPLE_ENTRY, 0x9aa7e155, 0xb64a, 0x4c1d, 0xa5, 0x00, 0x45, 0x5d, 0x60, 0x0b, 0x65, 0x60); DEFINE_GUID(MF_MT_PIXEL_ASPECT_RATIO, 0xc6376a1e, 0x8d0a, 0x4027, 0xbe, 0x45, 0x6d, 0x9a, 0x0a, 0xd3, 0x9b, 0xb6); +DEFINE_GUID(MF_MT_REALTIME_CONTENT, 0xbb12d222, 0x2bdb, 0x425e, 0x91, 0xec, 0x23, 0x08, 0xe1, 0x89, 0xa5, 0x8f); +DEFINE_GUID(MF_MT_OUTPUT_BUFFER_NUM, 0xa505d3ac, 0xf930, 0x436e, 0x8e, 0xde, 0x93, 0xa5, 0x09, 0xce, 0x23, 0xb2); DEFINE_GUID(MF_MT_SUBTYPE, 0xf7e34c9a, 0x42e8, 0x4714, 0xb7, 0x4b, 0xcb, 0x29, 0xd7, 0x2c, 0x35, 0xe5); DEFINE_GUID(MF_MT_ALL_SAMPLES_INDEPENDENT, 0xc9173739, 0x5e56, 0x461c, 0xb7, 0x13, 0x46, 0xfb, 0x99, 0x5c, 0xb9, 0x5f); DEFINE_GUID(MF_MT_USER_DATA, 0xb6bc765f, 0x4c3b, 0x40a4, 0xbd, 0x51, 0x25, 0x35, 0xb6, 0x6f, 0xe0, 0x9d); @@ -244,13 +262,23 @@ DEFINE_GUID(MF_MT_VIDEO_3D_FORMAT, 0x5315d8a0, 0x87c5, 0x469 DEFINE_GUID(MF_MT_VIDEO_3D_NUM_VIEWS, 0xbb077e8a, 0xdcbf, 0x42eb, 0xaf, 0x60, 0x41, 0x8d, 0xf9, 0x8a, 0xa4, 0x95); DEFINE_GUID(MF_MT_VIDEO_3D_LEFT_IS_BASE, 0x6d4b7bff, 0x5629, 0x4404, 0x94, 0x8c, 0xc6, 0x34, 0xf4, 0xce, 0x26, 0xd4); DEFINE_GUID(MF_MT_VIDEO_3D_FIRST_IS_LEFT, 0xec298493, 0x0ada, 0x4ea1, 0xa4, 0xfe, 0xcb, 0xbd, 0x36, 0xce, 0x93, 0x31); +DEFINE_GUID(MF_MT_VIDEO_CHROMA_SITING, 0x65df2370, 0xc773, 0x4c33, 0xaa, 0x64, 0x84, 0x3e, 0x06, 0x8e, 0xfb, 0x0c); DEFINE_GUID(MF_MT_VIDEO_LEVEL, 0x96f66574, 0x11c5, 0x4015, 0x86, 0x66, 0xbf, 0xf5, 0x16, 0x43, 0x6d, 0xa7); +DEFINE_GUID(MF_MT_VIDEO_LIGHTING, 0x53a0529c, 0x890b, 0x4216, 0x8b, 0xf9, 0x59, 0x93, 0x67, 0xad, 0x6d, 0x20); +DEFINE_GUID(MF_MT_VIDEO_NOMINAL_RANGE, 0xc21b8ee5, 0xb956, 0x4071, 0x8d, 0xaf, 0x32, 0x5e, 0xdf, 0x5c, 0xab, 0x11); +DEFINE_GUID(MF_MT_VIDEO_PRIMARIES, 0xdbfbe4d7, 0x0740, 0x4ee0, 0x81, 0x92, 0x85, 0x0a, 0xb0, 0xe2, 0x19, 0x35); DEFINE_GUID(MF_MT_VIDEO_PROFILE, 0xad76a80b, 0x2d5c, 0x4e0b, 0xb3, 0x75, 0x64, 0xe5, 0x20, 0x13, 0x70, 0x36); DEFINE_GUID(MF_MT_VIDEO_ROTATION, 0xc380465d, 0x2271, 0x428c, 0x9b, 0x83, 0xec, 0xea, 0x3b, 0x4a, 0x85, 0xc1); DEFINE_GUID(MF_MT_VIDEO_RENDERER_EXTENSION_PROFILE, 0x8437d4b9, 0xd448, 0x4fcd, 0x9b, 0x6b, 0x83, 0x9b, 0xf9, 0x6c, 0x77, 0x98); DEFINE_GUID(MF_MT_VIDEO_NO_FRAME_ORDERING, 0x3f5b106f, 0x6bc2, 0x4ee3, 0xb7, 0xed, 0x89, 0x02, 0xc1, 0x8f, 0x53, 0x51); DEFINE_GUID(MF_MT_VIDEO_H264_NO_FMOASO, 0xed461cd6, 0xec9f, 0x416a, 0xa8, 0xa3, 0x26, 0xd7, 0xd3, 0x10, 0x18, 0xd7); +DEFINE_GUID(MF_MT_PAD_CONTROL_FLAGS, 0x4d0e73e5, 0x80ea, 0x4354, 0xa9, 0xd0, 0x11, 0x76, 0xce, 0xb0, 0x28, 0xea); +DEFINE_GUID(MF_MT_PAN_SCAN_APERTURE, 0x79614dde, 0x9187, 0x48fb, 0xb8, 0xc7, 0x4d, 0x52, 0x68, 0x9d, 0xe6, 0x49); +DEFINE_GUID(MF_MT_PAN_SCAN_ENABLED, 0x4b7f6bc3, 0x8b13, 0x40b2, 0xa9, 0x93, 0xab, 0xf6, 0x30, 0xb8, 0x20, 0x4e); DEFINE_GUID(MF_MT_SECURE, 0xc5acc4fd, 0x0304, 0x4ecf, 0x80, 0x9f, 0x47, 0xbc, 0x97, 0xff, 0x63, 0xbd); +DEFINE_GUID(MF_MT_SOURCE_CONTENT_HINT, 0x68aca3cc, 0x22d0, 0x44e6, 0x85, 0xf8, 0x28, 0x16, 0x71, 0x97, 0xfa, 0x38); +DEFINE_GUID(MF_MT_TIMESTAMP_CAN_BE_DTS, 0x24974215, 0x1b7b, 0x41e4, 0x86, 0x25, 0xac, 0x46, 0x9f, 0x2d, 0xed, 0xaa); +DEFINE_GUID(MF_MT_TRANSFER_FUNCTION, 0x5fb0fce9, 0xbe5c, 0x4935, 0xa8, 0x11, 0xec, 0x83, 0x8f, 0x8e, 0xed, 0x93); DEFINE_GUID(MF_MT_ALPHA_MODE, 0x5d959b0d, 0x4cbf, 0x4d04, 0x91, 0x9f, 0x3f, 0x5f, 0x7f, 0x28, 0x42, 0x11); DEFINE_GUID(MF_MT_DEPTH_MEASUREMENT, 0xfd5ac489, 0x0917, 0x4bb6, 0x9d, 0x54, 0x31, 0x22, 0xbf, 0x70, 0x14, 0x4b); DEFINE_GUID(MF_MT_DEPTH_VALUE_UNIT, 0x21a800f5, 0x3189, 0x4797, 0xbe, 0xba, 0xf1, 0x3c, 0xd9, 0xa3, 0x1a, 0x5e); @@ -276,6 +304,14 @@ DEFINE_GUID(MF_MT_ORIGINAL_4CC, 0xd7be3fe0, 0x2bc7, 0x492 DEFINE_GUID(MF_MT_ORIGINAL_WAVE_FORMAT_TAG, 0x8cbbc843, 0x9fd9, 0x49c2, 0x88, 0x2f, 0xa7, 0x25, 0x86, 0xc4, 0x08, 0xad); DEFINE_GUID(MF_MT_DEFAULT_STRIDE, 0x644b4e48, 0x1e02, 0x4516, 0xb0, 0xeb, 0xc0, 0x1c, 0xa9, 0xd4, 0x9a, 0xc6); DEFINE_GUID(MF_MT_PALETTE, 0x6d283f42, 0x9846, 0x4410, 0xaf, 0xd9, 0x65, 0x4d, 0x50, 0x3b, 0x1a, 0x54); +DEFINE_GUID(MF_MT_YUV_MATRIX, 0x3e23d450, 0x2c75, 0x4d25, 0xa0, 0x0e, 0xb9, 0x16, 0x70, 0xd1, 0x23, 0x27); + +DEFINE_GUID(MF_MT_SPATIAL_AUDIO_MAX_DYNAMIC_OBJECTS, 0xdcfba24a, 0x2609, 0x4240, 0xa7, 0x21, 0x3f, 0xae, 0xa7, 0x6a, 0x4d, 0xf9); +DEFINE_GUID(MF_MT_SPATIAL_AUDIO_OBJECT_METADATA_FORMAT_ID, 0x2ab71bc0, 0x6223, 0x4ba7, 0xad, 0x64, 0x7b, 0x94, 0xb4, 0x7a, 0xe7, 0x92); +DEFINE_GUID(MF_MT_SPATIAL_AUDIO_OBJECT_METADATA_LENGTH, 0x094ba8be, 0xd723, 0x489f, 0x92, 0xfa, 0x76, 0x67, 0x77, 0xb3, 0x47, 0x26); +DEFINE_GUID(MF_MT_SPATIAL_AUDIO_MAX_METADATA_ITEMS, 0x11aa80b4, 0xe0da, 0x47c6, 0x80, 0x60, 0x96, 0xc1, 0x25, 0x9a, 0xe5, 0x0d); +DEFINE_GUID(MF_MT_SPATIAL_AUDIO_MIN_METADATA_ITEM_OFFSET_SPACING, 0x83e96ec9, 0x1184, 0x417e, 0x82, 0x54, 0x9f, 0x26, 0x91, 0x58, 0xfc, 0x06); +DEFINE_GUID(MF_MT_SPATIAL_AUDIO_DATA_PRESENT, 0x6842f6e7, 0xd43e, 0x4ebb, 0x9c, 0x9c, 0xc9, 0x6f, 0x41, 0x78, 0x48, 0x63); DEFINE_GUID(MF_MT_AAC_PAYLOAD_TYPE, 0xbfbabe79, 0x7434, 0x4d1c, 0x94, 0xf0, 0x72, 0xa3, 0xb9, 0xe1, 0x71, 0x88); DEFINE_GUID(MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION, 0x7632f0e6, 0x9538, 0x4d61, 0xac, 0xda, 0xea, 0x29, 0xc8, 0xc1, 0x44, 0x56); -- 2.25.1

1 0