I made the commitment to deliver updated binaries of mplayer.git (64bit and Snow Leopard only). These are very simple to install in your graphical user interface of choice, even if I always recommend MPlayerOSX Extended.
The binaries are available on the project page hosted on Google Code.

I finally installed Mac OS X Snow Leopard and managed to do a 64bit compilation using Uoti’s mplayer fork build scripts. I hope this will be useful for anyone running Snow Leopard (note that some of the chunks of this post are taken from my previous one about building on Leopard).
This has been tested on a clean slate install of SL, if you upgraded from Leopard you should reinstall MacPorts and all the ports or install the ports as universal binaries to include the x86_64 version.

1) First you need to install a couple of dependencies. MacPorts automates the building process for the dependencies. Make sure your MacPorts directories are at the start of your path and that you exported the PKG_CONFIG variable correctly. To achieve this your .bash_profile file should look something like this:

export PATH=/opt/local/bin:/opt/local/sbin:${PATH}
export PKG_CONFIG_PATH="/opt/local/lib/pkgconfig"

Install those dependencies:

sudo port install git-core autoconf automake libtool pkgconfig freetype fontconfig libiconv ncurses zlib lzo2

2) Download the build scripts from the git repository:

git clone git://repo.or.cz/mplayer-build.git

To launch the build script you do not use the usual ./configure && make && make install, read the README for more information on how the scripts work.

Download the source code for ffmpeg, libass and mplayer (this is done with the ./init command), and enable multithreading in ffmpeg:

cd mplayer-build
./enable-mt
./init

3) Edit the configuration files.

“common_options”:

--cc=gcc-4.2

“ffmpeg_options”:

--cpu=core2
--arch=x86_64

“mplayer_options”:

--disable-x11
--disable-gl
--disable-mencoder
--enable-macosx-bundle
--enable-macosx-finder
--target=x86_64-Darwin

4) Compile using

make

The build script will take care of compiling ffmpeg, libass, mplayer and then linking them together.
After you are done you should find your mplayer executable in the mplayer subdirectory.

5) To use your newly compiled mplayer with the MPlayerOSX Extended GUI:

cd mplayer
sudo cp mplayer /Applications/MPlayer\ OSX\ Extended.app/Contents/Resources/External_Binaries/mplayer.app/Contents/MacOS/mplayer

Enjoy your bleeding edge mplayer!

Note that at the moment it is not possible to embed mplayer in the GUI Window; in Preferences->Display you need to choose “As separate window (CoreVideo)” as your video output.

EDIT (26/9/2009): Removed the source code fix from this article, since it has been added on the repository.
EDIT (10/10/2009): As of current release video embed works again.

In this post I will explain how I am compiling mplayer on Mac OSX Leopard using the Uoti’s mplayer fork build script. The script automates all the build process of ffmpeg, mplayer and libass. It is better than my previous method because it includes automatically the most recent version of libass (the one coming with mplayer is ancient).

First you need to install a couple of dependencies, you could compile them manually but it is not worth the hassle. Use MacPorts instead.

sudo port install git-core autoconf automake libtool pkgconfig freetype fontconfig libiconv ncurses zlib lzo2 libpng

Now make sure your MacPorts bin directory is at the start of your PATH, this will override the automake and autoconf shipping with Leopard. Your last .bash_profile line should look something like this:

export PATH=/opt/local/bin:/opt/local/sbin:${PATH}

Download the build scripts:

git clone git://repo.or.cz/mplayer-build.git

To launch the build script you do not use the usual ./configure && make && make install, read the README for more information on how the scripts work.

Download the source code for ffmpeg, libass and mplayer, and enable multithreading in ffmpeg:

cd mplayer-build
./init
./enable-mt

Now you need to edit some configuration file or the compilation will fail. First you need to add

--cc=gcc-4.2

to the common_options file (this should be optional on Snow Leopard since it comes with gcc4.2 as default compiler).

Second add

--disable-x11
--disable-gl
--disable-mencoder

to the mplayer_options file.

Third add

--enable-encoder=png

to ffmpeg_options file if you want to take screenshots with the MplayerOSX Extended GUI.

Fourth you need to remove ‘–cpu=native’, from script/ffmpeg-config and if you are on a core2 or core2duo add ‘–cpu=core2′,.

Now you are ready to compile everything, just run:

export PKG_CONFIG_PATH="/opt/local/lib/pkgconfig"
make

The build script will take care of compiling ffmpeg, libass, mplayer and then linking them together.
After you are done you should find your mplayer executable in the mplayer subdirectory.

To use your newly compiled mplayer with the MPlayerOSX Extended GUI:

cd mplayer
sudo cp mplayer /Applications/MPlayer\ OSX\ Extended.app/Contents/Resources/External_Binaries/mplayer.app/Contents/MacOS/mplayer

That’s all folks! enjoy.

