[MPlayer-dev-eng] [PATCH] Avisynth native demuxer

Gianluigi Tiesi mplayer at netfarm.it
Wed Jan 19 00:00:44 CET 2005


I've made an avisynth native demuxer, it works only on windows,
but it compiles on linux, since avisynth.dll is a c++ lib, it needs
exception handling, currently not implemented in the win32 loader/wine
stuff.
I'm adding also avs.diff (a patch to avisynth to avoid the first
exception) and avs_on_linux.diff, some mods on win32.c, to make mplayer
at least load the dll.

Since the demuxer needs the file and not the stream, I've changed:
demuxer=demux_open_stream(stream,file_format,audio_id,video_id,dvdsub_id,NULL);
in
demuxer=demux_open_stream(stream,file_format,audio_id,video_id,dvdsub_id,filename);

to make extension based detection work (this is included in the patch).

Best Regards


-- 
Gianluigi Tiesi <sherpya at netfarm.it>
EDP Project Leader
Netfarm S.r.l. - http://www.netfarm.it/
Free Software: http://oss.netfarm.it/
-------------- next part --------------
diff -NubBr -xCVS -xhelp_mp.h -xGui -x'*.a' -x'*.exe' -x'*.o' -xconfigure.log -xconfig.mak -x.cvsignore -x'*.ini' -xconfig.h -xcodecs.conf.h -xversion.h -x.depend main/libmpdemux/Makefile sherpya/libmpdemux/Makefile
--- main/libmpdemux/Makefile	2005-01-08 11:06:36.349604800 +0100
+++ sherpya/libmpdemux/Makefile	2005-01-17 05:36:53.765974400 +0100
@@ -21,6 +21,10 @@
 SRCS += dvb_tune.c
 endif
 
+ifneq ($(W32_LIB),)
+SRCS += demux_avs.c
+endif
+
 ifeq ($(MATROSKA),yes)
 SRCS += demux_mkv.c ebml.c
 endif
