path: root/packages/mplayer/mplayer-1.0pre7/mplayer-w100_1.0pre3.1.modified.diff

diff -ruN MPlayer-1.0pre3/Makefile MPlayer-1.0pre3.custom/Makefile
--- MPlayer-1.0pre3.orig/Makefile    Tue Dec  9 06:33:31 2003
+++ MPlayer-1.0pre3/Makefile     Thu Dec 11 16:18:27 2003
@@ -17,7 +17,7 @@

 # These subdirectories require installation due to binaries within them.
 ifeq ($(VIDIX),yes)
-SUBDIRS += libdha vidix
+SUBDIRS += vidix
 DO_MAKE = @ for i in $(SUBDIRS); do $(MAKE) -C $$i $@; done
 endif

@@ -45,7 +45,7 @@
 PARTS += libfaad2
 endif
 ifeq ($(VIDIX),yes)
-PARTS += libdha vidix
+PARTS += vidix
 endif
 ifeq ($(FAME),yes)
 PARTS += libfame
@@ -81,7 +81,7 @@
 COMMON_DEPS += libfaad2/libfaad2.a
 endif
 ifeq ($(VIDIX),yes)
-COMMON_DEPS += libdha/libdha.so vidix/libvidix.a
+COMMON_DEPS += vidix/libvidix.a
 endif
 ifeq ($(FAME),yes)
 COMMON_DEPS += libfame/libfame.a
diff -ruN MPlayer-1.0pre3.orig/configure MPlayer-1.0pre3/configure
--- MPlayer-1.0pre3.orig/configure	Tue Dec  9 06:33:31 2003
+++ MPlayer-1.0pre3/configure	Thu Dec 11 17:29:38 2003
@@ -2151,7 +2151,7 @@
 #include <sys/types.h>
 int main(void) { printf("%d\n", sizeof(size_t)*8); return 0; }
 EOF
-cc_check && _wordsize=`$TMPO` && _mp_wordsize="#define MP_WORDSIZE $_wordsize"
+cc_check && _wordsize="32" && _mp_wordsize="#define MP_WORDSIZE $_wordsize"
 echores "$_wordsize"
 
 
@@ -2289,6 +2289,8 @@
 EOF
 if mingw32 ; then
   _ld_pthread=''
+elif true ; then
+  _ld_pthread='-lpthread'
 elif ( cc_check && $TMPO ) ; then              # QNX
   _ld_pthread=''
 elif ( cc_check -lpthread && $TMPO ) ; then
diff -ruN MPlayer-1.0pre3.orig/vidix/drivers/Makefile MPlayer-1.0pre3/vidix/drivers/Makefile
--- MPlayer-1.0pre3.orig/vidix/drivers/Makefile	Thu Oct 23 01:45:33 2003
+++ MPlayer-1.0pre3/vidix/drivers/Makefile	Thu Dec 11 17:13:01 2003
@@ -124,6 +131,12 @@
 
 $(SIS_VID):     $(SIS_OBJS)
 	$(CC) -shared $(SIS_OBJS) $(SIS_LIBS) -Wl,-soname,$(SIS_VID) -o $(SIS_VID) 
+
+$(W100_OBJS):    $(W100_SRCS)
+	$(CC) -c $(W100_CFLAGS) -o $@ $<
+
+$(W100_VID):     $(W100_OBJS)
+	$(CC) -shared $(W100_OBJS) $(W100_LIBS) -Wl,-soname,$(W100_VID) -o $(W100_VID)
 
 clean:
 	rm -f *.o *.so *~