NOTE: This guide is outdated, for the current reccomended way to build mplayer please check my other post here.

A lot of recent releases of fansubbed anime make use of ordered chapters (linking segments), a feature of the Matroska video container that allows to link external video sources to the file you are currently playing. It is very useful because that way the Opening/Endings can be distributed only one time for each series and then be linked to each episode during playback.

Until a while back the only way to play these files correctly was on windows using Haali’s Media Splitter, however it is now possible to get it work on Linux and MacOSX by just compiling mplayer from the development server.
If you are looking for a similar guide for Linux check this.

First you need to install a couple of dependencies, you could compile them manually but it is not worth the hassle. Use MacPorts instead.

sudo port install git-core pkgconfig freetype fontconfig libiconv ncurses zlib lzo2 libpng

Now you can download a copy of mplayer and ffmpeg from the development git.

git clone git://repo.or.cz/mplayer.git mplayer
cd mplayer
git checkout -b mt -t origin/mt && git submodule init && git submodule update

Time to compile:

export PKG_CONFIG_PATH="/opt/local/lib/pkgconfig"
./configure --disable-x11 --disable-gl --disable-mencoder --enable-apple-remote --extra-cflags=-I/opt/local/include --extra-ldflags=-L/opt/local/lib
make
sudo make install

To use your newly compiled mplayer with the MPlayerOSX Extended GUI:

sudo cp mplayer /Applications/MPlayer\ OSX\ Extended.app/Contents/Resources/External_Binaries/mplayer.app/Contents/MacOS/mplayer

Thats all. Here is a screenshot of it running :)

Working on my project I used Core Animation for the first time. Unfortunately layer-backed views don’t work well with some Cocoa controls (such as NSTextField and NSButton with check style). Luckyly I only need Core Animation to set up some NSView replacing and NSWindow scaling transitions.

For this reason I started to research a way to turn on layer backing before the animation starts and turn it off as soon as it ends. Since I didn’t find much information about it I wrote this post to sum it up. Here is some source code:

-(IBAction) trigger:(id) sender
{
	[[mainWindow contentView] setWantsLayer:YES];
	[NSTimer scheduledTimerWithTimeInterval:.2 target:self
                       selector:@selector(doAnimation) userInfo:nil repeats:NO];

}
-(void)doAnimation
{
	[NSAnimationContext beginGrouping];
	// do your transition here
	[NSAnimationContext endGrouping];
	[NSTimer scheduledTimerWithTimeInterval:.1 target:self
                       selector:@selector(finishAnimation) userInfo:nil repeats:NO];

}
-(void)finishAnimation
{
	[[mainWindow contentView] setWantsLayer:NO];
}

Have fun with Core Animation!

As you know Leopard has this new amazing facility to present complex data on screen. NSCollectionView allows you to lay out some NSViews each representing your data, whereas NSTableView supports only NSCells out of the box.

Anyway if you are thinking about using a NSCollectionView you will be disappointed to discover that the current implementation is very buggy. As pointed out in the linked posts whenever you resize a containing NSWindow the contained NSCollectionView will scroll to its origins (provided that you actually have springed the NSCollectionView to the window).

Fortunately, fixing the “scroll to origin” misbehavior is pretty easy. All you need to do is a NSWindow subclass implementing two delegate methods.

In the definition define an outlet that you will bind to the NSScrollView containing the NSCollectionView you want to resize properly. Moreover define an NSPoint to store the original position of the NSCollectionView in the NSScrollView.

@interface PGZWindow : NSWindow {

	IBOutlet NSScrollView * scrollView;
	NSPoint pos;

}

@property (retain) IBOutlet NSScrollView * scrollView;
- (void)windowDidResize:(NSNotification *)notification;
- (NSSize)windowWillResize:(NSWindow *) window toSize:(NSSize)newSize;

@end

In the implementation you just store the position before the resize, and set it after the resize is completed. Note that you need to set the delegate to self or windowDidResize: will not be called (the mysteries of cocoa…).

@implementation PGZWindow
@synthesize scrollView;

- (void) awakeFromNib
{
	[self setDelegate:self];
}

- (NSSize)windowWillResize:(NSWindow *) window toSize:(NSSize)newSize
{
	NSPoint new_pos = [[scrollView contentView] bounds].origin;
	if(new_pos.x > 0.0 || new_pos.y > 0.0){
		self->pos = new_pos;
	}
}

- (void)windowDidResize:(NSNotification *)notification
{
	NSPoint new_pos = [[scrollView contentView] bounds].origin;
	if(new_pos.x > 0.0 || new_pos.y > 0.0){
		self->pos = new_pos;
	} else {
		[[scrollView contentView] scrollToPoint:self->pos];
		[scrollView reflectScrolledClipView: [scrollView contentView]];
	}
	self->pos = NSMakePoint(0.0, 0.0);
}

@end

Thank you for reading and enjoy your resizing NSCollectionView. Cheers :)