diff -NubBr -xCVS -xhelp_mp.h -xGui -x'*.a' -x'*.exe' -x'*.o' -xconfigure.log -xconfig.mak -x.cvsignore -x'*.ini' -xconfig.h -xcodecs.conf.h -xversion.h -x.depend main/libmpdemux/demux_avs.c sherpya/libmpdemux/demux_avs.c
--- main/libmpdemux/demux_avs.c	1970-01-01 01:00:00.000000000 +0100
+++ sherpya/libmpdemux/demux_avs.c	2005-01-17 07:14:09.467300800 +0100
@@ -0,0 +1,353 @@
+/*
+ * Demuxer for avisynth
+ * Copyright (c) 2005 Gianluigi Tiesi <sherpya at netfarm.it>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "config.h"
+#include "mp_msg.h"
+#include "help_mp.h"
+
+#include "stream.h"
+#include "demuxer.h"
+#include "stheader.h"
+
+#include "wine/windef.h"
+
+#ifdef WIN32_LOADER
+#include "ldt_keeper.h"
+#endif
+
+#include "demux_avs.h"
+
+HMODULE WINAPI LoadLibraryA(LPCSTR);
+FARPROC WINAPI GetProcAddress(HMODULE,LPCSTR);
+int     WINAPI FreeLibrary(HMODULE);
+
+typedef WINAPI AVS_ScriptEnvironment* (*imp_avs_create_script_environment)(int version);
+typedef WINAPI AVS_Value (*imp_avs_invoke)(AVS_ScriptEnvironment *, const char * name, AVS_Value args, const char** arg_names);
+typedef WINAPI const AVS_VideoInfo *(*imp_avs_get_video_info)(AVS_Clip *);
+typedef WINAPI AVS_Clip* (*imp_avs_take_clip)(AVS_Value, AVS_ScriptEnvironment *);
+typedef WINAPI AVS_VideoFrame* (*imp_avs_get_frame)(AVS_Clip *, int n);
+typedef WINAPI void (*imp_avs_release_video_frame)(AVS_VideoFrame *);
+
+#define Q(string) # string
+#define IMPORT_FUNC(x) \
+    AVS->x = ( imp_##x ) GetProcAddress(AVS->dll, Q(x)); \
+    if (!AVS->x) { mp_msg(MSGT_DEMUX,MSGL_V,"AVS: failed to load "Q(x)"()\n"); return 0; }
+
+typedef struct tagAVS
+{
+    AVS_ScriptEnvironment *avs_env;
+    AVS_Value handler;
+    AVS_Clip *clip;
+    const AVS_VideoInfo *video_info;
+    HMODULE dll;
+    int frameno;
+    int init;
+    
+    imp_avs_create_script_environment avs_create_script_environment;
+    imp_avs_invoke avs_invoke;
+    imp_avs_get_video_info avs_get_video_info;
+    imp_avs_take_clip avs_take_clip;
+    imp_avs_get_frame avs_get_frame;
+    imp_avs_release_video_frame avs_release_video_frame;
+} AVS_T;
+
+AVS_T *initAVS(const char *filename)
+{   
+    AVS_T *AVS = (AVS_T *) malloc (sizeof(AVS_T));
+    memset(AVS, 0, sizeof(AVS_T));
+
+#ifdef WIN32_LOADER
+    Setup_LDT_Keeper();
+#endif
+    
+    AVS->dll = LoadLibraryA("avisynth.dll");
+    if(!AVS->dll)
+    {
+        mp_msg(MSGT_DEMUX ,MSGL_V, "AVS: failed to load avisynth.dll\n");
+        return NULL;
+    }
+    
+    /* Dynamic import of needed stuff from avisynth.dll */
+    IMPORT_FUNC(avs_create_script_environment);
+    IMPORT_FUNC(avs_create_script_environment);
+    IMPORT_FUNC(avs_invoke);
+    IMPORT_FUNC(avs_get_video_info);
+    IMPORT_FUNC(avs_take_clip);
+    IMPORT_FUNC(avs_get_frame);
+    IMPORT_FUNC(avs_release_video_frame);
+    
+    AVS->avs_env = AVS->avs_create_script_environment(AVISYNTH_INTERFACE_VERSION);
+    if (!AVS->avs_env)
+    {
+        mp_msg(MSGT_DEMUX, MSGL_V, "AVS: avs_create_script_environment failed\n");
+        return NULL;
+    }
+    
+    AVS_Value arg0 = avs_new_value_string(filename);
+    AVS_Value args = avs_new_value_array(&arg0, 1);
+
+    AVS->handler = AVS->avs_invoke(AVS->avs_env, "Import", args, 0);
+    
+    if (avs_is_error(AVS->handler))
+    {
+        char buf[256];
+        sprintf(buf, "AVS: Avisynth error: %s\n", avs_as_string(AVS->handler));
+        mp_msg(MSGT_DEMUX, MSGL_V, buf);
+        return NULL;
+    }
+
+    if (!avs_is_clip(AVS->handler))
+    {
+        mp_msg(MSGT_DEMUX, MSGL_V, "AVS: Avisynth doesn't return a clip\n");
+        return NULL;
+    }
+    
+    return AVS;
+}
+
+/* Implement RGB MODES ?? */
+/*
+int get_mmioFOURCC(const AVS_VideoInfo *v)
+{
+    if (avs_is_rgb(v)) return mmioFOURCC(8, 'R', 'G', 'B');
+    if (avs_is_rgb24(v)) return mmioFOURCC(24, 'R', 'G', 'B');
+    if (avs_is_rgb32(v)) return mmioFOURCC(32, 'R', 'G', 'B');
+    if (avs_is_yv12(v)) return mmioFOURCC('Y', 'V', '1', '2');
+    //if (avs_is_yuy(v)) return mmioFOURCC('Y', 'U', 'Y', ' ');
+    if (avs_is_yuy2(v)) return mmioFOURCC('Y', 'U', 'Y', '2');    
+    return 0;
+}*/
+
+int demux_avs_fill_buffer(demuxer_t *demuxer)
+{
+    //static AVS_VideoFrame *curr_frame; // static no thread safe?
+    AVS_VideoFrame *curr_frame;
+    demux_packet_t *dp = NULL;
+    AVS_T *AVS = (AVS_T *) demuxer->priv;
+
+    demux_stream_t *d_video=demuxer->video;
+    sh_video_t *sh_video=d_video->sh;
+    
+    if (AVS->video_info->num_frames < AVS->frameno) return 0; // EOF
+    
+    curr_frame = AVS->avs_get_frame(AVS->clip, AVS->frameno);
+    if (!curr_frame)
+    {
+        mp_msg(MSGT_DEMUX, MSGL_V, "AVS: error getting frame -- EOF??\n");
+        return 0;
+    }
+        
+    dp = new_demux_packet(curr_frame->vfb->data_size);
+    dp->pts = curr_frame->vfb->sequence_number / sh_video->fps;
+    dp->flags=0;
+    
+    memcpy(dp->buffer, curr_frame->vfb->data + curr_frame->offset, curr_frame->vfb->data_size);
+    
+    AVS->frameno++;
+    
+    demuxer->video->dpos++;
+    ds_add_packet(demuxer->video, dp);
+    
+    AVS->avs_release_video_frame(curr_frame);
+    return 1;
+}
+
+int demux_open_avs(demuxer_t* demuxer)
+{
+    sh_video_t *sh_video = NULL;
+    sh_audio_t *sh_audio = NULL;
+    char buf[128];
+    int found = 0;
+    AVS_T *AVS = (AVS_T *) demuxer->priv;
+    
+    AVS->frameno = 0;
+
+    mp_msg(MSGT_DEMUX, MSGL_V, "AVS: demux_open_avs()\n");
+    demuxer->seekable = 1;
+
+    AVS->clip = AVS->avs_take_clip(AVS->handler, AVS->avs_env);
+    if(!AVS->clip)
+    {
+        mp_msg(MSGT_DEMUX, MSGL_V, "AVS: cannot take the clip\n");
+        return 0;
+    }
+
+    AVS->video_info = AVS->avs_get_video_info(AVS->clip);
+    if (!AVS->video_info)
+    {
+        mp_msg(MSGT_DEMUX, MSGL_V, "AVS: avs_get_video_info() call failed\n");
+        return 0;
+    }
+    
+    if (!avs_is_yv12(AVS->video_info))
+    {
+        AVS->handler = AVS->avs_invoke(AVS->avs_env, "ConvertToYV12", avs_new_value_array(&AVS->handler, 1), 0);
+        if (avs_is_error(AVS->handler))
+        {
+            sprintf(buf, "AVS: Cannot convert input video to YV12: %s\n", avs_as_string(AVS->handler));
+            mp_msg(MSGT_DEMUX, MSGL_V, buf);
+            return 0;
+        }
+        
+        AVS->clip = AVS->avs_take_clip(AVS->handler, AVS->avs_env);
+        
+        if(!AVS->clip)
+        {
+            mp_msg(MSGT_DEMUX, MSGL_V, "AVS: cannot take the clip\n");
+            return 0;
+        }
+
+        AVS->video_info = AVS->avs_get_video_info(AVS->clip);
+        if (!AVS->video_info)
+        {
+            mp_msg(MSGT_DEMUX, MSGL_V, "AVS: avs_get_video_info() call failed\n");
+            return 0;
+        }
+        AVS->video_info = AVS->avs_get_video_info(AVS->clip);
+    }
+    
+    // TODO check field-based ??
+
+    /* Video */  
+    if (avs_has_video(AVS->video_info))
+    {
+        found = 1;
+        sh_video = new_sh_video(demuxer, 0);
+        
+        demuxer->video->sh = sh_video;
+        sh_video->ds = demuxer->video;
+        
+        sh_video->disp_w = AVS->video_info->width;
+        sh_video->disp_h = AVS->video_info->height;
+        
+        //sh_video->format = get_mmioFOURCC(AVS.video_info);
+        sh_video->format = mmioFOURCC('Y', 'V', '1', '2');
+        sh_video->fps = (float) ((float) AVS->video_info->fps_numerator / (float) AVS->video_info->fps_denominator);
+        sh_video->frametime = 1.0 / sh_video->fps;
+        
+        sh_video->bih = malloc(sizeof(BITMAPINFOHEADER) + (256 * 4));
+        sh_video->bih->biCompression = sh_video->format;
+        sh_video->bih->biBitCount = avs_bits_per_pixel(AVS->video_info);
+        //sh_video->bih->biPlanes = 2;
+        
+        sh_video->bih->biWidth = AVS->video_info->width;
+        sh_video->bih->biHeight = AVS->video_info->height;
+
+        //sh_video->bih->biBitCount = avs_bits_per_pixel(AVS->video_info);
+    }
+
+    /* Audio */
+    if (avs_has_audio(AVS->video_info))
+    {
+        //found = 1;
+        sprintf(buf, "AVS: Clip has audio -> Channels = %d - Freq = %d\n", AVS->video_info->nchannels, AVS->video_info->audio_samples_per_second);
+        mp_msg(MSGT_DEMUX, MSGL_V, buf);
+
+        //sh_audio = new_sh_audio(demuxer, 0);
+        //demuxer->audio->sh = sh_audio;
+    }
+
+    AVS->init = 1;
+    return found;
+}
+
+int demux_avs_control(demuxer_t *demuxer, int cmd, void *arg)
+{   
+    demux_stream_t *d_video=demuxer->video;
+    sh_video_t *sh_video=d_video->sh;
+    AVS_T *AVS = (AVS_T *) demuxer->priv;
+
+    switch(cmd)
+    {
+        case DEMUXER_CTRL_GET_TIME_LENGTH:
+        {
+            if (!AVS->video_info->num_frames) return DEMUXER_CTRL_DONTKNOW;
+
+            *((unsigned long *)arg) = AVS->video_info->num_frames / sh_video->fps;
+            return DEMUXER_CTRL_OK;
+        }
+        case DEMUXER_CTRL_GET_PERCENT_POS:
+        {
+            if (!AVS->video_info->num_frames) return DEMUXER_CTRL_DONTKNOW;
+                
+            *((int *)arg) = (int) (AVS->frameno * 100 / AVS->video_info->num_frames);
+            return DEMUXER_CTRL_OK;
+        }
+    default:
+        return DEMUXER_CTRL_NOTIMPL;
+    }
+}
+
+void demux_close_avs(demuxer_t* demuxer)
+{
+    AVS_T *AVS = (AVS_T *) demuxer->priv;
+    
+    if (AVS)
+    {
+        if (AVS->dll)
+        {
+            mp_msg(MSGT_DEMUX, MSGL_V, "AVS: Unloading avisynth.dll\n");
+            FreeLibrary(AVS->dll);
+        }
+        free(AVS);
+    }
+}
+
+void demux_seek_avs(demuxer_t *demuxer, float rel_seek_secs,int flags)
+{
+    //char buf[128];
+    demux_stream_t *d_video=demuxer->video;
+    sh_video_t *sh_video=d_video->sh;
+    AVS_T *AVS = (AVS_T *) demuxer->priv;
+    int video_pos=AVS->frameno;
+    
+    //sprintf(buf, "AVS: seek rel_seek_secs = %f - flags = 0x%08x\n", rel_seek_secs, flags);
+    //mp_msg(MSGT_DEMUX, MSGL_V, buf);
+    
+    // seek absolute
+    if (flags&1) video_pos=0;
+
+    video_pos += (rel_seek_secs * sh_video->fps);
+    if (video_pos < 0) video_pos = 0;
+    if (video_pos > AVS->video_info->num_frames) video_pos = AVS->video_info->num_frames;
+        
+    AVS->frameno = video_pos;
+}
+
+int avs_check_file(demuxer_t *demuxer, const char *filename)
+{
+    mp_msg(MSGT_DEMUX, MSGL_V, "AVS: avs_check_file\n");
+    mp_msg(MSGT_DEMUX, MSGL_V, "AVS: attempting to open file\n");
+
+    if (!filename) return 0;
+    demuxer->priv = initAVS(filename);
+    
+    if (demuxer->priv)
+    {
+        mp_msg(MSGT_DEMUX,MSGL_V, "AVS: Init Ok\n");
+        return 1;
+    }
+    mp_msg(MSGT_DEMUX,MSGL_V, "AVS: Init failed\n");
+    return 0;
+}
diff -NubBr -xCVS -xhelp_mp.h -xGui -x'*.a' -x'*.exe' -x'*.o' -xconfigure.log -xconfig.mak -x.cvsignore -x'*.ini' -xconfig.h -xcodecs.conf.h -xversion.h -x.depend main/libmpdemux/demux_avs.h sherpya/libmpdemux/demux_avs.h
--- main/libmpdemux/demux_avs.h	1970-01-01 01:00:00.000000000 +0100
+++ sherpya/libmpdemux/demux_avs.h	2005-01-17 05:36:53.806032000 +0100
@@ -0,0 +1,152 @@
+/*
+ * Demuxer for avisynth
+ * Copyright (c) 2005 Gianluigi Tiesi <sherpya at netfarm.it>
+ *
+ * Avisynth C Interface Version 0.20
+ * Copyright 2003 Kevin Atkinson
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+enum { AVISYNTH_INTERFACE_VERSION = 2 };
+
+enum
+{
+  AVS_SAMPLE_INT8  = 1<<0,
+  AVS_SAMPLE_INT16 = 1<<1, 
+  AVS_SAMPLE_INT24 = 1<<2,
+  AVS_SAMPLE_INT32 = 1<<3,
+  AVS_SAMPLE_FLOAT = 1<<4
+};
+
+enum
+{
+  AVS_PLANAR_Y=1<<0,
+  AVS_PLANAR_U=1<<1,
+  AVS_PLANAR_V=1<<2,
+  AVS_PLANAR_ALIGNED=1<<3,
+  AVS_PLANAR_Y_ALIGNED=AVS_PLANAR_Y|AVS_PLANAR_ALIGNED,
+  AVS_PLANAR_U_ALIGNED=AVS_PLANAR_U|AVS_PLANAR_ALIGNED,
+  AVS_PLANAR_V_ALIGNED=AVS_PLANAR_V|AVS_PLANAR_ALIGNED
+};
+
+// Colorspace properties.
+enum
+{
+  AVS_CS_BGR = 1<<28,  
+  AVS_CS_YUV = 1<<29,
+  AVS_CS_INTERLEAVED = 1<<30,
+  AVS_CS_PLANAR = 1<<31
+};
+
+// Specific colorformats
+enum
+{
+  AVS_CS_UNKNOWN = 0,
+  AVS_CS_BGR24 = 1<<0 | AVS_CS_BGR | AVS_CS_INTERLEAVED,
+  AVS_CS_BGR32 = 1<<1 | AVS_CS_BGR | AVS_CS_INTERLEAVED,
+  AVS_CS_YUY2 = 1<<2 | AVS_CS_YUV | AVS_CS_INTERLEAVED,
+  AVS_CS_YV12 = 1<<3 | AVS_CS_YUV | AVS_CS_PLANAR,  // y-v-u, planar
+  AVS_CS_I420 = 1<<4 | AVS_CS_YUV | AVS_CS_PLANAR,  // y-u-v, planar
+  AVS_CS_IYUV = 1<<4 | AVS_CS_YUV | AVS_CS_PLANAR  // same as above
+};
+
+typedef struct AVS_Clip AVS_Clip;
+typedef struct AVS_ScriptEnvironment AVS_ScriptEnvironment;
+
+typedef struct AVS_Value AVS_Value;
+struct AVS_Value {
+  short type;  // 'a'rray, 'c'lip, 'b'ool, 'i'nt, 'f'loat, 's'tring, 'v'oid, or 'l'ong
+               // for some function e'rror
+  short array_size;
+  union {
+    void * clip; // do not use directly, use avs_take_clip
+    char boolean;
+    int integer;
+    float floating_pt;
+    const char * string;
+    const AVS_Value * array;
+  } d;
+};
+
+static const AVS_Value avs_void = {'v'};
+
+// AVS_VideoInfo is layed out identicly to VideoInfo
+typedef struct AVS_VideoInfo {
+  int width, height;    // width=0 means no video
+  unsigned fps_numerator, fps_denominator;
+  int num_frames;
+
+  int pixel_type;
+  
+  int audio_samples_per_second;   // 0 means no audio
+  int sample_type;
+  uint64_t num_audio_samples;
+  int nchannels;
+
+  // Imagetype properties
+
+  int image_type;
+} AVS_VideoInfo;
+
+typedef struct AVS_VideoFrameBuffer {
+  BYTE * data;
+  int data_size;
+  // sequence_number is incremented every time the buffer is changed, so
+  // that stale views can tell they're no longer valid.
+  long sequence_number;
+
+  long refcount;
+} AVS_VideoFrameBuffer;
+
+typedef struct AVS_VideoFrame {
+  int refcount;
+  AVS_VideoFrameBuffer * vfb;
+  int offset, pitch, row_size, height, offsetU, offsetV, pitchUV;  // U&V offsets are from top of picture.
+} AVS_VideoFrame;
+
+
+static __inline AVS_Value avs_new_value_string(const char * v0) 
+{ AVS_Value v; v.type = 's'; v.d.string = v0; return v; }
+
+static __inline AVS_Value avs_new_value_array(AVS_Value * v0, int size)
+{ AVS_Value v; v.type = 'a'; v.d.array = v0; v.array_size = size; return v; }
+
+
+static __inline int avs_is_error(AVS_Value v) { return v.type == 'e'; }
+static __inline int avs_is_clip(AVS_Value v) { return v.type == 'c'; }
+static __inline int avs_is_string(AVS_Value v) { return v.type == 's'; }
+static __inline int avs_has_video(const AVS_VideoInfo * p) { return (p->width!=0); }
+static __inline int avs_has_audio(const AVS_VideoInfo * p) { return (p->audio_samples_per_second!=0); }
+
+static __inline const char * avs_as_string(AVS_Value v) 
+{ return avs_is_error(v) || avs_is_string(v) ? v.d.string : 0; }
+
+static __inline int avs_is_yv12(const AVS_VideoInfo * p) 
+{ return ((p->pixel_type & AVS_CS_YV12) == AVS_CS_YV12)||((p->pixel_type & AVS_CS_I420) == AVS_CS_I420); }
+
+
+static __inline int avs_bits_per_pixel(const AVS_VideoInfo * p) 
+{ 
+  switch (p->pixel_type) {
+      case AVS_CS_BGR24: return 24;
+      case AVS_CS_BGR32: return 32;
+      case AVS_CS_YUY2:  return 16;
+      case AVS_CS_YV12:
+      case AVS_CS_I420:  return 12;
+      default:           return 0;
+    }
+}
diff -NubBr -xCVS -xhelp_mp.h -xGui -x'*.a' -x'*.exe' -x'*.o' -xconfigure.log -xconfig.mak -x.cvsignore -x'*.ini' -xconfig.h -xcodecs.conf.h -xversion.h -x.depend main/libmpdemux/demuxer.c sherpya/libmpdemux/demuxer.c
--- main/libmpdemux/demuxer.c	2005-01-16 02:02:51.853753600 +0100
+++ sherpya/libmpdemux/demuxer.c	2005-01-17 05:36:53.806032000 +0100
@@ -157,6 +157,9 @@
 extern void demux_close_ty(demuxer_t* demuxer);
 extern void demux_close_lavf(demuxer_t* demuxer);
 extern void demux_close_vqf(demuxer_t* demuxer);
+#ifdef USE_WIN32DLL
+extern void demux_close_avs(demuxer_t* demuxer);
+#endif
 
 
 #ifdef USE_TV
@@ -248,6 +251,10 @@
     case DEMUXER_TYPE_LAVF:
       demux_close_lavf(demuxer); break;
 #endif
+#ifdef USE_WIN32DLL
+    case DEMUXER_TYPE_AVS:
+      demux_close_avs(demuxer); break;
+#endif
     }
     // free streams:
     for(i=0;i<256;i++){
@@ -339,6 +346,9 @@
 extern int demux_lmlm4_fill_buffer(demuxer_t* demux);
 extern int demux_mkv_fill_buffer(demuxer_t *d);
 extern int demux_lavf_fill_buffer(demuxer_t *d);
+#ifdef USE_WIN32DLL
+extern int demux_avs_fill_buffer(demuxer_t *d);
+#endif
 
 int demux_fill_buffer(demuxer_t *demux,demux_stream_t *ds){
   // Note: parameter 'ds' can be NULL!
@@ -398,6 +408,9 @@
 #ifdef USE_LIBAVFORMAT
      case DEMUXER_TYPE_LAVF: return demux_lavf_fill_buffer(demux);
 #endif
+#ifdef USE_WIN32DLL
+    case DEMUXER_TYPE_AVS: return demux_avs_fill_buffer(demux);
+#endif
   }
   return 0;
 }
@@ -609,6 +622,10 @@
 extern int rawdv_check_file(demuxer_t *demuxer);
 #endif
 
+#ifdef USE_WIN32DLL
+int avs_check_file(demuxer_t *demuxer, const char *filename);
+#endif
+
 extern int vivo_check_file(demuxer_t *demuxer);
 extern void demux_open_vivo(demuxer_t *demuxer);
 extern int y4m_check_file(demuxer_t *demuxer);
@@ -646,6 +663,9 @@
 #endif
 extern int lavf_check_file(demuxer_t *demuxer);
 extern int demux_open_lavf(demuxer_t* demuxer);
+#ifdef USE_WIN32DLL
+extern int demux_open_avs(demuxer_t* demuxer);
+#endif
 
 extern demuxer_t* init_avi_with_ogg(demuxer_t* demuxer);
 #ifdef STREAMING_LIVE_DOT_COM
@@ -836,7 +856,7 @@
   file_format=demuxer_type_by_filename(filename);
   if(file_format!=DEMUXER_TYPE_UNKNOWN){
     // we like recursion :)
-    demuxer=demux_open_stream(stream,file_format,audio_id,video_id,dvdsub_id,NULL);
+    demuxer=demux_open_stream(stream,file_format,audio_id,video_id,dvdsub_id,filename);
     if(demuxer) return demuxer; // done!
     file_format=DEMUXER_TYPE_UNKNOWN; // continue fuzzy guessing...
     mp_msg(MSGT_DEMUXER,MSGL_V,"demuxer: continue fuzzy content-based format guessing...\n");
@@ -934,6 +954,19 @@
   }
 }
 #endif
+#ifdef USE_WIN32DLL
+//=============== Try to open as Avisynth file: =================
+if(file_format==DEMUXER_TYPE_UNKNOWN || file_format==DEMUXER_TYPE_AVS){
+  demuxer=new_demuxer(stream,DEMUXER_TYPE_AVS,audio_id,video_id,dvdsub_id);
+  if (avs_check_file(demuxer, filename)){
+      mp_msg(MSGT_DEMUXER,MSGL_INFO,MSGTR_Detected_XXX_FileFormat,"AVS");
+      file_format=DEMUXER_TYPE_AVS;
+  } else {
+      free_demuxer(demuxer);
+      demuxer = NULL;
+  }
+}
+#endif
 //=============== Try to open as PVA file: =================
 if(file_format == DEMUXER_TYPE_UNKNOWN || file_format==DEMUXER_TYPE_PVA){
 	demuxer=new_demuxer(stream,DEMUXER_TYPE_PVA,audio_id,video_id,dvdsub_id);
@@ -1384,6 +1417,12 @@
   break;
  }
 #endif
+#ifdef USE_WIN32DLL
+  case DEMUXER_TYPE_AVS: {
+  if (!demux_open_avs(demuxer)) return NULL;
+  break;
+ }
+#endif
 } // switch(file_format)
 pts_from_bps=0; // !!!
 if ((sh_video=demuxer->video->sh) && sh_video->bih)
@@ -1485,6 +1524,9 @@
 int demux_seek_pva(demuxer_t *demuxer,float rel_seek_secs,int flags);
 int demux_seek_ts(demuxer_t *demuxer,float rel_seek_secs,int flags);
 int demux_seek_lavf(demuxer_t *demuxer,float rel_seek_secs,int flags);
+#ifdef USE_WIN32DLL
+int demux_seek_avs(demuxer_t *demuxer,float rel_seek_secs,int flags);
+#endif
 
 #ifdef HAVE_LIBDV095
 int demux_seek_rawdv(demuxer_t *demuxer, float pts, int flags);
@@ -1602,6 +1644,10 @@
  #endif
  case DEMUXER_TYPE_VQF:
       demux_seek_vqf(demuxer,rel_seek_secs,flags); break;
+ #ifdef USE_WIN32DLL
+ case DEMUXER_TYPE_AVS:
+      demux_seek_avs(demuxer,rel_seek_secs,flags); break;
+ #endif
 
 } // switch(demuxer->file_format)
 
@@ -1669,6 +1715,9 @@
 extern int demux_real_control(demuxer_t *demuxer, int cmd, void *arg);
 extern int demux_lavf_control(demuxer_t *demuxer, int cmd, void *arg);
 extern int demux_mov_control(demuxer_t *demuxer, int cmd, void *arg);
+#ifdef USE_WIN32DLL
+extern int demux_avs_control(demuxer_t *demuxer, int cmd, void *arg);
+#endif
 
 int demux_control(demuxer_t *demuxer, int cmd, void *arg) {
     switch(demuxer->type) {
@@ -1707,7 +1756,10 @@
 #endif
         case DEMUXER_TYPE_MOV:
    	    return demux_mov_control(demuxer, cmd, arg);
-
+#ifdef USE_WIN32DLL
+        case DEMUXER_TYPE_AVS:
+   	    return demux_avs_control(demuxer, cmd, arg);
+#endif 
 	default:
 	    return DEMUXER_CTRL_NOTIMPL;
     }
diff -NubBr -xCVS -xhelp_mp.h -xGui -x'*.a' -x'*.exe' -x'*.o' -xconfigure.log -xconfig.mak -x.cvsignore -x'*.ini' -xconfig.h -xcodecs.conf.h -xversion.h -x.depend main/libmpdemux/demuxer.h sherpya/libmpdemux/demuxer.h
--- main/libmpdemux/demuxer.h	2005-01-08 11:06:37.200828800 +0100
+++ sherpya/libmpdemux/demuxer.h	2005-01-17 05:36:53.816046400 +0100
@@ -45,11 +45,12 @@
 #define DEMUXER_TYPE_LAVF 35
 #define DEMUXER_TYPE_NSV 36
 #define DEMUXER_TYPE_VQF 37
+#define DEMUXER_TYPE_AVS 38
 
 // This should always match the higest demuxer type number.
 // Unless you want to disallow users to force the demuxer to some types
 #define DEMUXER_TYPE_MIN 0
-#define DEMUXER_TYPE_MAX 37
+#define DEMUXER_TYPE_MAX 38
 
 #define DEMUXER_TYPE_DEMUXERS (1<<16)
 // A virtual demuxer type for the network code
diff -NubBr -xCVS -xhelp_mp.h -xGui -x'*.a' -x'*.exe' -x'*.o' -xconfigure.log -xconfig.mak -x.cvsignore -x'*.ini' -xconfig.h -xcodecs.conf.h -xversion.h -x.depend main/libmpdemux/extension.c sherpya/libmpdemux/extension.c
--- main/libmpdemux/extension.c	2004-12-04 23:59:35.000000000 +0100
+++ sherpya/libmpdemux/extension.c	2005-01-17 05:36:53.816046400 +0100
@@ -51,7 +51,8 @@
         { "vqf", DEMUXER_TYPE_XMMS },
         { "nsv", DEMUXER_TYPE_NSV },
         { "nsa", DEMUXER_TYPE_NSV },
-	{ "nut", DEMUXER_TYPE_LAVF }
+        { "nut", DEMUXER_TYPE_LAVF },
+        { "avs", DEMUXER_TYPE_AVS }
 };
 
 int demuxer_type_by_filename(char* filename){
-------------- next part --------------
Index: src/core/avisynth.cpp
===================================================================
RCS file: /cvsroot/avisynth2/avisynth/src/core/avisynth.cpp,v
retrieving revision 1.14
diff -u -r1.14 avisynth.cpp
--- src/core/avisynth.cpp	4 Jan 2005 09:06:08 -0000	1.14
+++ src/core/avisynth.cpp	17 Jan 2005 04:53:50 -0000
@@ -826,10 +826,10 @@
 const char* ScriptEnvironment::GetPluginDirectory()
 {
   char* plugin_dir;
-  try {
-    plugin_dir = (char*)GetVar("$PluginDir$").AsString();
-  }
-  catch (...) {
+  //try {
+  //  plugin_dir = (char*)GetVar("$PluginDir$").AsString();
+  //}
+  //catch (...) {
     HKEY AvisynthKey;
     if (RegOpenKeyEx(RegRootKey, RegAvisynthKey, 0, KEY_READ, &AvisynthKey))
       return 0;
@@ -847,7 +847,7 @@
       l--;
     plugin_dir[l]=0;
     SetGlobalVar("$PluginDir$", AVSValue(plugin_dir));
-  }
+  //}
   return plugin_dir;
 }
 
-------------- next part --------------
Index: loader/win32.c
===================================================================
RCS file: /cvsroot/mplayer/main/loader/win32.c,v
retrieving revision 1.97
diff -u -r1.97 win32.c
--- loader/win32.c	21 Dec 2004 23:26:45 -0000	1.97
+++ loader/win32.c	17 Jan 2005 04:40:37 -0000
@@ -63,6 +63,59 @@
 #include <kstat.h>
 #endif
 
+/* Sherpya */
+
+typedef void (*vtable_ptr)();
+
+/* exception object */
+typedef struct __exception
+{
+  const vtable_ptr *vtable;
+  char             *name;    /* Name of this exception, always a new copy for each object */
+  int               do_free; /* Whether to free 'name' in our dtor */
+} exception;
+
+/* type_info object, see cpp.c for inplementation */
+typedef struct __type_info
+{
+  const vtable_ptr *vtable;
+  char              *name;        /* Unmangled name, allocated lazily */
+  char               mangled[32]; /* Variable length, but we declare it large enough for static RTTI */
+} type_info;
+
+typedef void (*cxx_copy_ctor)(void);
+
+/* offsets for computing the this pointer */
+typedef struct
+{
+  int         this_offset;   /* offset of base class this pointer from start of object */
+  int         vbase_descr;   /* offset of virtual base class descriptor */
+  int         vbase_offset;  /* offset of this pointer offset in virtual base class descriptor */
+} this_ptr_offsets;
+
+typedef struct __cxx_type_info
+{
+  unsigned int flags;        /* flags (see CLASS_* flags below) */
+  const type_info *type_info;    /* C++ type info */
+  this_ptr_offsets offsets;      /* offsets for computing the this pointer */
+  size_t           size;         /* object size */
+  cxx_copy_ctor copy_ctor;    /* copy constructor */
+} cxx_type_info;
+
+typedef struct __cxx_type_info_table
+{
+  unsigned int count;     /* number of types */
+  const cxx_type_info *info[3];   /* variable length, we declare it large enough for static RTTI */
+} cxx_type_info_table;
+
+typedef struct __cxx_exception_type
+{
+  unsigned int flags;            /* TYPE_FLAG flags */
+  void                     (*destructor)();    /* exception object destructor */
+  /*cxx_exc_custom_handler*/ void*     custom_handler;   /* custom handler for this exception */
+  const cxx_type_info_table *type_info_table;  /* list of types for this exception object */
+} cxx_exception_type;
+
 #if HAVE_VSSCANF
 int vsscanf( const char *str, const char *format, va_list ap);
 #else
