RepoMirrors/mpv
1
0
Fork 0
mirror of https://github.com/mpv-player/mpv synced 2025-04-01 23:00:41 +00:00
Code Issues Releases Wiki Activity

Add Fullscreen, Ontop and OSD support

Browse Source 
git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@12297 b3059339-0415-0410-9bf9-f77b7e298cf2
This commit is contained in:
nplourde 2004-04-26 12:17:26 +00:00
parent e4e095dcfd
commit b2d2ccd206
1 changed files with 461 additions and 447 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

892
libvo/vo_quartz.c
View File

@ -1,31 +1,27 @@
/* /*
* vo_quartz.c vo_quartz.c
*
* Copyright (c) Nicolas Plourde - January 2004 by Nicolas Plourde <nicolasplourde@hotmail.com>
*
* MPlayer Mac OSX Quartz video out module. Copyright (c) Nicolas Plourde - April 2004
*
* TODO: -Fullscreen MPlayer Mac OSX Quartz video out module.
* -Better event handling
* todo: -YUV support.
* Note on performance: -Redo event handling.
* Right now i can play fullsize dvd video with -framedrop on my -Choose fullscreen display device.
* iBook G4 800mhz. YUV to RGB converstion will speed up thing alot. -Fullscreen antialiasing.
* Another thing is the slow fps when you maximize the window, I was -resize black bar without CGContext
* not expecting that. I will fix this a.s.a.p. Im new to Mac -rootwin
* programming so help is welcome. -non-blocking event
-(add sugestion here)
*/ */
//SYS //SYS
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <errno.h>
//OSX //OSX
#include <Carbon/Carbon.h> #include <Carbon/Carbon.h>
#include <QuickTime/QuickTime.h>
//MPLAYER //MPLAYER
#include "config.h" #include "config.h"
@ -38,492 +34,510 @@
#include "vo_quartz.h" #include "vo_quartz.h"
static vo_info_t info = { static vo_info_t info =
"MacOS X (Quartz)", {
"quartz", "Mac OSX (Quartz)",
"Nicolas Plourde <nicolasplourde@hotmail.com>", "quartz",
"" "Nicolas Plourde <nicolasplourde@hotmail.com>",
""
}; };
LIBVO_EXTERN (quartz) LIBVO_EXTERN(quartz)
static unsigned char *ImageData = NULL;
static uint32_t image_width; uint32_t image_width;
static uint32_t image_height; uint32_t image_height;
static uint32_t image_depth; uint32_t image_depth;
static uint32_t image_bytes; uint32_t image_bytes;
static uint32_t image_format; uint32_t image_format;
char *image_data;
static int int_pause = 0; extern int vo_ontop;
extern int vo_fs;
int screen_width, screen_height; int int_pause = 0;
WindowRef theWindow;
CGContextRef context;
CGRect bounds;
CGRect winBounds;
Rect contentRect;
CGImageRef image;
CGDataProviderRef dataProviderRef;
Ptr oldscreenstate;
RGBColor black = { 0, 0, 0 };
float winAlpha = 1; float winAlpha = 1;
int device_width, device_height;
WindowRef theWindow;
GWorldPtr imgGWorld;
Rect imgRect;
Rect dstRect;
Rect winRect;
CGContextRef context;
#include "../osdep/keycodes.h" #include "../osdep/keycodes.h"
extern void mplayer_put_key (int code); extern void mplayer_put_key(int code);
extern void vo_draw_text(int dxs,int dys,void (*draw_alpha)(int x0,int y0, int w,int h, unsigned char* src, unsigned char *srca, int stride));
//PROTOTYPE///////////////////////////////////////////////////////////////// //PROTOTYPE/////////////////////////////////////////////////////////////////
void resize_window (uint32_t width, uint32_t height); void window_resized();
static OSStatus MainWindowEventHandler (EventHandlerCallRef nextHandler, void window_ontop();
EventRef event, void *userData); void window_fullscreen();
static OSStatus MainKeyEventHandler (EventHandlerCallRef nextHandler,
EventRef event, void *userData);
static OSStatus MainWindowEventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData);
static OSStatus MainKeyboardEventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData);
static OSStatus MainMouseEventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData);
static void draw_alpha(int x0, int y0, int w, int h, unsigned char *src, unsigned char *srca, int stride)
{
vo_draw_alpha_rgb32(w,h,src,srca,stride,image_data+4*(y0*imgRect.right+x0),4*imgRect.right);
}
//default window event handler //default window event handler
static OSStatus static OSStatus MainWindowEventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData)
MainWindowEventHandler (EventHandlerCallRef nextHandler, EventRef event,
void *userData)
{ {
OSStatus err = noErr; OSStatus err = noErr;
WindowRef window; WindowRef window;
Rect rectPort = { 0, 0, 0, 0 }; Rect rectPort = {0,0,0,0};
OSStatus result = eventNotHandledErr; OSStatus result = eventNotHandledErr;
UInt32 class = GetEventClass (event); UInt32 class = GetEventClass (event);
UInt32 kind = GetEventKind (event); UInt32 kind = GetEventKind (event);
GetEventParameter (event, kEventParamDirectObject, typeWindowRef, NULL, GetEventParameter(event, kEventParamDirectObject, typeWindowRef, NULL, sizeof(WindowRef), NULL, &window);
sizeof (WindowRef), NULL, &window); if(window)
if (window) {
GetWindowPortBounds (window, &rectPort);
}
switch (kind)
{ {
GetWindowPortBounds (window, &rectPort); //close window
case kEventWindowClosed:
HideWindow(window);
mplayer_put_key(KEY_ESC);
break;
//resize window
case kEventWindowBoundsChanged:
window_resized();
flip_page();
break;
default:
err = eventNotHandledErr;
break;
} }
switch (kind) return err;
{
case kEventWindowActivated:
case kEventWindowDrawContent:
break;
case kEventWindowClosed:
HideWindow (window);
mplayer_put_key (KEY_ESC);
break;
case kEventWindowShown:
InvalWindowRect (window, &rectPort);
break;
case kEventWindowBoundsChanged:
resize_window (rectPort.right, rectPort.bottom);
break;
case kEventWindowZoomed:
resize_window (rectPort.right, rectPort.bottom);
break;
default:
err = eventNotHandledErr;
break;
}
return err;
} }
//keyboard event handler //keyboard event handler
static OSStatus static OSStatus MainKeyboardEventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData)
MainKeyEventHandler (EventHandlerCallRef nextHandler, EventRef event,
void *userData)
{ {
OSStatus err = noErr; OSStatus err = noErr;
UInt32 macKeyCode; UInt32 macKeyCode;
GetEventParameter (event, kEventParamKeyCode, typeUInt32, NULL, GetEventParameter(event, kEventParamKeyCode, typeUInt32, NULL, sizeof(macKeyCode), NULL, &macKeyCode);
sizeof (macKeyCode), NULL, &macKeyCode);
switch (GetEventKind (event)) switch (GetEventKind (event))
{ {
case kEventRawKeyDown: case kEventRawKeyDown:
{ {
switch (macKeyCode) switch(macKeyCode)
{ {
case QZ_RETURN: case QZ_RETURN: mplayer_put_key(KEY_ENTER);break;
mplayer_put_key (KEY_ENTER); case QZ_ESCAPE: mplayer_put_key(KEY_ESC);break;
break; case QZ_q: mplayer_put_key('q');break;
case QZ_ESCAPE: case QZ_F1: mplayer_put_key(KEY_F+1);break;
EndFullScreen (oldscreenstate, 0); case QZ_F2: mplayer_put_key(KEY_F+2);break;
QuitApplicationEventLoop (); case QZ_F3: mplayer_put_key(KEY_F+3);break;
mplayer_put_key (KEY_ESC); case QZ_F4: mplayer_put_key(KEY_F+4);break;
break; case QZ_F5: mplayer_put_key(KEY_F+5);break;
case QZ_q: case QZ_F6: mplayer_put_key(KEY_F+6);break;
mplayer_put_key ('q'); case QZ_F7: mplayer_put_key(KEY_F+7);break;
break; case QZ_F8: mplayer_put_key(KEY_F+8);break;
case QZ_F1: case QZ_F9: mplayer_put_key(KEY_F+9);break;
mplayer_put_key (KEY_F + 1); case QZ_F10: mplayer_put_key(KEY_F+10);break;
break; case QZ_F11: mplayer_put_key(KEY_F+11);break;
case QZ_F2: case QZ_F12: mplayer_put_key(KEY_F+12);break;
mplayer_put_key (KEY_F + 2); case QZ_o: mplayer_put_key('o');break;
break; case QZ_SPACE: mplayer_put_key(' ');break;
case QZ_F3: case QZ_p: mplayer_put_key('p');break;
mplayer_put_key (KEY_F + 3); //case QZ_7: mplayer_put_key(shift_key?'/':'7');
break; //case QZ_PLUS: mplayer_put_key(shift_key?'*':'+');
case QZ_F4: case QZ_KP_PLUS: mplayer_put_key('+');break;
mplayer_put_key (KEY_F + 4); case QZ_MINUS:
break; case QZ_KP_MINUS: mplayer_put_key('-');break;
case QZ_F5: case QZ_TAB: mplayer_put_key('\t');break;
mplayer_put_key (KEY_F + 5); case QZ_PAGEUP: mplayer_put_key(KEY_PAGE_UP);break;
break; case QZ_PAGEDOWN: mplayer_put_key(KEY_PAGE_DOWN);break;
case QZ_F6: case QZ_UP: mplayer_put_key(KEY_UP);break;
mplayer_put_key (KEY_F + 6); case QZ_DOWN: mplayer_put_key(KEY_DOWN);break;
break; case QZ_LEFT: mplayer_put_key(KEY_LEFT);break;
case QZ_F7: case QZ_RIGHT: mplayer_put_key(KEY_RIGHT);break;
mplayer_put_key (KEY_F + 7); //case QZ_LESS: mplayer_put_key(shift_key?'>':'<'); break;
break; //case QZ_GREATER: mplayer_put_key('>'); break;
case QZ_F8: //case QZ_ASTERISK:
mplayer_put_key (KEY_F + 8); case QZ_KP_MULTIPLY: mplayer_put_key('*'); break;
break; case QZ_SLASH:
case QZ_F9: case QZ_KP_DIVIDE: mplayer_put_key('/'); break;
mplayer_put_key (KEY_F + 9); case QZ_KP0: mplayer_put_key(KEY_KP0); break;
break; case QZ_KP1: mplayer_put_key(KEY_KP1); break;
case QZ_F10: case QZ_KP2: mplayer_put_key(KEY_KP2); break;
mplayer_put_key (KEY_F + 10); case QZ_KP3: mplayer_put_key(KEY_KP3); break;
break; case QZ_KP4: mplayer_put_key(KEY_KP4); break;
case QZ_F11: case QZ_KP5: mplayer_put_key(KEY_KP5); break;
mplayer_put_key (KEY_F + 11); case QZ_KP6: mplayer_put_key(KEY_KP6); break;
break; case QZ_KP7: mplayer_put_key(KEY_KP7); break;
case QZ_F12: case QZ_KP8: mplayer_put_key(KEY_KP8); break;
mplayer_put_key (KEY_F + 12); case QZ_KP9: mplayer_put_key(KEY_KP9); break;
break; case QZ_KP_PERIOD: mplayer_put_key(KEY_KPDEC); break;
case QZ_o: case QZ_KP_ENTER: mplayer_put_key(KEY_KPENTER); break;
mplayer_put_key ('o'); case QZ_LEFTBRACKET: SetWindowAlpha(theWindow, winAlpha-=0.05);break;
break; case QZ_RIGHTBRACKET: SetWindowAlpha(theWindow, winAlpha+=0.05);break;
case QZ_SPACE: case QZ_f: mplayer_put_key('f'); break;
mplayer_put_key (' '); case QZ_t: mplayer_put_key('T'); break;
break; default:
case QZ_p: break;
mplayer_put_key ('p'); }
break; }
//case QZ_7: mplayer_put_key(shift_key?'/':'7'); break;
//case QZ_PLUS: mplayer_put_key(shift_key?'*':'+'); default:
case QZ_KP_PLUS: err = eventNotHandledErr;
mplayer_put_key ('+'); break;
break;
case QZ_MINUS:
case QZ_KP_MINUS:
mplayer_put_key ('-');
break;
case QZ_TAB:
mplayer_put_key ('\t');
break;
case QZ_PAGEUP:
mplayer_put_key (KEY_PAGE_UP);
break;
case QZ_PAGEDOWN:
mplayer_put_key (KEY_PAGE_DOWN);
break;
case QZ_UP:
mplayer_put_key (KEY_UP);
break;
case QZ_DOWN:
mplayer_put_key (KEY_DOWN);
break;
case QZ_LEFT:
mplayer_put_key (KEY_LEFT);
break;
case QZ_RIGHT:
mplayer_put_key (KEY_RIGHT);
break;
//case QZ_LESS: mplayer_put_key(shift_key?'>':'<'); break;
//case QZ_GREATER: mplayer_put_key('>'); break;
//case QZ_ASTERISK:
case QZ_KP_MULTIPLY:
mplayer_put_key ('*');
break;
case QZ_SLASH:
case QZ_KP_DIVIDE:
mplayer_put_key ('/');
break;
case QZ_KP0:
mplayer_put_key (KEY_KP0);
break;
case QZ_KP1:
mplayer_put_key (KEY_KP1);
break;
case QZ_KP2:
mplayer_put_key (KEY_KP2);
break;
case QZ_KP3:
mplayer_put_key (KEY_KP3);
break;
case QZ_KP4:
mplayer_put_key (KEY_KP4);
break;
case QZ_KP5:
mplayer_put_key (KEY_KP5);
break;
case QZ_KP6:
mplayer_put_key (KEY_KP6);
break;
case QZ_KP7:
mplayer_put_key (KEY_KP7);
break;
case QZ_KP8:
mplayer_put_key (KEY_KP8);
break;
case QZ_KP9:
mplayer_put_key (KEY_KP9);
break;
case QZ_KP_PERIOD:
mplayer_put_key (KEY_KPDEC);
break;
case QZ_KP_ENTER:
mplayer_put_key (KEY_KPENTER);
break;
case QZ_LEFTBRACKET:
SetWindowAlpha (theWindow, winAlpha -= 0.05);
break;
case QZ_RIGHTBRACKET:
SetWindowAlpha (theWindow, winAlpha += 0.05);
break;
case QZ_f:
break;
default:
break;
}
}
break;
default:
err = eventNotHandledErr;
break;
} }
return err; return err;
} }
static uint32_t //Mouse event handler
config (uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, static OSStatus MainMouseEventHandler(EventHandlerCallRef nextHandler, EventRef event, void *userData)
uint32_t flags, char *title, uint32_t format)
{ {
WindowAttributes windowAttrs; OSStatus err = noErr;
CFStringRef titleKey; WindowPtr tmpWin;
CFStringRef windowTitle; Point mousePos;
OSStatus result;
GDHandle deviceHdl;
Rect deviceRect;
//Get Main device info/////////////////////////////////////////////////// GetEventParameter(event, kEventParamMouseLocation, typeQDPoint, 0, sizeof(Point), 0, &mousePos);
deviceHdl = GetMainDevice ();
deviceRect = (*deviceHdl)->gdRect;
screen_width = deviceRect.right; switch (GetEventKind (event))
screen_height = deviceRect.bottom;
//misc mplayer setup/////////////////////////////////////////////////////
image_width = width;
image_height = height;
image_depth = IMGFMT_RGB_DEPTH (format);
image_bytes = (IMGFMT_RGB_DEPTH (format) + 7) / 8;
aspect_save_orig (width, height);
aspect_save_prescale (d_width, d_height);
aspect_save_screenres (screen_width, screen_height);
aspect (&d_width, &d_height, A_NOZOOM);
if (ImageData)
free (ImageData);
ImageData = malloc (image_width * image_height * image_bytes);
//Create player window//////////////////////////////////////////////////
windowAttrs = kWindowStandardDocumentAttributes
| kWindowMetalAttribute
| kWindowStandardHandlerAttribute
| kWindowInWindowMenuAttribute
| kWindowLiveResizeAttribute | kWindowCompositingAttribute;
SetRect (&contentRect, 0, 0, d_width, d_height);
CreateNewWindow (kDocumentWindowClass, windowAttrs, &contentRect,
&theWindow);
titleKey = CFSTR ("MPlayer");
windowTitle = CFCopyLocalizedString (titleKey, NULL);
result = SetWindowTitleWithCFString (theWindow, windowTitle);
CFRelease (titleKey);
CFRelease (windowTitle);
const EventTypeSpec winEvents[] = {
{kEventClassWindow, kEventWindowActivated},
{kEventClassWindow, kEventWindowDrawContent},
{kEventClassWindow, kEventWindowClosed},
{kEventClassWindow, kEventWindowShown},
{kEventClassWindow, kEventWindowBoundsChanged},
{kEventClassWindow, kEventWindowZoomed}
};
const EventTypeSpec keyEvents[] =
{ {kEventClassKeyboard, kEventRawKeyDown} };
InstallWindowEventHandler (theWindow,
NewEventHandlerUPP (MainWindowEventHandler),
GetEventTypeCount (winEvents), winEvents,
theWindow, NULL);
InstallWindowEventHandler (theWindow,
NewEventHandlerUPP (MainKeyEventHandler),
GetEventTypeCount (keyEvents), keyEvents,
theWindow, NULL);
RepositionWindow (theWindow, NULL, kWindowCascadeOnMainScreen);
ShowWindow (theWindow);
//Setup Quartz context
CreateCGContextForPort (GetWindowPort (theWindow), &context);
//set size and aspect for current window
resize_window (d_width, d_height);
return 0;
}
//resize drawing context to fit window
void
resize_window (uint32_t width, uint32_t height)
{
//this is a "wow it work". Need some improvement.
uint32_t d_width;
uint32_t d_height;
uint32_t size;
Rect tmpRect;
float aspectX;
float aspectY;
aspect (&d_width, &d_height, A_NOZOOM);
aspectX = (float) ((float) d_width * (width / (float) d_width));
aspectY = (float) ((float) d_height * (width / (float) d_width));
if (aspectY > height)
{ {
aspectX = (float) ((float) d_width * (height / (float) d_height)); case kEventMouseDown:
aspectY = (float) ((float) d_height * (height / (float) d_height)); {
short part = FindWindow(mousePos,&tmpWin);
bounds = CGRectMake ((width - aspectX) / 2, 0, aspectX, aspectY); if(part == inMenuBar)
} {
else MenuSelect(mousePos);
{ }
bounds = CGRectMake (0, (height - aspectY) / 2, aspectX, aspectY); }
break;
default:
err = eventNotHandledErr;
break;
} }
//create a graphic context for the window HiliteMenu(0);
GetWindowPortBounds (theWindow, &tmpRect); return err;
SetPortBounds (GetWindowPort (theWindow), &tmpRect);
CreateCGContextForPort (GetWindowPort (theWindow), &context);
//fill background with black
winBounds =
CGRectMake (tmpRect.top, tmpRect.left, tmpRect.right, tmpRect.bottom);
CGContextSetRGBFillColor (context, 0.0, 0.0, 0.0, 1.0);
CGContextFillRect (context, winBounds);
} }
static void static uint32_t config(uint32_t width, uint32_t height, uint32_t d_width, uint32_t d_height, uint32_t flags, char *title, uint32_t format)
check_events (void)
{ {
EventRef theEvent; WindowAttributes windowAttrs;
EventTargetRef theTarget; CFStringRef titleKey;
CFStringRef windowTitle;
OSStatus result;
GDHandle deviceHdl;
Rect deviceRect;
theTarget = GetEventDispatcherTarget (); //Get Main device info///////////////////////////////////////////////////
deviceHdl = GetMainDevice();
deviceRect = (*deviceHdl)->gdRect;
ReceiveNextEvent (0, NULL, kEventDurationNoWait, true, &theEvent); device_width = deviceRect.right;
SendEventToEventTarget (theEvent, theTarget); device_height = deviceRect.bottom;
ReleaseEvent (theEvent);
//if(VO_EVENT_RESIZE) resize_window(vo_dwidth,vo_dheight); //misc mplayer setup/////////////////////////////////////////////////////
if (VO_EVENT_EXPOSE && int_pause) image_width = width;
flip_page (); image_height = height;
image_depth = IMGFMT_RGB_DEPTH(format);
image_bytes = (IMGFMT_RGB_DEPTH(format)+7)/8;
image_data = malloc(image_width*image_height*4);
vo_fs = flags & VOFLAG_FULLSCREEN;
//get movie aspect
aspect_save_orig(width,height);
aspect_save_prescale(d_width,d_height);
aspect_save_screenres(device_width, device_height);
aspect(&d_width,&d_height,A_NOZOOM);
//Create player window//////////////////////////////////////////////////
windowAttrs = kWindowStandardDocumentAttributes
| kWindowStandardHandlerAttribute
| kWindowLiveResizeAttribute;
SetRect(&winRect, 0, 0, d_width, d_height);
SetRect(&dstRect, 0, 0, d_width, d_height);
SetRect(&imgRect, 0, 0, image_width, image_height);
CreateNewWindow(kDocumentWindowClass, windowAttrs, &winRect, &theWindow);
//Set window title
titleKey = CFSTR("MPlayer");
windowTitle = CFCopyLocalizedString(titleKey, NULL);
result = SetWindowTitleWithCFString(theWindow, windowTitle);
CFRelease(titleKey);
CFRelease(windowTitle);
//Install event handler
const EventTypeSpec winEvents[] = { { kEventClassWindow, kEventWindowClosed }, { kEventClassWindow, kEventWindowBoundsChanged } };
const EventTypeSpec keyEvents[] = { { kEventClassKeyboard, kEventRawKeyDown } };
const EventTypeSpec mouseEvents[] = { { kEventClassMouse, kEventMouseDown } };
InstallWindowEventHandler (theWindow, NewEventHandlerUPP (MainWindowEventHandler), GetEventTypeCount(winEvents), winEvents, theWindow, NULL);
InstallWindowEventHandler (theWindow, NewEventHandlerUPP (MainKeyboardEventHandler), GetEventTypeCount(keyEvents), keyEvents, theWindow, NULL);
InstallApplicationEventHandler (NewEventHandlerUPP (MainMouseEventHandler), GetEventTypeCount(mouseEvents), mouseEvents, 0, NULL);
//Show window
RepositionWindow(theWindow, NULL, kWindowCascadeOnMainScreen);
ShowWindow (theWindow);
if(vo_fs)
window_fullscreen();
if(vo_ontop)
window_ontop();
return 0;
} }
static void static void check_events(void)
draw_osd (void)
{ {
EventRef theEvent;
EventTargetRef theTarget;
OSStatus theErr;
//Get event
theTarget = GetEventDispatcherTarget();
theErr = ReceiveNextEvent(0, 0, kEventDurationNoWait,true, &theEvent);
if(theErr == noErr && theEvent != NULL)
{
SendEventToEventTarget (theEvent, theTarget);
ReleaseEvent(theEvent);
}
//update activity every 30 seconds to prevent
//screensaver from starting up.
DateTimeRec d;
unsigned long curTime;
static unsigned long lastTime = 0;
GetTime(&d);
DateToSeconds( &d, &curTime);
if( ( (curTime - lastTime) >= 30) || (lastTime == 0))
{
UpdateSystemActivity(UsrActivity);
lastTime = curTime;
}
} }
static void static void draw_osd(void)
flip_page (void)
{ {
CGContextFlush (context); vo_draw_text(image_width,image_height,draw_alpha);
} }
static uint32_t static void flip_page(void)
draw_slice (uint8_t * src[], int stride[], int w, int h, int x, int y)
{ {
return -1; OSStatus error;
CGrafPtr oldPort,deskPort;
GDHandle oldGDevice;
OSStatus lockPixelsError;
Boolean canLockPixels;
GetGWorld (&oldPort, &oldGDevice);
SetGWorld(GetWindowPort(theWindow), GetMainDevice());
CGrafPtr windowPort = GetWindowPort(theWindow);
lockPixelsError = LockPortBits(windowPort);
if (lockPixelsError == noErr)
canLockPixels = true;
else
canLockPixels = false;
if (canLockPixels)
{
CopyBits( GetPortBitMapForCopyBits (imgGWorld), GetPortBitMapForCopyBits (windowPort), &imgRect, &dstRect, srcCopy, 0 );
lockPixelsError = UnlockPortBits(windowPort);
}
RgnHandle theVisibleRegion;
if (QDIsPortBuffered(windowPort))
{
theVisibleRegion = NewRgn();
GetPortVisibleRegion(windowPort, theVisibleRegion);
QDFlushPortBuffer(windowPort, theVisibleRegion);
DisposeRgn(theVisibleRegion);
}
SetGWorld(oldPort, oldGDevice);
} }
static uint32_t static uint32_t draw_slice(uint8_t *src[], int stride[], int w,int h,int x,int y)
draw_frame (uint8_t * src[])
{ {
//this is very slow. I have to find another way. return -1;
CGImageAlphaInfo alphaInfo;
dataProviderRef =
CGDataProviderCreateWithData (0, src[0],
image_width * image_height * image_bytes,
0);
if (image_format == IMGFMT_RGB24)
alphaInfo = kCGImageAlphaNone;
else if (image_format == IMGFMT_RGB32)
alphaInfo = kCGImageAlphaNoneSkipFirst;
image = CGImageCreate (image_width,
image_height,
8,
image_depth,
((image_width * image_depth) + 7) / 8,
CGColorSpaceCreateDeviceRGB (),
alphaInfo,
dataProviderRef, 0, 0, kCGRenderingIntentDefault);
CGContextDrawImage (context, bounds, image);
return 0;
} }
static uint32_t static uint32_t draw_frame(uint8_t *src[])
query_format (uint32_t format)
{ {
image_format = format; image_data = src[0];
//Curently supporting only rgb format. DisposeGWorld(imgGWorld);
if ((format == IMGFMT_RGB24) || (format == IMGFMT_RGB32)) NewGWorldFromPtr (&imgGWorld, k32ARGBPixelFormat, &imgRect, 0, 0, 0, image_data, image_width * 4);
return VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW;
return 0; return 0;
} }
static uint32_t query_format(uint32_t format)
static void
uninit (void)
{ {
image_format = format;
//Curently supporting only rgb32 format.
if ((format == IMGFMT_RGB32))
return VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW;
return 0;
} }
static uint32_t static void uninit(void)
preinit (const char *arg)
{ {
return 0; ShowMenuBar();
} }
static uint32_t static uint32_t preinit(const char *arg)
control (uint32_t request, void *data, ...) {
return 0;
}
static uint32_t control(uint32_t request, void *data, ...)
{ {
switch (request) switch (request)
{ {
case VOCTRL_PAUSE: case VOCTRL_PAUSE: return (int_pause=1);
return (int_pause = 1); case VOCTRL_RESUME: return (int_pause=0);
case VOCTRL_RESUME: case VOCTRL_FULLSCREEN: window_fullscreen(); return VO_TRUE;
return (int_pause = 0); case VOCTRL_ONTOP: window_ontop(); return VO_TRUE;
case VOCTRL_QUERY_FORMAT: case VOCTRL_QUERY_FORMAT: return query_format(*((uint32_t*)data));
return query_format (*((uint32_t *) data)); }
}
return VO_NOTIMPL; return VO_NOTIMPL;
} }
void window_resized()
{
float aspectX;
float aspectY;
int padding;
uint32_t d_width;
uint32_t d_height;
GetWindowPortBounds(theWindow, &winRect);
aspect( &d_width, &d_height, A_NOZOOM);
aspectX = (float)((float)winRect.right/(float)d_width);
aspectY = (float)((float)winRect.bottom/(float)d_height);
if((d_height*aspectX)>winRect.bottom)
{
padding = (winRect.right - d_width*aspectY)/2;
SetRect(&dstRect, padding, 0, d_width*aspectY+padding, d_height*aspectY);
}
else
{
padding = (winRect.bottom - d_height*aspectX)/2;
SetRect(&dstRect, 0, padding, (d_width*aspectX), d_height*aspectX+padding);
}
//create a graphic context for the window
SetPortBounds(GetWindowPort(theWindow), &winRect);
CreateCGContextForPort(GetWindowPort(theWindow),&context);
//fill background with black
CGRect winBounds = CGRectMake( winRect.top, winRect.left, winRect.right, winRect.bottom);
CGContextSetRGBFillColor(context, 0.0, 0.0, 0.0, 1.0);
CGContextFillRect(context, winBounds);
CGContextFlush(context);
}
void window_ontop()
{
if(!vo_ontop)
SetWindowClass( theWindow, kUtilityWindowClass);
else
SetWindowClass( theWindow, kDocumentWindowClass);
vo_ontop = (!(vo_ontop));
}
void window_fullscreen()
{
static Rect oldRect;
static Ptr *restoreState = nil;
short width=640;
short height=480;
RGBColor black={0,0,0};
GDHandle deviceHdl;
Rect deviceRect;
//go fullscreen
if(!vo_fs)
{
//BeginFullScreen( &restoreState,nil,&width,&height,nil,&black,nil);
HideMenuBar();
//Get Main device info///////////////////////////////////////////////////
deviceHdl = GetMainDevice();
deviceRect = (*deviceHdl)->gdRect;
device_width = deviceRect.right;
device_height = deviceRect.bottom;
//save old window size
GetWindowPortBounds(theWindow, &oldRect);
//hide mouse cursor
HideCursor();
//go fullscreen
ChangeWindowAttributes(theWindow, 0, kWindowResizableAttribute);
MoveWindow (theWindow, 0, 0, 1);
SizeWindow(theWindow, device_width, device_height,1);
vo_fs = 1;
}
else //go back to windowed mode
{
//EndFullScreen( restoreState,0);
ShowMenuBar();
//Get Main device info///////////////////////////////////////////////////
deviceHdl = GetMainDevice();
deviceRect = (*deviceHdl)->gdRect;
device_width = deviceRect.right;
device_height = deviceRect.bottom;
//show mouse cursor
ShowCursor();
//revert window to previous setting
ChangeWindowAttributes(theWindow, kWindowResizableAttribute, 0);
SizeWindow(theWindow, oldRect.right, oldRect.bottom,1);
RepositionWindow(theWindow, NULL, kWindowCascadeOnMainScreen);
vo_fs = 0;
}
window_resized();
}