Background Audio Playback Agent terminates during playback Windows Phone 7.5

Question 1

If I were you, I would probably do the following, in that order:

Ensure you have the latest OS updates. They have silently fixed some BAP-related memory issues in their 7.8 update. If you're not using the latest OS, upgrade and try to reproduce.
Place breakpoints in every place of your GUI process code that interacts with BAP, to make sure you’re not mistakenly calling e.g. BackgroundAudioPlayer.Stop() or BackgroundAudioPlayer.Track=null, try to reproduce.
Instead of “logging current memory usage of the BAP at various stages”, in static constructor of some agent class, create a thread that, in the endless loop, appends to some CSV file in the isolated storage, logging current timestamp + current memory , then sleeps for 500-1000 milliseconds. Reproduce the problem, use ISETool.exe to download the log, use Excel to build the RAM usage graph…
If (3) won’t show RAM usage approaching the limit, Implement tracing to either isolated storage or network (BTW, I’ve implemented a SysLog RFC 5426 client in my WP7 code, and installed free software called “SysRose Syslog Desktop” on my PC), then try to do printf-style debugging.

Question 2

This may happen on unhandled exceptions. Subscribe for Application.Current.UnhandledException (and if you're using async-await for TaskScheduler.UnobservedTaskException) and log them somewhere. Also, override OnError method of your agent, and log.
This may happen if forget to call BackgroundAgent.NotifyComplete() after you've finished processing the requests (i.e. for player agent, the OnPlayStateChanged and OnUserAction). In this case, the OS consludes you was unable to process the request in a timely manner, and terminates the BAP process.
RAM issues, but you've figured it out.

P.S. Here's the relevant part of my Sky.fm player application. It doesn't play local MP3s , instead it streams the music from the Internets, however the player agent code should be more or less the same.

/// <summary>This class wraps AudioPlayerAgent API into the async-friendly abstract class.</summary>
/// <remarks>Logging and exception handling are added, as well.</remarks>
public abstract class PlayerAgentAsync: AudioPlayerAgent
{
    static PlayerAgentAsync()
    {
        UnhandledExceptionHandler.subscribe();
    }

    public PlayerAgentAsync()
    {
        Logger.info( "constructed" );
    }

    protected override void OnError( BackgroundAudioPlayer player, AudioTrack track, Exception ex, bool isFatal )
    {
        if( isFatal )
        {
            BackgroundErrorNotifier.addError( ex );
            ex.log();
            Abort();
        }
        else
        {
            ex.logWarning();
            try
            {
                // Force the track to stop 
                // http://blogs.msdn.com/b/wpukcoe/archive/2012/02/11/background-audio-in-windows-phone-7-5-part-3.aspx
                player.Track = null;
            }
            catch (System.Exception ex2)
            {
                ex2.logWarning( "Exception while trying to stop da playa" );
            }
            NotifyComplete();
        }
    }

    /// <summary>Called when the play state changes, except for the error state.</summary>
    protected override async void OnPlayStateChanged( BackgroundAudioPlayer player, AudioTrack track, PlayState playState )
    {
        Logger.info( "new playState = {0}", playState.ToString() );

        try
        {
            await this.playStateChangedAsync( player, track, playState ).ConfigureAwait( false );
            NotifyComplete();
        }
        catch (System.Exception ex)
        {
            this.onException( ex );
        }
    }

    /// <summary>Called when the user requests an action using some application-provided UI or the Universal Volume Control (UVC) and the application has requested notification of the action.</summary>
    protected override async void OnUserAction( BackgroundAudioPlayer player, AudioTrack track, UserAction action, object param )
    {
        Logger.info( "action = {0};", action.ToString() );

        try
        {
            await this.userActionAsync( player, track, action, param ).ConfigureAwait( false );
            NotifyComplete();
        }
        catch( System.Exception ex )
        {
            this.onException( ex );
        }
    }

    private void onException( Exception ex )
    {
        if( ex.shouldBeIgnored() )
        {
            ex.logWarning();
            this.NotifyComplete();
            return;
        }
        ex.log();
        BackgroundErrorNotifier.addError( ex );
        this.Abort();
    }

    protected override void OnCancel()
    {
        Logger.trace();
        base.OnCancel();
    }

    /// <summary>Handle OnPlayStateChanged asyncronously.</summary>
    /// <param name="player">The Microsoft.Phone.BackgroundAudio.BackgroundAudioPlayer.</param>
    /// <param name="track">The track playing at the time that the play state changed.</param>
    /// <param name="playState">The new state of the player.</param>
    protected abstract Task playStateChangedAsync( BackgroundAudioPlayer player, AudioTrack track, PlayState playState );

    /// <summary>Handle OnUserAction asyncronously</summary>
    /// <param name="player">The Microsoft.Phone.BackgroundAudio.BackgroundAudioPlayer.</param>
    /// <param name="track">The track playing at the time of the user action.</param>
    /// <param name="action">The action that the user has requested.</param>
    /// <param name="param">The data associated with the requested action.</param>
    protected abstract Task userActionAsync( BackgroundAudioPlayer player, AudioTrack track, UserAction action, object param );
}