diff -ruN MPlayer-1.0pre3.orig/vidix/drivers/w100_vid.c MPlayer-1.0pre3/vidix/drivers/w100_vid.c
--- MPlayer-1.0pre3.orig/vidix/drivers/w100_vid.c	Thu Jan  1 09:00:00 1970
+++ MPlayer-1.0pre3/vidix/drivers/w100_vid.c	Thu Dec 11 16:24:01 2003
@@ -0,0 +1,375 @@
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+#include <unistd.h>
+
+#include "../vidix.h"
+#include "../fourcc.h"
+#include "../../config.h"
+#include "aticore.h"
+
+#define UNUSED(v) ((void)(v))
+
+static uint16_t st_overlayHandle;
+
+static vidix_capability_t w100_cap =
+{
+    "ATI W100 driver",
+    "AGAWA Koji <kaoru-K@self-core.org>",
+    TYPE_OUTPUT,
+    { 0, 0, 0, 0 },                     /* reserved */
+    480,                                /* max width */
+    640,                                /* max height */
+    4,                                  /* min width */
+    4,                                  /* min height */
+    -1,                                 /* max framerate */
+    FLAG_EQUALIZER,                     /* flags */
+    0x1002,                             /* VENDOR_ATI(libdha/pci_vendors.h) */
+    -1,                                 /* device id */
+    { 0, 0, 0, 0 }                      /* reserved */
+};
+
+unsigned int vixGetVersion(void)
+{
+    return VIDIX_VERSION;
+}
+
+int vixProbe(int verbose, int force)
+{
+    UNUSED(verbose);
+    UNUSED(force);
+    return 0;
+}
+
+int vixInit(void)
+{
+    if (AtiCore_ProcessAttach()) {
+        if (AtiCore_AllocOverlay(&st_overlayHandle))
+            return 0;
+    }
+
+    return ENOSYS;
+}
+
+void vixDestroy(void)
+{
+    AtiCore_SetOverlayOnOff(st_overlayHandle, 0);
+    AtiCore_ReleaseOverlay(st_overlayHandle);
+    AtiCore_ProcessDetach();
+}
+
+int vixGetCapability(vidix_capability_t *to)
+{
+    memcpy(to, &w100_cap, sizeof(vidix_capability_t));
+    return 0;
+}
+
+static int is_supported_fourcc(uint32_t fourcc)
+{
+    switch(fourcc) {
+    case IMGFMT_YV12:
+        return 1;
+    default:
+        return 0;
+    }
+}
+
+int vixQueryFourcc(vidix_fourcc_t *to)
+{
+    if (is_supported_fourcc(to->fourcc)) {
+        to->depth = VID_DEPTH_1BPP | VID_DEPTH_2BPP |
+            VID_DEPTH_4BPP | VID_DEPTH_8BPP |
+            VID_DEPTH_12BPP| VID_DEPTH_15BPP|
+            VID_DEPTH_16BPP| VID_DEPTH_24BPP|
+            VID_DEPTH_32BPP;
+        to->flags = VID_CAP_EXPAND | VID_CAP_SHRINK;
+/*         to->flags = VID_CAP_EXPAND | VID_CAP_SHRINK | VID_CAP_COLORKEY; */
+        return 0;
+    } else
+        to->depth = to->flags = 0;
+
+    return ENOSYS;
+}
+
+int vixGetGrKeys(vidix_grkey_t *grkey)
+{
+    UNUSED(grkey);
+    return 0;
+}
+
+int vixSetGrKeys(const vidix_grkey_t *grkey)
+{
+    UNUSED(grkey);
+    return 0;
+}
+
+static vidix_video_eq_t st_equal =
+{
+    VEQ_CAP_BRIGHTNESS,
+    0, 0, 0, 0, 0, 0, 0, 0
+};
+
+int vixPlaybackGetEq(vidix_video_eq_t * eq)
+{
+    memcpy(eq, &st_equal, sizeof(st_equal));
+    return 0;
+}
+
+int vixPlaybackSetEq(const vidix_video_eq_t * eq)
+{
+    int br;
+
+    if (eq->cap & VEQ_CAP_BRIGHTNESS)
+        st_equal.brightness = eq->brightness;
+    if (eq->cap & VEQ_CAP_CONTRAST)
+        st_equal.contrast = eq->contrast;
+    if (eq->cap & VEQ_CAP_SATURATION)
+        st_equal.saturation = eq->saturation;
+    if (eq->cap & VEQ_CAP_HUE)
+        st_equal.hue = eq->hue;
+    if (eq->cap & VEQ_CAP_RGB_INTENSITY) {
+        st_equal.red_intensity   = eq->red_intensity;
+        st_equal.green_intensity = eq->green_intensity;
+        st_equal.blue_intensity  = eq->blue_intensity;
+    }
+    st_equal.flags = eq->flags;
+
+    br = (st_equal.brightness + 1000) * 127 / 2000;
+    if (br < 0)
+        br = 0;
+    if (br > 127)
+        br = 127;
+    if (br > 64)
+        br -= 64;
+    else
+        br += 64;
+
+    AtiCore_SetDisplayBrightness(br);
+
+    return 0;
+}
+
+static uint32_t st_frameOffsets[VID_PLAY_MAXFRAMES];
+static vidix_playback_t st_playbackInfo;
+static ATI_OVERLAYPROP st_overlayProp;
+
+int vixConfigPlayback(vidix_playback_t *info)
+{
+    int src_w, src_h;
+    int drw_w, drw_h;
+    int y_pitch, uv_pitch;
+    int i, ret, newNumFrames;
+    ATI_CLIPRECT clipRect;
+    uint32_t base;
+    uint32_t internalVramSize, internalVramAddr;
+    uint32_t externalVramSize, externalVramAddr;
+    int useExternalVram = 0;
+
+    if (!is_supported_fourcc(info->fourcc))
+        return -1;
+
+    src_w = info->src.w;
+    src_h = info->src.h;
+    drw_w = info->dest.w;
+    drw_h = info->dest.h;
+
+    switch (info->fourcc) {
+    case IMGFMT_YV12:
+        y_pitch = (src_w + 15) & ~15;
+        uv_pitch = ((src_w / 2) + 7) & ~7;
+        info->offset.y = 0;
+        info->offset.v = y_pitch * src_h;
+        info->offset.u = info->offset.v + uv_pitch * (src_h / 2);
+        info->frame_size = y_pitch * src_h + 2 * uv_pitch * (src_h / 2);
+        break;
+    default:
+        return -1;
+    }
+/*     fprintf(stderr, "w100_vid: num_frames:%d\n", info->num_frames); */
+/*     fprintf(stderr, "w100_vid: y_pitch:%d\n", y_pitch); */
+
+/*     fprintf(stderr, "w100_vid: struct info {\n"); */
+/*     fprintf(stderr, "w100_vid:   src.x:%d. src.y:%d. src.w:%d, src.h:%d,\n", */
+/*             info->src.x, info->src.y, info->src.w, info->src.h); */
+/*     fprintf(stderr, "w100_vid:   dest.x:%d. dest.y:%d. dest.w:%d, dest.h:%d,\n", */
+/*             info->dest.x, info->dest.y, info->dest.w, info->dest.h); */
+/*     fprintf(stderr, "w100_vid:   offset.y:%d, offset.v:%d offset.y:%d\n", */
+/*             info->offset.y, info->offset.v, info->offset.u); */
+/*     fprintf(stderr, "w100_vid:   frame_size:%d,\n", info->frame_size); */
+
+    GetAvailableVideoMem(&internalVramSize, &externalVramSize);
+    AtiCore_SetupMemoryTransfer(0, &internalVramAddr);
+    AtiCore_TerminateMemoryTransfer();
+    AtiCore_SetupMemoryTransfer(0xF000000, &externalVramAddr);
+    AtiCore_TerminateMemoryTransfer();
+
+/*     info->num_frames = 1; */
+    useExternalVram =  (getenv("MPLAYER_W100_USEEXTVRAM") ? 1 : 0);
+
+    if (useExternalVram) {
+        /* $B%U%l!<%`%P%C%U%!$H$7$FMxMQ$5$l$F$$$kItJ,$O;H$o$J$$(B */
+        base = 640 * 480 * 2;
+        newNumFrames = (externalVramSize - (640 * 480 * 2))
+            / info->frame_size;
+
+        /* FIXME: $B30It(B VRAM $B$K%*!<%P%l%$$r3NJ]$9$k$H!"(BVGA/QVGA $BLd$o$:(B
+         $BI=<($,GH>u$KMp$l$k!#(B @SL-C700/C750 */
+    } else {
+        /* $B%U%l!<%`%P%C%U%!It$b;H$o$J$$$H!"(BVRAM $BMFNL$,B-$j$J$$(B */
+/*         base = 320 * 240 * 2; */
+        base = 320 * 4 * 2;
+        memset((void *)internalVramAddr, 0x00, 320 * 4 * 2);
+        newNumFrames = internalVramSize / info->frame_size;
+    }
+
+    if (newNumFrames > info->num_frames)
+        newNumFrames = info->num_frames;
+    if (newNumFrames > VID_PLAY_MAXFRAMES)
+        newNumFrames = VID_PLAY_MAXFRAMES;
+    info->num_frames = newNumFrames;
+
+    info->dga_addr =
+        (void *)(useExternalVram ? externalVramAddr : internalVramAddr);
+/*     fprintf(stderr, "w100_vid:   num_frames:%d,\n", info->num_frames); */
+
+    info->dest.pitch.y = 16;
+    info->dest.pitch.u = 16;
+    info->dest.pitch.v = 16;
+
+/*     fprintf(stderr, "w100_vid: }\n"); */
+/*     fprintf(stderr, "w100_vid: base:%d\n", base); */
+
+    for (i = 0; i < info->num_frames; ++i) {
+        info->offsets[i] = base + info->frame_size * i;
+        st_frameOffsets[i] = info->offsets[i]
+            + (useExternalVram ? 0xF000000 : 0);
+    }
+
+    st_overlayProp.lpSrcBitmap = (void *)st_frameOffsets[0];
+    st_overlayProp.XCoord = 0;
+    st_overlayProp.YCoord = 0;
+    st_overlayProp.SrcPitch = y_pitch;
+    st_overlayProp.SrcHeight = src_h;
+    st_overlayProp.OverlayWidth = y_pitch;
+    st_overlayProp.OverlayHeight = src_h;
+    st_overlayProp.lpOverlayKey = 0;
+    st_overlayProp.OverlayFormat = OVLTYPE_YUV420;
+
+    ret = AtiCore_SetupOverlay(st_overlayHandle, &st_overlayProp);
+/*     printf("w100_vid: AtiCore_SetupOverlay: ret=%d\n", ret); */
+
+    clipRect.X_Top_Left = 0;
+    clipRect.Y_Top_Left = 0;
+    clipRect.X_Bottom_Right = st_overlayProp.SrcPitch;
+    clipRect.Y_Bottom_Right = st_overlayProp.SrcHeight;
+    AtiCore_SetDstClippingRect(&clipRect);
+    clipRect.X_Bottom_Right = info->src.w;
+    clipRect.Y_Bottom_Right = info->src.h;
+    AtiCore_SetSrcClippingRect(&clipRect);
+
+/*     AtiCore_SetOverlayPos(st_overlayHandle, info->dest.x, info->dest.y); */
+    AtiCore_SetOverlayPos(st_overlayHandle, 4, 0);
+
+    AtiCore_SetRopOperation(ROP3_SRCCOPY);
+    AtiCore_SetDstType(DSTTYPE_8BPP);
+    AtiCore_SetSrcType(SRCTYPE_EQU_DST);
+
+    vixPlaybackSetEq(&st_equal);
+
+    memcpy(&st_playbackInfo, info, sizeof(*info));
+
+/*     fprintf(stderr, "w100_vid: ---- vixConfigPlayback complete.\n"); */
+
+    return 0;
+}
+
+int vixPlaybackOn(void)
+{
+    AtiCore_SetOverlayOnOff(st_overlayHandle, 1);
+
+    return 0;
+}
+
+int vixPlaybackOff(void)
+{
+    AtiCore_SetOverlayOnOff(st_overlayHandle, 0);
+
+    return 0;
+}
+
+int vixPlaybackFrameSelect(unsigned int frame)
+{
+    st_overlayProp.lpSrcBitmap = (void *)st_frameOffsets[frame];
+    AtiCore_SetupOverlay(st_overlayHandle, &st_overlayProp);
+
+#if 0
+    ATI_STRETCH stretchOptions;
+    ATI_POINT dpPoint;
+    ATI_RECT srcRect, dstRect;
+    int ret;
+
+/*     fprintf(stderr, "w100_vid: vixPlaybackFrameSelect(frame=%d)\n", frame); */
+/*     fprintf(stderr, "w100_vid:   dga_addr:0x%08x, offset:%d,\n", */
+/*             st_playbackInfo.dga_addr, st_frameOffsets[frame]); */
+
+    stretchOptions.Count = 1;
+    stretchOptions.ScaleXFactor = 4;
+    stretchOptions.ScaleYFactor = 4;
+    stretchOptions.BlendOn = 0;
+    stretchOptions.dummy1 = 0;
+
+    dpPoint.XCoord = 0;
+    dpPoint.YCoord = 0;
+
+    srcRect.XCoord = st_playbackInfo.src.x;
+    srcRect.YCoord = st_playbackInfo.src.y;
+    srcRect.Width = st_playbackInfo.src.w;
+    srcRect.Height = st_playbackInfo.src.h;
+    fprintf(stderr, "%d, %d, %d, %d\n", srcRect.XCoord, srcRect.YCoord,
+            srcRect.Width, srcRect.Height);
+
+    dstRect.XCoord = 0;
+    dstRect.YCoord = 0;
+    dstRect.Width = 432;//st_playbackInfo.src.w;
+    dstRect.Height = 592;//st_playbackInfo.src.h;
+
+#if 1
+    while (AtiCore_WaitComplete(100) != 1)
+        ;
+
+	AtiCore_SetRopOperation( ROP3_SRCCOPY );
+	AtiCore_SetDstType( DSTTYPE_8BPP );
+	AtiCore_SetSrcType( SRCTYPE_EQU_DST );
+
+    ret = AtiCore_SetSrcPitchOffset(st_playbackInfo.src.w,
+                                    st_frameOffsets[frame]);
+    fprintf(stderr, "AtiCore_SetSrcPitchOffset(%d, %x) %d\n",
+            st_playbackInfo.src.w, st_frameOffsets[frame], ret);
+    ret = AtiCore_SetDstPitchOffset(432, 0);
+/*     printf("AtiCore_SetDstPitchOffset: ret=%d\n", ret); */
+
+/*     ret = AtiCore_BitBltFilpRotate(0, &srcRect, &dstRect); */
+    ret = AtiCore_StretchBlt(&stretchOptions, &dpPoint, &srcRect);
+    fprintf(stderr, "AtiCore_StretchBlt: ret=%d\n", ret);
+
+#else
+    {
+        int y, srcOffset = 0, dstOffset = 0;
+        fprintf(stderr, "%d %d %d\n", st_playbackInfo.src.h,
+                st_playbackInfo.src.w, 0);
+        for (y = 0; y < st_playbackInfo.src.h; ++y) {
+            memcpy(
+                0xF1100000 + dstOffset,
+                st_playbackInfo.dga_addr + st_playbackInfo.offsets[frame] + srcOffset,
+                st_playbackInfo.src.w);
+            srcOffset += st_playbackInfo.src.w;
+            dstOffset += 432;
+        }
+    }
+#endif
+#endif
+
+    return 0;
+}