Remove win32/qt/xanim/real binary codecs loading

Remove the win32 loader - the win32 emulation layer, as well as the
code for using DirectShow/DMO/VFW codecs. Remove loading of xanim,
QuickTime, and RealMedia codecs.

The win32 emulation layer is based on a very old version of wine.
Apparently, wine code was copied and hacked until it was somehow able
to load a limited collection of binary codecs. It poked around in the
code segment of some known binary codecs to disable unsupported win32
API calls to make them work. Example from module.c:

    for (i=0;i<5;i++)  RVA(0x19e842)[i]=0x90; // make_new_region ?
    for (i=0;i<28;i++) RVA(0x19e86d)[i]=0x90; // call__call_CreateCompatibleDC ?
    for (i=0;i<5;i++)  RVA(0x19e898)[i]=0x90; // jmp_to_call_loadbitmap ?
    for (i=0;i<9;i++)  RVA(0x19e8ac)[i]=0x90; // call__calls_OLE_shit ?
    for (i=0;i<106;i++) RVA(0x261b10)[i]=0x90; // disable threads

Just to show how utterly insane this code is. You wouldn't want even
your worst enemy to have to maintain this. In fact, it seems nobody
made major changes to this code ever since it was committed.

Most formats can be decoded by libavcodecs these days, and the loader
couldn't be used on 64 bit platforms anyway. The same is (probably)
true for the other binary codecs.

General note about how support for win32 codecs could be added back:

It's not possible to replace the win32 loader code by using wine as
library, because modern wine can not be linked with native Linux
programs for certain reasons. It would be possible to to move DirectShow
video decoding into a separate process linked with wine, like the
CoreAVC-for-Linux patches do. There is also the mplayer-ww fork, which
uses the dshownative library to use DirectShow codecs on Windows.

1 files changed, 0 insertions, 531 deletions