@@ -208,15 +261,15 @@
     }
 #endif
 #ifdef MPLAYER
-    if (verbose > 2)
-    {
+//    if (verbose > 2)
+//    {
 	va_list va;
 	
 	va_start(va, fmt);
 	vprintf(fmt, va);
-//	mp_dbg(MSGT_WIN32, MSGL_DBG3, fmt, va);
+	mp_dbg(MSGT_WIN32, MSGL_DBG3, fmt, va);
 	va_end(va);
-    }
+//    }
   fflush(stdout);
 #endif
 }
@@ -569,6 +622,11 @@
 #define	MODULE_HANDLE_msvcrt	((HMODULE)0x126)
 #define	MODULE_HANDLE_ole32	((HMODULE)0x127)
 #define	MODULE_HANDLE_winmm	((HMODULE)0x128)
+#define	MODULE_HANDLE_avifil32	((HMODULE)0x129)
+#define MODULE_HANDLE_msacm32	((HMODULE)0x12a)
+#define MODULE_HANDLE_gdi32	((HMODULE)0x12b)
+#define MODULE_HANDLE_msvcp60	((HMODULE)0x12c)
+#define MODULE_HANDLE_msvfw32	((HMODULE)0x12d)
 
 static HMODULE WINAPI expGetModuleHandleA(const char* name)
 {
@@ -1870,11 +1928,24 @@
 }
 static long WINAPI expRegQueryValueExA(long key, const char* value, int* reserved, int* type, int* data, int* count)
 {
-    long result=RegQueryValueExA(key, value, reserved, type, data, count);
-    dbgprintf("RegQueryValueExA(key 0x%x, value %s, reserved 0x%x, data 0x%x, count 0x%x)"
-	      " => 0x%x\n", key, value, reserved, data, count, result);
-    if(data && count)dbgprintf("  read %d bytes: '%s'\n", *count, data);
-    return result;
+//    long result=RegQueryValueExA(key, value, reserved, type, data, count);
+//    dbgprintf("RegQueryValueExA(key 0x%x, value %s, reserved 0x%x, data 0x%x, count 0x%x)"
+//	      " => 0x%x\n", key, value, reserved, data, count, result);
+//    if(data && count)dbgprintf("  read %d bytes: '%s'\n", *count, data);
+//    if (!strcasecmp("PluginDir2_5", value))
+    
+    if (data)
+    {
+       data[0] = 0;
+       strcat(data, ".");
+       *count = 1;
+       dbgprintf("Plugindir ----> %s\n", data);
+    }
+    else
+       *count = 1;
+		   
+    return 0;
+//    return result;
 }
 
 //from wine source dlls/advapi32/registry.c
@@ -2370,6 +2441,16 @@
 	return MODULE_HANDLE_ole32;
     if (strcasecmp(name, "winmm.dll") == 0 || strcasecmp(name, "winmm") == 0)
 	return MODULE_HANDLE_winmm;
+    if (strcasecmp(name, "avifil32.dll") == 0 || strcasecmp(name, "avifil32") == 0)
+	return MODULE_HANDLE_avifil32;
+    if (strcasecmp(name, "msacm32.dll") == 0 || strcasecmp(name, "msacm32") == 0)
+	return MODULE_HANDLE_msacm32;
+    if (strcasecmp(name, "gdi32.dll") == 0 || strcasecmp(name, "gdi32") == 0)
+	return MODULE_HANDLE_gdi32;
+    if (strcasecmp(name, "msvcp60.dll") == 0 || strcasecmp(name, "msvcp60") == 0)
+	return MODULE_HANDLE_msvcp60;
+    if (strcasecmp(name, "msvfw32.dll") == 0 || strcasecmp(name, "msvfw32") == 0)
+	return MODULE_HANDLE_msvfw32;
 
     result=LoadLibraryA(name);
     dbgprintf("Returned LoadLibraryA(0x%x='%s'), def_path=%s => 0x%x\n", name, name, def_path, result);