diff --git a/loader/registry.c b/loader/registry.c
deleted file mode 100644
index b87c160e67..0000000000
--- a/loader/registry.c
+++ /dev/null
@@ -1,531 +0,0 @@
-/*
- * Modified for use with MPlayer, detailed changelog at
- * http://svn.mplayerhq.hu/mplayer/trunk/
- */
-
-#include "config.h"
-#include "debug.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <pwd.h>
-#include <sys/types.h>
-
-#include "wine/winbase.h"
-#include "wine/winreg.h"
-#include "wine/winnt.h"
-#include "wine/winerror.h"
-
-#include "ext.h"
-#include "registry.h"
-
-#include "path.h"
-
-//#undef TRACE
-//#define TRACE printf
-
-// ...can be set before init_registry() call
-char* regpathname = NULL;
-
-static char* localregpathname = NULL;
-
-typedef struct reg_handle_s
-{
-	int handle;
-	char* name;
-	struct reg_handle_s* next;
-	struct reg_handle_s* prev;
-} reg_handle_t;
-
-struct reg_value
-{
-	int type;
-	char* name;
-	int len;
-	char* value;
-};
-
-static struct reg_value* regs = NULL;
-static int reg_size;
-static reg_handle_t* head = NULL;
-
-#define DIR -25
-
-static void create_registry(void);
-static void open_registry(void);
-static void save_registry(void);
-static void init_registry(void);
-
-
-static void create_registry(void){
-    if(regs)
-    {
-	printf("Logic error: create_registry() called with existing registry\n");
-	save_registry();
-	return;
-    }
-    regs=malloc(3*sizeof(struct reg_value));
-    regs[0].type=regs[1].type=DIR;
-    regs[0].name=malloc(5);
-    strcpy(regs[0].name, "HKLM");
-    regs[1].name=malloc(5);
-    strcpy(regs[1].name, "HKCU");
-    regs[0].value=regs[1].value=NULL;
-    regs[0].len=regs[1].len=0;
-    reg_size=2;
-    head = 0;
-    save_registry();
-}
-
-static void open_registry(void)
-{
-	int fd;
-	int i;
-	unsigned int len;
-	if(regs)
-	{
-		printf("Multiple open_registry(>\n");
-		return;
-	}
-	fd = open(localregpathname, O_RDONLY);
-	if (fd == -1)
-	{
-	    printf("Creating new registry\n");
-	    create_registry();
-	    return;
-	}
-	read(fd, &reg_size, 4);
-	regs=malloc(reg_size*sizeof(struct reg_value));
-	head = 0;
-	for(i=0; i<reg_size; i++)
-	{
-		read(fd,&regs[i].type,4);
-		read(fd,&len,4);
-		regs[i].name=malloc(len+1);
-		if(regs[i].name==0)
-		{
-			reg_size=i+1;
-			goto error;
-		}
-		read(fd, regs[i].name, len);
-		regs[i].name[len]=0;
-		read(fd,&regs[i].len,4);
-		regs[i].value=malloc(regs[i].len+1);
-		if(regs[i].value==0)
-		{
-		        free(regs[i].name);
-			reg_size=i+1;
-			goto error;
-		}
-		read(fd, regs[i].value, regs[i].len);
-		regs[i].value[regs[i].len]=0;
-	}
-error:
-	close(fd);
-	return;
-}
-
-static void save_registry(void)
-{
-	int fd, i;
-	if (!regs)
-		init_registry();
-	fd = open(localregpathname, O_WRONLY | O_CREAT, 00666);
-	if (fd == -1)
-	{
-	    printf("Failed to open registry file '%s' for writing.\n",
-		   localregpathname);
-	    return;
-	}
-	write(fd, &reg_size, 4);
-	for(i=0; i<reg_size; i++)
-	{
-	        unsigned len=strlen(regs[i].name);
-		write(fd, &regs[i].type, 4);
-		write(fd, &len, 4);
-		write(fd, regs[i].name, len);
-		write(fd, &regs[i].len, 4);
-		write(fd, regs[i].value, regs[i].len);
-	}
-	close(fd);
-}
-
-void free_registry(void)
-{
-    reg_handle_t* t = head;
-    while (t)
-    {
-	reg_handle_t* f = t;
-	free(t->name);
-	t=t->prev;
-        free(f);
-    }
-    head = 0;
-    if (regs)
-    {
-        int i;
-	for(i=0; i<reg_size; i++)
-	{
-	    free(regs[i].name);
-	    free(regs[i].value);
-	}
-	free(regs);
-	regs = 0;
-    }
-
-    if (localregpathname && localregpathname != regpathname)
-	free(localregpathname);
-    localregpathname = 0;
-}
-
-
-#if 0
-static reg_handle_t* find_handle_by_name(const char* name)
-{
-	reg_handle_t* t;
-	for(t=head; t; t=t->prev)
-	{
-		if(!strcmp(t->name, name))
-		{
-			return t;
-		}
-	}
-	return 0;
-}
-#endif
-static struct reg_value* find_value_by_name(const char* name)
-{
-	int i;
-	for(i=0; i<reg_size; i++)
-		if(!strcmp(regs[i].name, name))
-			return regs+i;
-	return 0;
-}
-static reg_handle_t* find_handle(int handle)
-{
-	reg_handle_t* t;
-	for(t=head; t; t=t->prev)
-	{
-		if(t->handle==handle)
-		{
-			return t;
-		}
-	}
-	return 0;
-}
-static int generate_handle(void)
-{
-	static unsigned int zz=249;
-	zz++;
-	while((zz==HKEY_LOCAL_MACHINE) || (zz==HKEY_CURRENT_USER))
-		zz++;
-	return zz;
-}
-
-static reg_handle_t* insert_handle(long handle, const char* name)
-{
-	reg_handle_t* t;
-	t=malloc(sizeof(reg_handle_t));
-	if(head==0)
-	{
-		t->prev=0;
-	}
-	else
-	{
-		head->next=t;
-		t->prev=head;
-	}
-	t->next=0;
-	t->name=malloc(strlen(name)+1);
-	strcpy(t->name, name);
-	t->handle=handle;
-	head=t;
-	return t;
-}
-static char* build_keyname(long key, const char* subkey)
-{
-	char* full_name;
-	reg_handle_t* t;
- 	if((t=find_handle(key))==0)
-	{
-		TRACE("Invalid key\n");
-		return NULL;
-	}
-	if(subkey==NULL)
-		subkey="<default>";
-	full_name=malloc(strlen(t->name)+strlen(subkey)+10);
-	strcpy(full_name, t->name);
-	strcat(full_name, "\\");
-	strcat(full_name, subkey);
-	return full_name;
-}
-static struct reg_value* insert_reg_value(int handle, const char* name, int type, const void* value, int len)
-{
-	struct reg_value* v;
-	char* fullname;
-	if((fullname=build_keyname(handle, name))==NULL)
-	{
-		TRACE("Invalid handle\n");
-		return NULL;
-	}
-
-	if((v=find_value_by_name(fullname))==0)
-	//creating new value in registry
-	{
-		if(regs==0)
-		    create_registry();
-		regs = realloc(regs, sizeof(struct reg_value) * (reg_size +1 ));
-		//regs=(struct reg_value*)my_realloc(regs, sizeof(struct reg_value)*(reg_size+1));
-		v=regs+reg_size;
-		reg_size++;
-	}
-	else
-	//replacing old one
-	{
-	    free(v->value);
-	    free(v->name);
-	}
-	TRACE("RegInsert '%s'  %p  v:%d  len:%d\n", name, value, *(int*)value, len);
-	v->type=type;
-	v->len=len;
-	v->value=malloc(len);
-	memcpy(v->value, value, len);
-	v->name=malloc(strlen(fullname)+1);
-	strcpy(v->name, fullname);
-        free(fullname);
-	save_registry();
-	return v;
-}
-
-static void init_registry(void)
-{
-	TRACE("Initializing registry\n");
-	// can't be free-ed - it's static and probably thread
-	// unsafe structure which is stored in glibc
-
-	regpathname = get_path("registry");
-	localregpathname = regpathname;
-
-	open_registry();
-	insert_handle(HKEY_LOCAL_MACHINE, "HKLM");
-	insert_handle(HKEY_CURRENT_USER, "HKCU");
-}
-
-#if 0
-static reg_handle_t* find_handle_2(long key, const char* subkey)
-{
-	char* full_name;
-	reg_handle_t* t;
- 	if((t=find_handle(key))==0)
-	{
-		TRACE("Invalid key\n");
-		return (reg_handle_t*)-1;
-	}
-	if(subkey==NULL)
-		return t;
-	full_name=malloc(strlen(t->name)+strlen(subkey)+10);
-	strcpy(full_name, t->name);
-	strcat(full_name, "\\");
-	strcat(full_name, subkey);
-	t=find_handle_by_name(full_name);
-	free(full_name);
-	return t;
-}
-#endif
-
-long __stdcall RegOpenKeyExA(long key, const char* subkey, long reserved, long access, int* newkey)
-{
-    char* full_name;
-    reg_handle_t* t;
-    TRACE("Opening key %s\n", subkey);
-
-    if(!regs)
-        init_registry()
-;
-/*	t=find_handle_2(key, subkey);
-
-	if(t==0)
-		return -1;
-
-	if(t==(reg_handle_t*)-1)
-		return -1;
-*/
-    full_name=build_keyname(key, subkey);
-    if(!full_name)
-        return -1;
-    TRACE("Opening key Fullname %s\n", full_name);
-    find_value_by_name(full_name);
-
-    t=insert_handle(generate_handle(), full_name);
-    *newkey=t->handle;
-    free(full_name);
-
-    return 0;
-}
-long __stdcall RegCloseKey(long key)
-{
-    reg_handle_t *handle;
-    if(key==(long)HKEY_LOCAL_MACHINE)
-	return 0;
-    if(key==(long)HKEY_CURRENT_USER)
-	return 0;
-    handle=find_handle(key);
-    if(handle==0)
-	return 0;
-    if(handle->prev)
-	handle->prev->next=handle->next;
-    if(handle->next)
-	handle->next->prev=handle->prev;
-    free(handle->name);
-    if(handle==head)
-	head=head->prev;
-    free(handle);
-    return 0;
-}
-
-long __stdcall RegQueryValueExA(long key, const char* value, int* reserved, int* type, int* data, int* count)
-{
-    struct reg_value* t;
-    char* c;
-    TRACE("Querying value %s\n", value);
-    if(!regs)
-	init_registry();
-
-    c=build_keyname(key, value);
-    if (!c)
-	return 1;
-    t=find_value_by_name(c);
-    if (t==0) {
-        // Hacks for CineForm.
-        if (strcmp(c, "HKCU\\SOFTWARE\\CineForm\\DecoderProperties\\Resolution") == 0) {
-            if (data)
-                *data = 1000;
-            if (type)
-                *type = REG_DWORD;
-            if (count)
-                *count = sizeof(DWORD);
-            free(c);
-            return ERROR_SUCCESS;
-        }
-        if (strcmp(c, "HKCU\\SOFTWARE\\CineForm\\DecoderProperties\\PixelFormats") == 0) {
-            if (data)
-                *data = 0xffff;
-            if (type)
-                *type = REG_DWORD;
-            if (count)
-                *count = sizeof(DWORD);
-            free(c);
-            return ERROR_SUCCESS;
-        }
-        free(c);
-        return ERROR_FILE_NOT_FOUND;
-    }
-    free(c);
-    if (type)
-	*type=t->type;
-    if (data)
-    {
-	memcpy(data, t->value, (t->len<*count)?t->len:*count);
-	TRACE("returning %d bytes: %d\n", t->len, *(int*)data);
-    }
-    if(*count<t->len)
-    {
-	*count=t->len;
-	return ERROR_MORE_DATA;
-    }
-    else
-    {
-	*count=t->len;
-    }
-    return ERROR_SUCCESS;
-}
-long __stdcall RegCreateKeyExA(long key, const char* name, long reserved,
-		     void* classs, long options, long security,
-		     void* sec_attr, int* newkey, int* status)
-{
-    reg_handle_t* t;
-    char* fullname;
-    struct reg_value* v;
-    //        TRACE("Creating/Opening key %s\n", name);
-    if(!regs)
-	init_registry();
-
-    fullname=build_keyname(key, name);
-    if (!fullname)
-	return 1;
-    TRACE("Creating/Opening key %s\n", fullname);
-    v=find_value_by_name(fullname);
-    if(v==0)
-    {
-	int qw=45708;
-	v=insert_reg_value(key, name, DIR, &qw, 4);
-	if (status) *status=REG_CREATED_NEW_KEY;
-	//		return 0;
-    }
-
-    t=insert_handle(generate_handle(), fullname);
-    *newkey=t->handle;
-    free(fullname);
-    return 0;
-}
-
-/*
-LONG RegEnumValue(
-  HKEY hKey,              // handle to key to query
-  DWORD dwIndex,          // index of value to query
-  LPTSTR lpValueName,     // address of buffer for value string
-  LPDWORD lpcbValueName,  // address for size of value buffer
-  LPDWORD lpReserved,     // reserved
-  LPDWORD lpType,         // address of buffer for type code
-  LPBYTE lpData,          // address of buffer for value data
-  LPDWORD lpcbData        // address for size of data buffer
-);
-*/
-
-long __stdcall RegEnumValueA(HKEY hkey, DWORD index, LPSTR value, LPDWORD val_count,
-		   LPDWORD reserved, LPDWORD type, LPBYTE data, LPDWORD count)
-{
-    // currenly just made to support MSZH & ZLIB
-    //printf("Reg Enum 0x%x %d  %s %d   data: %p %d  %d >%s<\n", hkey, index,
-    //       value, *val_count, data, *count, reg_size, data);
-    reg_handle_t* t = find_handle(hkey);
-    if (t && index < 10)
-    {
-	struct reg_value* v=find_value_by_name(t->name);
-	if (v)
-	{
-	    memcpy(data, v->value, (v->len < *count) ? v->len : *count);
-	    if(*count < v->len)
-		*count = v->len;
-	    if (type)
-		*type = v->type;
-	    //printf("Found handle  %s\n", v->name);
-	    return 0;
-	}
-    }
-    return ERROR_NO_MORE_ITEMS;
-}
-
-long __stdcall RegSetValueExA(long key, const char* name, long v1, long v2, const void* data, long size)
-{
-    char* c;
-    TRACE("Request to set value %s %d\n", name, *(const int*)data);
-    if(!regs)
-	init_registry();
-
-    c=build_keyname(key, name);
-    if(c==NULL)
-	return 1;
-    insert_reg_value(key, name, v2, data, size);
-    free(c);
-    return 0;
-}
-
-long __stdcall RegEnumKeyExA(HKEY hKey, DWORD dwIndex, LPSTR lpName, LPDWORD lpcbName,
-		   LPDWORD lpReserved, LPSTR lpClass, LPDWORD lpcbClass,
-		   LPFILETIME lpftLastWriteTime)
-{
-    return ERROR_NO_MORE_ITEMS;
-}