@@ -2412,10 +2493,20 @@
 	result=LookupExternalByName("ole32.dll", name); break;
     case MODULE_HANDLE_winmm:
 	result=LookupExternalByName("winmm.dll", name); break;
+    case MODULE_HANDLE_avifil32:
+	result=LookupExternalByName("avifil32.dll", name); break;
+    case MODULE_HANDLE_msacm32:
+	result=LookupExternalByName("msacm32.dll", name); break;
+    case MODULE_HANDLE_gdi32:
+	result=LookupExternalByName("gdi32.dll", name); break;
+    case MODULE_HANDLE_msvcp60:
+	result=LookupExternalByName("msvcp60.dll", name); break;
+    case MODULE_HANDLE_msvfw32:
+	result=LookupExternalByName("msvfw32.dll", name); break;
     default:
 	result=GetProcAddress(mod, name);
     }
-    dbgprintf("GetProcAddress(0x%x, '%s') => 0x%x\n", mod, name, result);
+//    dbgprintf("GetProcAddress(0x%x, '%s') => 0x%x\n", mod, name, result);
     return result;
 }
 
@@ -3749,7 +3840,7 @@
 static LONG WINAPI explstrcmpiA(const char* str1, const char* str2)
 {
     LONG result=strcasecmp(str1, str2);
-    dbgprintf("strcmpi(0x%x='%s', 0x%x='%s') => %d\n", str1, str1, str2, str2, result);
+//    dbgprintf("strcmpi(0x%x='%s', 0x%x='%s') => %d\n", str1, str1, str2, str2, result);
     return result;
 }
 
@@ -3783,7 +3874,6 @@
     return result;
 }
 
-
 static LONG WINAPI expInterlockedExchange(long *dest, long l)
 {
     long retval = *dest;
@@ -4206,7 +4296,7 @@
 static void* expmemmove(void* dest, void* src, int n)
 {
     void* result = memmove(dest, src, n);
-    dbgprintf("memmove(0x%x, 0x%x, %d) => %p\n", dest, src, n, result);
+//    dbgprintf("memmove(0x%x, 0x%x, %d) => %p\n", dest, src, n, result);
     return result;
 }
 static int expmemcmp(void* dest, void* src, int n)
@@ -4700,6 +4790,48 @@
     return 1;
 }
 
+static LONG WINAPI expAVIStreamBeginStreaming(/*PAVISTREAM*/ void* pavi, LONG lStart, LONG lEnd, LONG lRate)
+{
+    return 1;
+}
+
+static int expdummy(void *dummy)
+{
+    dbgprintf("dummy -> %p\n", dummy);
+    return 0;
+}
+
+static void expThrowException (exception *object, const cxx_exception_type *type)
+{
+    char buf[128];
+    char *seek = NULL;
+    char *name = type->type_info_table->info[0]->type_info->mangled;
+
+
+    /* Cheap undercoration */
+    name += 4;
+    seek = strstr(name, "@");
+    seek++;
+
+    buf[0]=0;
+    strcat(buf, seek);
+
+    seek = strstr(buf, "@");
+    *seek = 0;
+    strcat(buf, "::");
+    strcat(buf, name);
+    seek = strstr(buf, "@");
+    *seek = 0;
+    
+    dbgprintf("msvcrt: ThrowException: %s\n", buf);
+}
+
+static int expdummy1(void *dummy)
+{
+    dbgprintf("found-> %p\n", dummy);
+    return 0;
+}
+
 static double expfloor(double x)
 {
     dbgprintf("floor(%lf)\n", x);
@@ -4727,7 +4859,8 @@
 
 struct exports
 {
-    char name[64];
+//    char name[64];
+    char name[128];
     int id;
     void* func;
 };
@@ -4956,7 +5089,85 @@
     {"vfprintf",-1,(void*)&vfprintf},
 //    {"realloc",-1,(void*)&realloc},
     FF(realloc,-1)
-    {"puts",-1,(void*)&puts}
+    {"puts",-1,(void*)&puts},
+    /* Sherpya */
+/*
+    {"_onexit", -1, expdummy},
+    {"??1type_info@@UAE at XZ", -1, expdummy},
+    {"bsearch", -1, (void*)&bsearch},
+    {"qsort", -1, (void*)&qsort},
+    {"_filelength", -1, expdummy},
+    {"fread", -1, (void*)&fread},
+    {"??1exception@@UAE at XZ", -1, expdummy},
+    {"??0exception@@QAE at ABV0@@Z", -1, expdummy},
+    {"__CxxFrameHandler", -1, expdummy},
+    {"_CxxThrowException", -1, expThrowException},
+    {"_purecall", -1, expdummy},
+    {"sin", -1, (void*)&sin},
+    {"exp", -1, (void*)&exp},
+    {"sqrt", -1, (void*)&sqrt},
+    {"fabs", -1, (void*)&fabs},
+    {"_strlwr", -1, expdummy}, // TODO??
+    {"_strrev", -1, expdummy},
+    {"strncat", -1, (void*)&strncat},
+    {"strstr", -1, (void*)&strstr},
+    {"_findfirst", -1, expdummy},
+    {"strftime", -1, (void*)&strftime},
+    {"_itoa", -1, expdummy}, // TODO
+    {"strtod", -1, (void*)&strtod},
+    {"_strnicmp", -1, (void*)&strncasecmp},
+    {"_clearfp", -1, expdummy}, // ??
+    {"_control87", -1, expdummy}, // ??
+    {"_except_handler3", -1, expdummy},
+    {"strcspn", -1, expdummy}, // TODO
+    {"atan", -1, (void*)&atan},
+    {"fclose", -1, (void*)&fclose},
+    {"abort", -1, (void*)&abort},
+    {"atoi", -1, (void*)&atoi},
+    {"tolower", -1, (void*)&tolower},
+    {"fgetc", -1, (void*)&fgetc},
+    {"_errno", -1, expdummy}, // FIXME
+    {"isprint", -1, (void*)&isprint}
+    */
+
+    /* */
+    {"_onexit", -1, expdummy},
+    {"??1type_info@@UAE at XZ", -1, expdummy},
+    {"bsearch", -1, expdummy},
+    {"qsort", -1, expdummy},
+    {"_filelength", -1, expdummy},
+    {"fread", -1, expdummy},
+    {"??1exception@@UAE at XZ", -1, expdummy},
+    {"??0exception@@QAE at ABV0@@Z", -1, expdummy},
+    {"__CxxFrameHandler", -1, expdummy},
+    {"_CxxThrowException", -1, expThrowException},
+    {"_purecall", -1, expdummy},
+    {"sin", -1, expdummy},
+    {"exp", -1, expdummy},
+    {"sqrt", -1, expdummy},
+    {"fabs", -1, expdummy},
+    {"_strlwr", -1, expdummy}, // TODO??
+    {"_strrev", -1, expdummy},
+    {"strncat", -1, expdummy},
+    {"strstr", -1, expdummy},
+    {"_findfirst", -1, expdummy},
+    {"strftime", -1, expdummy},
+    {"_itoa", -1, expdummy}, // TODO
+    {"strtod", -1, expdummy},
+    {"_strnicmp", -1, expdummy},
+    {"_clearfp", -1, expdummy}, // ??
+    {"_control87", -1, expdummy}, // ??
+    {"_except_handler3", -1, expdummy},
+    {"strcspn", -1, expdummy}, // TODO
+    {"atan", -1, expdummy},
+    {"fclose", -1, expdummy},
+    {"abort", -1, expdummy},
+    {"atoi", -1, expdummy},
+    {"tolower", -1, expdummy},
+    {"fgetc", -1, expdummy},
+    {"_errno", -1, expdummy}, // FIXME
+    {"isprint", -1, expdummy}
+
 };
 struct exports exp_winmm[]={
     FF(GetDriverModuleHandle, -1)
@@ -5015,6 +5226,10 @@
 #endif
     FF(MessageBeep, -1)
     FF(DialogBoxParamA, -1)
+    /* Sherpya */
+    {"wvsprintfA", -1, (void*)&vsprintf},
+    {"FillRect", -1, expdummy}
+    
 };
 struct exports exp_advapi32[]={
     FF(RegCloseKey, -1)
@@ -5051,6 +5266,9 @@
     FF(CoTaskMemAlloc, -1)
     FF(CoTaskMemFree, -1)
     FF(StringFromGUID2, -1)
+    /* Sherpya */
+    {"CoUninitialize", -1, expdummy},
+    {"wvsprintfA", -1, (void*)&vsprintf}
 };
 // do we really need crtdll ???
 // msvcrt is the correct place probably...
@@ -5127,6 +5345,28 @@
 struct exports exp_comdlg32[]={
     FF(GetOpenFileNameA, -1)
 };
+/* Sherpya */
+struct exports exp_avifil32[]={
+    FF(AVIStreamBeginStreaming, -1)
+};
+
+struct exports exp_msacm32[]={
+};
+
+struct exports exp_msvcp60[]={
+    {"??0?$basic_ios at DU?$char_traits at D@std@@@std@@IAE at XZ", -1, expdummy},
+    {"??6?$basic_ostream at DU?$char_traits at D@std@@@std@@QAEAAV01 at H@Z", -1, expdummy},
+    {"??_7?$basic_ostringstream at DU?$char_traits at D@std@@V?$allocator at D@2@@std@@6B@", -1, expdummy},
+    {"??_8?$basic_ostringstream at DU?$char_traits at D@std@@V?$allocator at D@2@@std@@7B@", -1, expdummy},
+    {"?setw at std@@YA?AU?$_Smanip at H@1 at H@Z", -1, expdummy}
+};
+
+struct exports exp_msvfw32[]={
+    {"ICDecompress", -1, expdummy},
+    {"ICLocate", -1, expdummy},
+    {"ICClose", -1, expdummy},
+    {"ICOpen", -1, expdummy}
+};
 
 #define LL(X) \
     {#X".dll", sizeof(exp_##X)/sizeof(struct exports), exp_##X},
@@ -5152,6 +5392,11 @@
     LL(ddraw)
 #endif
     LL(comdlg32)
+    /* Sherpya */
+    LL(avifil32)
+    LL(msacm32)
+    LL(msvcp60)
+    LL(msvfw32)
 };
 
 static void ext_stubs(void)
@@ -5305,7 +5550,7 @@
 	printf("ERROR: name=0\n");
 	return (void*)ext_unknown;
     }
-    dbgprintf("External func %s:%s\n", library, name);
+//    dbgprintf("External func %s:%s\n", library, name);
     for(i=0; i<sizeof(libraries)/sizeof(struct libs); i++)
     {
 	if(strcasecmp(library, libraries[i].name))


More information about the MPlayer-dev-eng mailing list