source: svn/newcon3bcm2_21bu/nexus/modules/playback/src/nexus_playback.c @ 66

/***************************************************************************
 *     (c)2007-2011 Broadcom Corporation
 *
 *  This program is the proprietary software of Broadcom Corporation and/or its licensors,
 *  and may only be used, duplicated, modified or distributed pursuant to the terms and
 *  conditions of a separate, written license agreement executed between you and Broadcom
 *  (an "Authorized License").  Except as set forth in an Authorized License, Broadcom grants
 *  no license (express or implied), right to use, or waiver of any kind with respect to the
 *  Software, and Broadcom expressly reserves all rights in and to the Software and all
 *  intellectual property rights therein.  IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU
 *  HAVE NO RIGHT TO USE THIS SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY
 *  NOTIFY BROADCOM AND DISCONTINUE ALL USE OF THE SOFTWARE.
 *
 *  Except as expressly set forth in the Authorized License,
 *
 *  1.     This program, including its structure, sequence and organization, constitutes the valuable trade
 *  secrets of Broadcom, and you shall use all reasonable efforts to protect the confidentiality thereof,
 *  and to use this information only in connection with your use of Broadcom integrated circuit products.
 *
 *  2.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
 *  AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, REPRESENTATIONS OR
 *  WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH RESPECT TO
 *  THE SOFTWARE.  BROADCOM SPECIFICALLY DISCLAIMS ANY AND ALL IMPLIED WARRANTIES
 *  OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE,
 *  LACK OF VIRUSES, ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION
 *  OR CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING OUT OF
 *  USE OR PERFORMANCE OF THE SOFTWARE.
 *
 *  3.     TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM OR ITS
 *  LICENSORS BE LIABLE FOR (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR
 *  EXEMPLARY DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO YOUR
 *  USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM HAS BEEN ADVISED OF
 *  THE POSSIBILITY OF SUCH DAMAGES; OR (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT
 *  ACTUALLY PAID FOR THE SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE
 *  LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF
 *  ANY LIMITED REMEDY.
 *
 * $brcm_Workfile: nexus_playback.c $
 * $brcm_Revision: 118 $
 * $brcm_Date: 12/20/11 1:43p $
 *
 * Module Description:
 *
 * Revision History:
 *
 * $brcm_Log: /nexus/modules/playback/src/nexus_playback.c $
 * 
 * 118   12/20/11 1:43p vsilyaev
 * SW7425-2034: Used 32-bit type for program id (pid) types
 * 
 * 117   12/9/11 10:07a erickson
 * SWDEPRECATED-1003: reset force_source_frame_rate on normal play
 * 
 * 116   10/19/11 3:52p erickson
 * SW7335-1368: don't allow non-zero rate to round down to zero (pause)
 * 
 * 115   10/12/11 11:44a erickson
 * SW7425-1264: convert decode_rate to abs before passing to
 *  nexus_playback_trick.c. if trick params must be adjusted, actually
 *  modify a copy of the struct for better debug.
 * 
 * 114   10/12/11 9:32a erickson
 * SW7425-1264: improve param checking for automatic and custom trick
 *  modes
 *
 * 113   10/7/11 11:16a erickson
 * SW7125-823: removing check for video pid channel when starting
 *  timeshifting. valid usage modes exist where this is not true.
 *
 * 112   9/22/11 4:43p erickson
 * SW7420-1965: add simple decoder support to nexus playback module
 *
 * 111   9/7/11 11:41a erickson
 * SW7405-5059: fail stc trick if any decoder not in TSM mode
 *
 * 110   8/31/11 2:44p vsilyaev
 * SW7420-1978: Add selection of index type for playback of MPEG-2 TS
 *  files
 *
 * 109   8/30/11 12:46p vsilyaev
 * SWDTV-7867: Use proper scale factor when converting rate to time
 *
 * 108   8/12/11 9:40a erickson
 * SW7358-83: add NEXUS_PlaybackTrickModeSettings.brcmTrickMode
 *
 * 107   6/16/11 3:38p erickson
 * SW7125-823: if playback lacks decoder, allow NEXUS_Playback_Seek to
 *  succeed but issue a WRN
 *
 * 106   5/26/11 7:32p vsilyaev
 * SW7425-646: Added configurable 'gap' for timeshifting
 *
 * 105   5/13/11 5:12p erickson
 * SW7125-823: add support for decoder-less host trick modes with
 *  nexus_playback
 *
 * 104   5/13/11 4:13p erickson
 * SWDTV-6386: add "nx_" namespace prefix for internal nexus threads
 *
 * 103   4/27/11 10:34a erickson
 * SW7405-4249: all audio-only timeshifting
 *
 * 102   4/14/11 3:31p jtna
 * SWDTV-6321: fix build warnings for 2.6.37 kernel
 *
 * 101   3/28/11 3:45p vsilyaev
 * SW7335-1214: Added NEXUS_CallbackHandler framework
 *
 * 100   2/24/11 1:36p vsilyaev
 * SWDTV-5485: Differentiates ES and ES->PES types
 *
 * 99   11/24/10 3:10p vsilyaev
 * SW35230-2195: Better support of 'start_paused'->pause transition and
 *  cleaned error reporting when PTS can't be obtained
 *
 * 98   11/11/10 5:47p vsilyaev
 * SW7405-4995: Use BKNI_Memcmp to preinitialize structure used in
 *  GetDefaultSettings
 *
 * 97   11/2/10 7:10p mward
 * SW7400-2920: playback should not flush when transitioning decoder skip
 *  modes if there's no index.
 *
 * 96   10/22/10 11:46a vsilyaev
 * SW35230-1600: When decrypting payload clear file buffer on transitions.
 *
 * 95   9/28/10 1:57p erickson
 * SWDEPRECATED-1003: pass force source frame rate from media framework to
 *  VideoDecoder
 *
 * 93   6/29/10 3:20p erickson
 * SW7405-4367: playback should flush when transitioning decoder skip
 *  modes. also added NEXUS_PlaybackTrickModeSettings.avoidFlush option to
 *  disable this behavior.
 *
 * 92   6/1/10 3:07p vsilyaev
 * SW7400-2787: Improving handling of 'start_paused'
 *
 * 91   4/29/10 11:55a vsilyaev
 * SW7400-2749: If in 'start.paused' state don't start playback on
 *  GetStatus
 *
 * 90   4/14/10 5:43p jtna
 *  SW7125-317: Coverity Defect ID:20335 CHECKED_RETURN
 *
 * 89   3/11/10 5:26p vsilyaev
 * SW3556-913: Always use header file to declare external functions
 *
 * 88   3/5/10 7:12p jtna
 * SW3556-913: support for ErrorHandlingMode_eAbort
 *
 * 87   2/23/10 4:58p erickson
 * SW7400-2684: add state variable so we only fire beginningOfStreamAction
 *  or endOfStreamAction once when paused
 *
 * 86   2/22/10 6:55p vsilyaev
 * SW3556-913: Don't call  b_play_check_buffer before reading status
 *
 * 85   2/22/10 6:50p vsilyaev
 * SW3556-913: Return playback state even if in 'Aborted' or 'Paused'
 *  state
 *
 * 84   2/18/10 12:05p vsilyaev
 * SW3556-913: Differentiate between index error and end of stream
 *
 * 83   1/13/10 5:41p vsilyaev
 * SW3556-913: Added option control error handling for Play/Seek/SetTrick
 *  operations
 *
 * 82   1/12/10 8:13p vsilyaev
 * SW3556-913: Don't sync pause with the playback data flow (file I/O)
 *
 * 81   12/17/09 6:16p vsilyaev
 * SW3556-913: Added option to specify timeout on asynchronous I/O
 *
 * 80   12/17/09 5:52p vsilyaev
 * SW3548-2677: Added configuration that allows user to choose what
 *  context should be used for synchronous I/O
 *
 * 79   11/16/09 10:31a vsilyaev
 * SW7405-3393 SW7400-2593: Use signed decode_rate for the host_paced mode
 *
 * 78   11/5/09 7:32p vsilyaev
 * SW7400-2593: Updated lookup table and handling of slow rewind modes
 *
 * 77   11/5/09 11:37a vsilyaev
 * SW7400-2593: Set trickModeSettings.rate to 0 while in the pause state
 *
 * 76   11/5/09 9:25a vsilyaev
 * SW7400-2593: Populate trickModeSettings inside NEXUS_Playback_GetStatus
 *
 * 75   10/14/09 10:24a jtna
 * SW7405-3205: fix typo in BDBG_ERR
 *
 * 74   9/30/09 7:12p vsilyaev
 * SW7405-2732: Fixed communication between media player and nexux
 *  playback when entering into the frame reverse mode
 *
 * 73   9/30/09 6:48p vsilyaev
 * SW7405-2732: Added fragmented mode, for the decoder side it set using
 *  Reoorder and filtering I frames only
 *
 * 72   9/9/09 12:04p erickson
 * SW7400-2507: NEXUS_Playback_CloseAllPidChannels should call
 *  NEXUS_Playback_ClosePidChannel so that cleanup logic doesn't have to
 *  be duplicated
 *
 * 71   8/19/09 3:25p erickson
 * PR57840: remove incorrect comment
 *
 * 70   8/10/09 3:36p ahulse
 * PR56762: firstPts/Passed callbacks not registered in settop API mode,
 *  move registration into b_play_trick_set_pid
 *
 * 69   7/31/09 4:29p erickson
 * PR57235: rename Settop API names, remove unused code
 *
 * 68   7/31/09 12:36p katrep
 * PR57193: stc_trick flag should be restored to requested value when
 *  resuming playback from trickmodes
 *
 * 67   7/30/09 7:15p vsilyaev
 * PR 55989: Do UnlockModule only after all playback componets where
 *  shutdown, this prevents from stray IO callback to reach into closed
 *  media player
 *
 * 66   7/21/09 5:57p vsilyaev
 * PR 56977: Nexus playback always control audio and video decoder.
 *  Provided way for the user to control the decoder slowmotion factor
 *  using the playback trick API.
 *
 * 65   7/13/09 3:51p jtna
 * PR56423: fix condition to set decoder trick state
 *
 * 64   7/8/09 3:25p vsilyaev
 * PR 55989: Used size of the video decoder CDB to control size of the
 *  data chunk
 *
 * 63   7/8/09 11:59a vsilyaev
 * PR 55989: Added support for OTF trickmodes
 *
 * 62   6/19/09 4:56p vsilyaev
 * PR 56169: Allow fast decode trickmodes even without STC trickmodes
 *
 * 61   6/19/09 4:11p vsilyaev
 * PR 56169: PR 53824: Allow user to sepcify max decodder rate. This
 *  superceeds overrideStcTrick.
 *
 * 60   6/11/09 4:31p jtna
 * PR55817: make check on duplicate channels backward-compatible
 *
 * 59   6/8/09 3:47p erickson
 * PR55817: relax the check on duplicate pid channels. they are allowed,
 *  as long as they are simultaneously enabled. we still prevent duplicate
 *  NEXUS_PidChannelHandle entries.
 *
 * 58   4/16/09 1:29p erickson
 * PR54129: failed Seek is not an ERR. prevent eWaitingRecord loop at
 *  beginning of circular record.
 *
 * 57   4/3/09 12:56p erickson
 * PR53824: reenable stc trick modes. add
 *  NEXUS_PlaybackTrickModeSettings.overrideStcTrick for additional app
 *  control.
 *
 * 56   3/27/09 12:51p vsilyaev
 * PR 50311: Return readPosition in the Nexus playback status. In
 *  combination with the position it could be used to measure depth of
 *  decoder and playback buffers in units of time.
 *
 * 55   3/6/09 1:55p erickson
 * PR52891: remove unnecessary call to b_play_trick_set_pid inside
 *  NEXUS_Playback_OpenPidChannel
 *
 * 54   3/5/09 5:46p vsilyaev
 * PR 52579: Updated circular FIFO/timeshifting code
 *
 * 53   2/26/09 9:03a erickson
 * PR52099: block all TrickState calls to AudioDecoder and VideoDecoder if
 *  NEXUS_PlaybackHostTrickMode_eNormal is set. also removed some old,
 *  unused code.
 *
 * 52   2/25/09 11:19a katrep
 * PR52099: Need to take into account decoder trick modes. Audio needs to
 *  be muted.
 *
 * 51   2/19/09 11:52a erickson
 * PR52290: Playback should fail on certain operations if there's no
 *  eAudio or eVideo pid set
 *
 * 50   2/13/09 11:49a erickson
 * PR52107: fix NEXUS_Playback_Seek when in startPaused state
 *
 * 49   2/5/09 4:48p erickson
 * PR51870: fix uninitialized variable
 *
 * 48   2/2/09 3:35p gmohile
 * PR 47815 : Add manual control of trickmodes
 *
 * 47   2/2/09 2:53p gmohile
 * PR 47815 : Add manual control of trickmodes
 *
 * 46   1/27/09 4:04p erickson
 * PR51377: NEXUS_Playback_Start or NEXUS_Playback_OpenPidChannel should
 *  reset VideoDecoder's trick state
 *
 * 45   1/26/09 11:38a vsilyaev
 * PR 51579: Added ES to PES packetization and support for capturing of
 *  streams produced by the playback module
 *
 * 44   1/12/09 5:45p vsilyaev
 * PR 50763: Improved seek to position 0 after rewind reached begining of
 *  the file
 *
 * 43   1/9/09 1:55a erickson
 * PR49294: don't allow NEXUS_PlaybackSettings.stcTrick to change while
 *  started
 *
 * 42   12/19/08 5:59p vsilyaev
 * PR 50214: Added callbacks and counters for parsing index files
 *
 * 41   12/15/08 2:41p erickson
 * PR50369: if b_play_trick_set fails, we can't abort all Playback state
 *  changes otherwise we end up with a stray NEXUS_Playpump_ReadComplete.
 *
 * 40   12/10/08 4:42p erickson
 * PR49930: add internal accurate seek algorithm for driving audio through
 *  the transition
 *
 * 39   12/10/08 11:11a erickson
 * PR49930: added NEXUS_Playback_AccurateSeekInProcess test api, added
 *  required flush before calling NEXUS_VideoDecoder_SetStartPts
 *
 * 38   12/10/08 2:06a vsilyaev
 * PR 48760: Using ES player for accurate progress monitor of MP3 streams
 *
 * 37   12/8/08 11:19a erickson
 * PR49930: implement NEXUS_PlaybackSettings.accurateSeek
 *
 * 36   11/21/08 12:06p erickson
 * PR49531: corrected comment
 *
 * 35   11/21/08 8:54a erickson
 * PR49531: cancel playback timer before stopping Playpump so that no
 *  additional calls to Playpump are made after stop
 *
 * 34   11/19/08 1:50p erickson
 * PR48744: don't require
 *  NEXUS_PlaybackPidChannelSettings.pidTypeSettings.video.index for
 *  decoder trick modes
 *
 * 33   11/18/08 4:58p erickson
 * PR47854: call NEXUS_FilePlay_Cancel if waiting for io times out. allow
 *  Playback to recover from eAborted state.
 *
 * 32   11/5/08 2:37p erickson
 * PR47407: fix warning
 *
 * 31   11/4/08 5:33p erickson
 * PR47407: remove call to b_play_trick_set and replace with direct
 *  assignment
 *
 * 30   10/23/08 3:52p erickson
 * PR48149: fix NEXUS_Playback_P_CheckWaitingIo state, don't force
 *  eStopped state
 *
 * 29   10/21/08 2:14p erickson
 * PR48149: implement algo to get out of eWaitingIo state
 *
 * 28   10/14/08 5:01p erickson
 * PR47407: only reapply audio decoder trick modes if already started
 *
 * 27   10/14/08 3:36p erickson
 * PR47407: reapply audio decoder trick mode settings when pid channel is
 *  opened or set
 *
 * 26   10/9/08 2:54p erickson
 * PR47608: move location of stcChannel test
 *
 * 25   10/9/08 2:23p erickson
 * PR47608: NEXUS_PlaybackSettings.stcChannel is now required for TSM
 *  playback. NEXUS_PlaybackSettings.stcTrick was added for stc trick
 *  modes.
 *
 * 24   10/6/08 11:48a gmohile
 * PR 47608 : Invalidate STC channel during flush
 *
 * 23   9/18/08 6:28p katrep
 * PR45880: Add support for FSPB(80/120 playback)
 *
 * 22   7/28/08 3:34p katrep
 * PR43242: Allow changes of timeshifting flag while playback is in
 *  progress
 *
 * 21   7/24/08 4:34p erickson
 * PR45124: allow duplicate calls to NEXUS_Playback_OpenPidChannel and
 *  ref_cnt internally
 *
 * 20   7/3/08 1:07p vsilyaev
 * PR 44381: Added code to limi nestendess of recursive calls
 *
 * 19   6/24/08 4:07p erickson
 * PR44107: rename to TrickMode
 *
 * 18   6/12/08 3:02p erickson
 * PR43606: rename NEXUS_PlaybackStreamSettings to
 *  NEXUS_PlaybackStartSettings
 *
 * 17   5/30/08 2:56p erickson
 * PR43000: fix default frame advance state at Start
 *
 * 16   5/22/08 7:25p vsilyaev
 * PR 42984: Wait for I/O completion shall be unconditional
 *
 * 15   5/21/08 2:37p erickson
 * PR41960: NEXUS_Playback_Start wasn't resetting its state to allow for
 *  the next Start.
 *
 * 14   5/15/08 4:38p erickson
 * PR42119: default trickmode_params correctly
 *
 * 13   5/7/08 4:20p erickson
 * PR42329: unlock playback inside NEXUS_Playback_Stop to avoid deadlock
 *  with playpump callbacks
 *
 * 12   5/5/08 5:42p vsilyaev
 * PR 42355: Fixed transition from trickmode to frame advance/reverse
 *
 * 11   5/5/08 4:46p vsilyaev
 * PR 42355: Fixed rewind for AVI files
 *
 * 10   4/25/08 1:24p erickson
 * PR41951: NEXUS_Playback_ClosePidChannel should return void
 *
 * 9   4/17/08 4:26p vsilyaev
 * PR 41845: Hold playpump callbacks if not playing data
 *
 * 8   4/10/08 5:08p erickson
 * PR40832: fix eWaitingRecord state
 *
 * 7   4/10/08 9:16a erickson
 * PR41589: check rc
 *
 * 6   4/9/08 1:09p jgarrett
 * PR 41557: Fixing GetDefaultPidChannelSettings
 *
 * 5   4/7/08 12:04p erickson
 * PR41431: only fail stcChannel change during trick mode
 *
 * 4   3/17/08 4:09p vsilyaev
 * PR 40554: In broadcom trikcmodes use decode_rate from the media player
 *
 * 3   3/8/08 7:45a erickson
 * PR40103: convert to NEXUS_TaskCallback
 *
 * 2   3/7/08 5:34p erickson
 * PR40307: don't return error on success
 *
 * 1   1/18/08 2:36p jgarrett
 * PR 38808: Merging to main branch
 *
 * Nexus_Devel/26   1/8/08 2:23p vsilyaev
 * PR 35824: Fixed resync on transition between modes
 *
 * Nexus_Devel/25   1/7/08 5:09p erickson
 * PR35824: add new continuous record support
 *
 * Nexus_Devel/24   12/28/07 5:06p erickson
 * PR37574: return state in status
 *
 * Nexus_Devel/23   12/21/07 5:55p vsilyaev
 * PR 38073: Fixed fa -> fb -> play transitions
 *
 * Nexus_Devel/22   12/20/07 5:24p vsilyaev
 * PR 38073: Improved handling of trickmodes
 *
 * Nexus_Devel/21   12/20/07 3:41p vsilyaev
 * PR 38073: Improving use of bmedia_player
 *
 * Nexus_Devel/20   12/20/07 10:29a vsilyaev
 * PR 38073: Updated to work with new bmedia_player
 *
 * Nexus_Devel/PR38073/3   12/19/07 5:01p vsilyaev
 * PR 38073: Moved time tracking code for host paced mode into the
 * bmedia_player
 *
 * Nexus_Devel/PR38073/2   12/18/07 6:45p vsilyaev
 * PR 38073: Added handling of no-index streams
 *
 * Nexus_Devel/PR38073/1   12/18/07 4:57p vsilyaev
 * PR 38073: Updated playback module to work exclusively with media player
 *
 * Nexus_Devel/19   12/6/07 5:24p vsilyaev
 * PR 37574: Added handling of segmented feed
 *
 * Nexus_Devel/18   12/5/07 3:09p vsilyaev
 * PR 37934: Implemented BLST_S_DICT
 *
 * Nexus_Devel/17   12/3/07 4:43p erickson
 * PR36404: restore start_paused code. fix status fifoSize.
 *
 * Nexus_Devel/16   11/16/07 12:38p vsilyaev
 * PR 35824: Added STC trickmodes
 *
 * Nexus_Devel/15   11/13/07 3:31p vsilyaev
 * PR 37015: At start Seek index to 0 offset
 *
 * Nexus_Devel/14   11/13/07 12:21p erickson
 * PR36788: fixed frameadvance. disabled start_paused check.
 *
 * Nexus_Devel/13   11/9/07 6:02p vsilyaev
 * PR 36788: Added timeshifting
 *
 * Nexus_Devel/12   11/1/07 9:41a erickson
 * PR36633: base enum changes
 *
 * Nexus_Devel/11   10/30/07 5:05p vsilyaev
 * PR 36404: Added audio tracking for slow motion modes
 *
 * Nexus_Devel/10   10/19/07 11:21a vsilyaev
 * PR 35824: Fixed data corruption on trick modes
 *
 * Nexus_Devel/9   10/17/07 5:38p vsilyaev
 * PR 35824: Added trickmode test
 *
 * Nexus_Devel/8   10/17/07 1:05p vsilyaev
 * PR 35824: Added playpump_trick
 *
 * Nexus_Devel/7   10/16/07 4:59p vsilyaev
 * PR 35824: Rearranged code
 *
 * Nexus_Devel/6   10/16/07 12:59p vsilyaev
 * PR 35824: Splitting playback into managable piecies
 *
 * Nexus_Devel/5   10/15/07 5:12p vsilyaev
 * PR 35824: Added module initialization
 *
 * Nexus_Devel/4   10/15/07 2:55p vsilyaev
 * PR 35824: Added synchronization thunk layer
 *
 * Nexus_Devel/2   10/11/07 6:25p vsilyaev
 * PR 35824: Added more playback code
 *
 * Nexus_Devel/1   10/10/07 4:54p vsilyaev
 * PR 35824: Playback module
 *
 * $copied_brcm_Log: /BSEAV/api/src/pvr/bsettop_playback.c $
 * $copied_brcm_Revision: 172 $
 * $copied_brcm_Date: 10/1/07 11:13a $
 **************************************************************************/
#include "nexus_playback_module.h"
#include "nexus_playback_impl.h"
#include "nexus_core_utils.h"

BDBG_MODULE(nexus_playback);

/* We have a separate dbg macro for data flow. When you want to see it, uncomment
the following */
#define BDBG_MSG_FLOW(X) /* BDBG_MSG(X) */



BDBG_OBJECT_ID(NEXUS_Playback);

/*
 * the following function is used to control playback dataflow
 * and handle various transition between trickmodes
 */
static NEXUS_Error bplay_p_frameadvance(NEXUS_PlaybackHandle p, bool forward, bool *restart);
static void b_play_playpump_read_callback_locked(void *context);
static NEXUS_Error b_play_playpump_read_callback_guard(void *context);

void
NEXUS_Playback_GetDefaultSettings( NEXUS_PlaybackSettings *pSettings)
{
    BKNI_Memset(pSettings, 0, sizeof(*pSettings));
    pSettings->playpump = NULL;
    NEXUS_Playpump_GetDefaultSettings(&pSettings->playpumpSettings);
    pSettings->endOfStreamAction = NEXUS_PlaybackLoopMode_eLoop;
    pSettings->stcChannel = NULL;
    pSettings->beginningOfStreamAction = NEXUS_PlaybackLoopMode_eLoop;
    NEXUS_CallbackDesc_Init(&pSettings->endOfStreamCallback);
    NEXUS_CallbackDesc_Init(&pSettings->beginningOfStreamCallback);
    NEXUS_CallbackDesc_Init(&pSettings->errorCallback);
    NEXUS_CallbackDesc_Init(&pSettings->parsingErrorCallback);
    pSettings->startPaused = false;
    pSettings->timeshifting = false;
    pSettings->stcTrick = false;
    pSettings->accurateSeek = false;
    pSettings->enableStreamProcessing = false;
    pSettings->ioTimeout = 5000; /* 5 sec */
    pSettings->playErrorHandling = NEXUS_PlaybackErrorHandlingMode_eEndOfStream;
    pSettings->seekErrorHandling = NEXUS_PlaybackErrorHandlingMode_eIgnore;
    pSettings->trickErrorHandling = NEXUS_PlaybackErrorHandlingMode_eIgnore;
    /* milliseconds to gap between end of playback and record which will not cause decode stuttering */
    pSettings->timeshiftingSettings.endOfStreamGap = 3000;
    /* milliseconds to gap between beginning of playback and truncating record which will not cause excess beginningOfStream events */
    pSettings->timeshiftingSettings.beginningOfStreamGap = 5000;

    return;
}

NEXUS_PlaybackHandle
NEXUS_Playback_Create( void )
{
    NEXUS_PlaybackHandle playback;
    NEXUS_Error rc;

    playback = BKNI_Malloc(sizeof(*playback));
    if (!playback) { rc = BERR_TRACE(NEXUS_OUT_OF_SYSTEM_MEMORY); goto err_alloc; }

    BDBG_OBJECT_INIT(playback,NEXUS_Playback);
    BKNI_Memset(&playback->state, 0, sizeof(playback->state));

    playback->state.state = eStopped;
    BLST_S_INIT(&playback->pid_list);
    playback->file = NULL;
    playback->media_player = NULL;
    playback->thread_terminate = false;
    playback->playpump_thread_event = NULL;
    playback->playpump_thread = NULL;
    playback->playpump_event_callback = NULL;
    playback->playpump_event = NULL;
    playback->index_file_mode = NEXUS_PlaybackIndexFileIo_eCallback;
    playback->actualTransportType = NEXUS_TransportType_eTs;
    NEXUS_CallbackHandler_Init(playback->dataCallbackHandler, b_play_playpump_read_callback_locked, playback);
    NEXUS_CallbackHandler_SetGuard(playback->dataCallbackHandler, b_play_playpump_read_callback_guard);
    NEXUS_CallbackHandler_Init(playback->videoDecoderFirstPts, NEXUS_Playback_P_VideoDecoderFirstPts, playback);
    NEXUS_CallbackHandler_Init(playback->videoDecoderFirstPtsPassed, NEXUS_Playback_P_VideoDecoderFirstPtsPassed, playback);

    NEXUS_Thread_GetDefaultSettings(&playback->playpump_thread_settings);
    NEXUS_Playback_GetDefaultTrickModeSettings(&playback->state.trickmode_params);
    playback->errorCallback = NEXUS_TaskCallback_Create(playback, NULL);
    if(!playback->errorCallback) {rc=BERR_TRACE(NEXUS_OUT_OF_SYSTEM_MEMORY);goto err_error_callback;}
    playback->endOfStreamCallback = NEXUS_TaskCallback_Create(playback, NULL);
    if(!playback->endOfStreamCallback) {rc=BERR_TRACE(NEXUS_OUT_OF_SYSTEM_MEMORY);goto err_end_of_stream_callback;}
    playback->beginningOfStreamCallback = NEXUS_TaskCallback_Create(playback, NULL);
    if(!playback->beginningOfStreamCallback) {rc=BERR_TRACE(NEXUS_OUT_OF_SYSTEM_MEMORY);goto err_beginning_of_stream_callback;}
    playback->parsingErrorCallback = NEXUS_TaskCallback_Create(playback, NULL);
    if(!playback->parsingErrorCallback) {rc=BERR_TRACE(NEXUS_OUT_OF_SYSTEM_MEMORY);goto err_parsing_error_callback;}

    NEXUS_Playback_GetDefaultSettings(&playback->params);

    rc = BKNI_CreateEvent(&playback->ack_event);
    if(rc!=BERR_SUCCESS) { rc = BERR_TRACE(rc); goto err_ack_event;}

    playback->playpump_event = NULL;
    playback->playpump_event_callback = NULL;

    b_play_media_time_test();
#if B_PLAYBACK_CAPTURE
    playback->capture.has_data = false;
    playback->capture.no = 0;
    playback->capture.fout = NULL;
#endif

    return playback;

err_ack_event:
    NEXUS_TaskCallback_Destroy(playback->parsingErrorCallback);
err_parsing_error_callback:
    NEXUS_TaskCallback_Destroy(playback->beginningOfStreamCallback);
err_beginning_of_stream_callback:
    NEXUS_TaskCallback_Destroy(playback->endOfStreamCallback);
err_end_of_stream_callback:
    NEXUS_TaskCallback_Destroy(playback->errorCallback);
err_error_callback:
    BKNI_Free(playback);
err_alloc:
    return NULL;
}


void
NEXUS_Playback_ClosePidChannel(NEXUS_PlaybackHandle playback, NEXUS_PidChannelHandle pidChannel)
{
    NEXUS_Error rc;
    NEXUS_Playback_P_PidChannel *play_pid;

    BDBG_OBJECT_ASSERT(playback, NEXUS_Playback);

    BLST_S_DICT_FIND(&playback->pid_list, play_pid, pidChannel, pidChn, link);
    if(play_pid==NULL) {
        BDBG_WRN(("NEXUS_Playback_ClosePidChannel: %#lx can't found pid:%#lx", (unsigned long)playback, (unsigned long)pidChannel));
        rc = BERR_TRACE(NEXUS_INVALID_PARAMETER);
        return;
    }

    if (play_pid->cfg.pidSettings.pidType == NEXUS_PidType_eVideo) {
        NEXUS_VideoDecoderPlaybackSettings playbackSettings;
        NEXUS_P_Playback_VideoDecoder_GetPlaybackSettings(play_pid, &playbackSettings);
        playbackSettings.firstPts.callback = NULL;
        playbackSettings.firstPtsPassed.callback = NULL;
        (void)NEXUS_P_Playback_VideoDecoder_SetPlaybackSettings(play_pid, &playbackSettings);
        NEXUS_CallbackHandler_Stop(playback->videoDecoderFirstPts);
        NEXUS_CallbackHandler_Stop(playback->videoDecoderFirstPtsPassed);
    }

    BDBG_ASSERT(play_pid->ref_cnt>0);
    play_pid->ref_cnt--;
    if(play_pid->ref_cnt==0) {
        BLST_S_DICT_REMOVE(&playback->pid_list, play_pid, pidChannel, NEXUS_Playback_P_PidChannel, pidChn, link);
        BDBG_ASSERT(play_pid);
        BDBG_ASSERT(playback->params.playpump);
        rc = NEXUS_Playpump_ClosePidChannel(playback->params.playpump, play_pid->pidChn);
        if(rc!=NEXUS_SUCCESS) {rc = BERR_TRACE(rc);}
        BKNI_Free(play_pid);
    }
    return;
}

void
NEXUS_Playback_CloseAllPidChannels(NEXUS_PlaybackHandle playback)
{
    NEXUS_Playback_P_PidChannel *pid;

    /* clear all pid channels */
    while(NULL!=(pid = BLST_S_FIRST(&playback->pid_list))) {
        /* use NEXUS_Playback_ClosePidChannel so that other cleanup will happen */
        NEXUS_Playback_ClosePidChannel(playback, pid->pidChn);
    }
    return;
}

void
NEXUS_Playback_GetDefaultPidChannelSettings(NEXUS_PlaybackPidChannelSettings *pSettings)
{
    BDBG_ASSERT(pSettings);
    BKNI_Memset(pSettings, 0, sizeof(*pSettings));
    NEXUS_Playpump_GetDefaultOpenPidChannelSettings(&pSettings->pidSettings);
    BDBG_ASSERT(pSettings->pidSettings.pidType == NEXUS_PidType_eUnknown);
    return;
}

NEXUS_PidChannelHandle
NEXUS_Playback_OpenPidChannel(NEXUS_PlaybackHandle playback, unsigned pidNo, const NEXUS_PlaybackPidChannelSettings *pSettings)
{
    NEXUS_PlaybackPidChannelSettings settings;
    NEXUS_Playback_P_PidChannel *play_pid;
    NEXUS_Error rc;
    unsigned playpump_pidNo;

    BDBG_OBJECT_ASSERT(playback, NEXUS_Playback);
    if(pSettings==NULL) {
        NEXUS_Playback_GetDefaultPidChannelSettings(&settings);
        pSettings = &settings;
    }

    /* if pidChannelIndex is specified, this is a special case that requires the app to manage its pid channels more. */
    if (pSettings->pidSettings.pidSettings.pidChannelIndex != -1) {
        NEXUS_PidChannelStatus pidStatus;
        /* look up existing pid channels for the same pidChannelIndex */
        for(play_pid=BLST_S_FIRST(&playback->pid_list); play_pid; play_pid=BLST_S_NEXT(play_pid, link)) {
            rc = NEXUS_PidChannel_GetStatus(play_pid->pidChn, &pidStatus);
            if(rc==NEXUS_SUCCESS && (int)pidStatus.pidChannelIndex == pSettings->pidSettings.pidSettings.pidChannelIndex) {
                if(play_pid->pid != pidNo) {
                    BDBG_ERR(("Cannot open the same pidChannelIndex (%d) with different pids (0x%x and 0x%x)", pSettings->pidSettings.pidSettings.pidChannelIndex, play_pid->pid, pidNo));
                    return NULL;
                }
                play_pid->ref_cnt++;
                goto done;
            }
        }
    /* else, allow the new NEXUS_PidChannelHandle to be opened, even if a NEXUS_PidChannelHandle already exists for this pid on a different pidChannelIndex.
       This is needed to support playpump multiplexing. */
    }
    else {
        for(play_pid=BLST_S_FIRST(&playback->pid_list); play_pid; play_pid=BLST_S_NEXT(play_pid, link)) {
            if(play_pid->pid == pidNo) {
                BDBG_MSG(("NEXUS_Playback_OpenPidChannel: %#lx detected duplicated pid %u (%#lx:%u)", (unsigned long)playback, (unsigned)pidNo, (unsigned long)play_pid, play_pid->ref_cnt));
                if(BKNI_Memcmp(pSettings, &play_pid->cfg, sizeof(*pSettings))!=0) {
                    BDBG_WRN(("NEXUS_Playback_OpenPidChannel: %#lx detected duplicated pid %u (%#lx:%u) with non-compatible settings", (unsigned long)playback, (unsigned)pidNo, (unsigned long)play_pid, play_pid->ref_cnt));
                }
                play_pid->ref_cnt++;
                goto done;
            }
        }
    }

    if(playback->params.playpump==NULL) {
        BDBG_WRN(("NEXUS_Playback_OpenPidChannel: %#lx pid could only be open if playpump is attached", (unsigned long)playback));
        rc = BERR_TRACE(BERR_NOT_SUPPORTED);
        goto err_playpump;
    }
    play_pid = BKNI_Malloc(sizeof(*play_pid));
    if(play_pid==NULL) { rc=BERR_TRACE(NEXUS_OUT_OF_SYSTEM_MEMORY);goto err_alloc;}
    playpump_pidNo = pidNo;

    switch(playback->params.playpumpSettings.transportType) {
    default:
        break;
#if 0
    case NEXUS_TransportType_eMp4:
    case NEXUS_TransportType_eMkv:
        break;
#endif
    case NEXUS_TransportType_eEs:
        if(playback->params.enableStreamProcessing) {
            playpump_pidNo = 0xC0;
        }
        break;
    }

    BDBG_MSG(("NEXUS_Playback_OpenPidChannel: %#lx pid %#lx mapped %u->%#x", (unsigned long)playback, (unsigned long)play_pid, (unsigned)pidNo, (unsigned)playpump_pidNo));
    play_pid->pidChn = NEXUS_Playpump_OpenPidChannel(playback->params.playpump, playpump_pidNo, &pSettings->pidSettings);
    if(!play_pid->pidChn) { rc = BERR_TRACE(BERR_NOT_SUPPORTED);goto err_open_pid;}
    play_pid->pid = pidNo;
    play_pid->ref_cnt = 1;
    play_pid->cfg = *pSettings;

    BLST_S_DICT_ADD(&playback->pid_list, play_pid, NEXUS_Playback_P_PidChannel, pidChn, link, err_duplicate);

done:
    return play_pid->pidChn;

err_duplicate:
    rc = BERR_TRACE(BERR_INVALID_PARAMETER);
    NEXUS_Playpump_ClosePidChannel(playback->params.playpump, play_pid->pidChn);
err_open_pid:
    BKNI_Free(play_pid);
err_alloc:
err_playpump:
    return NULL;

}

NEXUS_Error
NEXUS_Playback_GetPidChannelSettings(NEXUS_PlaybackHandle playback, NEXUS_PidChannelHandle pidChannel, NEXUS_PlaybackPidChannelSettings *pSettings)
{
    const NEXUS_Playback_P_PidChannel *pid;
    NEXUS_Error rc;
    BDBG_OBJECT_ASSERT(playback, NEXUS_Playback);
    BDBG_ASSERT(pSettings);

    BLST_S_DICT_FIND(&playback->pid_list, pid, pidChannel, pidChn, link);
    if(!pid) {
        rc = BERR_TRACE(NEXUS_INVALID_PARAMETER);
        goto err_invalid_pid;
    }
    *pSettings = pid->cfg;
    return BERR_SUCCESS;
err_invalid_pid:
    return rc;
}

NEXUS_Error
NEXUS_Playback_SetPidChannelSettings( NEXUS_PlaybackHandle playback, NEXUS_PidChannelHandle pidChannel, const NEXUS_PlaybackPidChannelSettings *pSettings)
{
    NEXUS_Playback_P_PidChannel *pid;
    NEXUS_Error rc;
    BDBG_OBJECT_ASSERT(playback, NEXUS_Playback);
    BDBG_ASSERT(pSettings);

    BLST_S_DICT_FIND(&playback->pid_list, pid, pidChannel, pidChn, link);
    if(!pid) { rc = BERR_TRACE(NEXUS_INVALID_PARAMETER); goto err_invalid_pid; }

    if(BKNI_Memcmp(&pid->cfg.pidSettings, &pSettings->pidSettings, sizeof(pSettings->pidSettings))!=0) { rc = BERR_TRACE(NEXUS_NOT_SUPPORTED);goto err_settings; } /* we can't change playpump pid configuration */
    pid->cfg.pidTypeSettings = pSettings->pidTypeSettings;

    if (playback->state.state != eStopped) {
        /* reapply current decoder settings */
        rc = b_play_trick_set_pid(playback, pid, NULL);
        if (rc) {rc = BERR_TRACE(rc); goto err_settings;}
    }

    return BERR_SUCCESS;

err_settings:
err_invalid_pid:
    return rc;
}

static void
NEXUS_Playback_P_KillPlaypumpThread(NEXUS_PlaybackHandle playback)
{
    playback->thread_terminate = true;
    BDBG_ASSERT(playback->playpump_thread_event);
    BKNI_SetEvent(playback->playpump_thread_event);
    NEXUS_UnlockModule();
    BDBG_MSG(("killing playpump_thread ..."));
    NEXUS_Thread_Destroy(playback->playpump_thread);
    BDBG_MSG(("killing playpump_thread ... done"));
    NEXUS_LockModule();
    playback->playpump_thread = NULL;
    return;
}


void
NEXUS_Playback_Destroy( NEXUS_PlaybackHandle playback)
{
    BDBG_OBJECT_ASSERT(playback, NEXUS_Playback);

    if(playback->state.state != eStopped) {
        BDBG_WRN(("NEXUS_Playback_Destroy: destroying playback without stopping"));
        NEXUS_Playback_Stop(playback);
    }
    NEXUS_Playback_CloseAllPidChannels(playback);

    if(playback->playpump_thread) {
        NEXUS_Playback_P_KillPlaypumpThread(playback);
    }
    if(playback->playpump_thread_event) {
        BKNI_DestroyEvent(playback->playpump_thread_event);
    }
    if(playback->playpump_event) {
        BDBG_ASSERT(playback->playpump_event_callback);
        NEXUS_UnregisterEvent(playback->playpump_event_callback);
        BKNI_DestroyEvent(playback->playpump_event);
    }
    BKNI_DestroyEvent(playback->ack_event);
    NEXUS_CallbackHandler_Shutdown(playback->dataCallbackHandler);
    NEXUS_CallbackHandler_Shutdown(playback->videoDecoderFirstPts);
    NEXUS_CallbackHandler_Shutdown(playback->videoDecoderFirstPtsPassed);
    NEXUS_TaskCallback_Destroy(playback->parsingErrorCallback);
    NEXUS_TaskCallback_Destroy(playback->errorCallback);
    NEXUS_TaskCallback_Destroy(playback->endOfStreamCallback);
    NEXUS_TaskCallback_Destroy(playback->beginningOfStreamCallback);

    BDBG_OBJECT_DESTROY(playback, NEXUS_Playback);
    BKNI_Free(playback);
    return;
}


static int
NEXUS_P_Playback_GetPriority(void *cntx)
{
    NEXUS_PlaybackHandle playback=cntx;
    NEXUS_PlaypumpStatus status;
    NEXUS_Error rc;
    int factor;

    /* no b_lock here because the state check is atomic and bplaypump_get_status
    has its own synchronization. */
    if (playback->state.mode == NEXUS_PlaybackState_ePlaying) {
        BDBG_ASSERT(playback->params.playpump);

        rc = NEXUS_Playpump_GetStatus(playback->params.playpump, &status);
        if(rc==NEXUS_SUCCESS) {
            factor  = (status.fifoSize - status.fifoDepth)/(status.fifoSize/256); /* priority is 0 .. 256 */
            /* make read priority grow linearly with space in the fifo*/
            BDBG_MSG_FLOW(("[%#x] level %d%% priority %d", playback, status.fifoDepth*100/status.fifoSize, factor));
     } else {
            factor = 0;
        }
    } else {
        factor = 32;
    }

    return factor;
}


/**
Relocate BNAV_Player to the current decode location.
Call these before changing pvr state in order to get the current pts.
**/
void
b_play_update_location(NEXUS_PlaybackHandle p)
{
    NEXUS_Error rc;
    uint32_t pts;

    rc = b_play_getpts(p, &pts);
    if(rc==NEXUS_SUCCESS) {
        p->state.validPts = true;
        bmedia_player_update_position(p->media_player, pts);
    } else {
        p->state.validPts = false;
        BDBG_MSG(("Can't reset location because no pts."));
    }
    return;
}

const NEXUS_Playback_P_PidChannel *
b_play_get_video_decoder(NEXUS_PlaybackHandle playback)
{
    const NEXUS_Playback_P_PidChannel *pid;
    for(pid = BLST_S_FIRST(&playback->pid_list); pid ; pid = BLST_S_NEXT(pid, link)) {
        if(pid->cfg.pidSettings.pidType == NEXUS_PidType_eVideo) {
            if (pid->cfg.pidTypeSettings.video.decoder || pid->cfg.pidTypeSettings.video.simpleDecoder) return pid;
        }
    }
    return NULL;
}

static bool
b_play_has_audio_decoder(NEXUS_PlaybackHandle playback)
{
    const NEXUS_Playback_P_PidChannel *pid;
    for(pid = BLST_S_FIRST(&playback->pid_list); pid ; pid = BLST_S_NEXT(pid, link)) {
        if(pid->cfg.pidSettings.pidType == NEXUS_PidType_eAudio) {
            if (pid->cfg.pidTypeSettings.audio.primary || pid->cfg.pidTypeSettings.audio.secondary || pid->cfg.pidTypeSettings.audio.simpleDecoder) {
                return true;
            }
        }
    }
    return false;
}

bool
b_play_decoders_in_tsm_mode(NEXUS_PlaybackHandle playback)
{
    NEXUS_Error rc;
    const NEXUS_Playback_P_PidChannel *pid;
    for(pid = BLST_S_FIRST(&playback->pid_list); pid ; pid = BLST_S_NEXT(pid, link)) {
        if(pid->cfg.pidSettings.pidType == NEXUS_PidType_eVideo) {
            NEXUS_VideoDecoderStatus status;
            rc = NEXUS_P_Playback_VideoDecoder_GetStatus(pid, &status);
            if (rc) return false;
            if (!status.tsm) return false;
        }
        else if(pid->cfg.pidSettings.pidType == NEXUS_PidType_eAudio) {
            NEXUS_AudioDecoderStatus status;
            rc = NEXUS_P_Playback_AudioDecoder_GetStatus(pid, &status);
            if (rc) return false;
            if (!status.tsm) return false;
        }
    }
    return true;
}

NEXUS_Error
b_play_getpts(NEXUS_PlaybackHandle p, uint32_t *pts)
{
    NEXUS_Error rc;
    NEXUS_Error result=NEXUS_NOT_SUPPORTED;
    const NEXUS_Playback_P_PidChannel *pid;

    BDBG_ASSERT(pts);
    *pts = 0;

    /* check video before checking audio */
    pid = b_play_get_video_decoder(p);
    if (pid) {
        NEXUS_VideoDecoderStatus status;
        rc = NEXUS_P_Playback_VideoDecoder_GetStatus(pid, &status);
        if(rc==NEXUS_SUCCESS) {
            if(status.ptsType == NEXUS_PtsType_eCoded || status.ptsType == NEXUS_PtsType_eInterpolatedFromValidPTS || p->actualTransportType==NEXUS_TransportType_eEs) {
                *pts = status.pts;
                result = NEXUS_SUCCESS;
            }
        }
    } else {
        bool found = false;
        for(pid = BLST_S_FIRST(&p->pid_list); pid ; pid = BLST_S_NEXT(pid, link)) {
            if(pid->cfg.pidSettings.pidType == NEXUS_PidType_eAudio) {
                NEXUS_AudioDecoderStatus audioStatus;
                found = true;
                rc = NEXUS_P_Playback_AudioDecoder_GetStatus(pid, &audioStatus);
                if(rc==BERR_SUCCESS) {
                    if(audioStatus.ptsType == NEXUS_PtsType_eCoded || audioStatus.ptsType == NEXUS_PtsType_eInterpolatedFromValidPTS || p->actualTransportType==NEXUS_TransportType_eEs) {
                        *pts = audioStatus.pts;
                        result = NEXUS_SUCCESS;
                        break;
                    }
                }
            }
        }
        if(!found) {
            BDBG_WRN(("Unable to look up position because no audio decoder was provided in any NEXUS_PlaybackPidChannelSettings."));
        }
    }
    return result;
}



void
NEXUS_Playback_GetDefaultTrickModeSettings(NEXUS_PlaybackTrickModeSettings *trickmode)
{
    BKNI_Memset(trickmode, 0, sizeof(*trickmode));
    trickmode->mode = NEXUS_PlaybackHostTrickMode_eNone;
    trickmode->rate = NEXUS_NORMAL_PLAY_SPEED;
    trickmode->mode_modifier = 1;
    trickmode->maxDecoderRate = 1.2 * NEXUS_NORMAL_PLAY_SPEED;
    trickmode->rateControl = NEXUS_PlaybackRateControl_eDecoder;
    trickmode->skipControl = NEXUS_PlaybackSkipControl_eHost;
    trickmode->brcmTrickMode = true;
    return;
}

static int bplay_p_accurate_seek(NEXUS_PlaybackHandle p, bmedia_player_pos position)
{
    uint32_t pts = 0;
    const NEXUS_Playback_P_PidChannel *pid = b_play_get_video_decoder(p);
    NEXUS_VideoDecoderHandle decode;
    int rc;
    b_trick_settings settings;

    /* requires regular decoder. does not support simpleDecoder */
    if (!pid) {
        return BERR_TRACE(NEXUS_INVALID_PARAMETER);
    }
    decode = pid->cfg.pidTypeSettings.video.decoder;
    if (!decode) {
        return BERR_TRACE(NEXUS_INVALID_PARAMETER);
    }

    /* must flush before NEXUS_VideoDecoder_SetStartPts is called to avoid a false detect
    with existing pictures in the queue */
    b_play_flush(p);

    switch (p->params.playpumpSettings.transportType) {
    case NEXUS_TransportType_eTs:
    case NEXUS_TransportType_eAsf:
    case NEXUS_TransportType_eAvi:
        break;
    default:
        /* not supported for other containers
        for MKV and MP4, get_next_frame is an asynchronous function. we will need to devise a different technique. */
        return -1;
    }

    b_play_trick_get(p, &settings);
    if (settings.state != b_trick_state_normal) {
        /* only applies to normal play mode */
        return 0;
    }

    if (!bmedia_player_lookup_pts(p->media_player, position, &pts)) {

        switch (p->params.playpumpSettings.transportType) {
        case NEXUS_TransportType_eAsf:
        case NEXUS_TransportType_eAvi:
            {
            bmedia_player_decoder_mode mode;
            bmedia_player_entry entry;
            /* jump back to the previous key frame */
            bmedia_player_set_direction(p->media_player, -33, -BMEDIA_TIME_SCALE_BASE, &mode);
            do {
                if (bmedia_player_next(p->media_player, &entry)) {
                    entry.timestamp = position;
                    break;
                }
            }
            while (entry.type == bmedia_player_entry_type_file && entry.start == 0);
            bmedia_player_set_direction(p->media_player, 0, BMEDIA_TIME_SCALE_BASE, &mode);
            bmedia_player_seek(p->media_player, entry.timestamp);
            BDBG_WRN(("accurate seek: from timestamp %d to %d (pts %#x)", entry.timestamp, position, pts));
            }
            break;
        default:
            /* bcmplayer already seeks back to previous I frame */
            BDBG_WRN(("accurate seek: to %d (pts %#x)", position, pts));
            break;
        }

        /* tell decoder to discard until this pts */
        rc = NEXUS_VideoDecoder_SetStartPts(decode, pts);
        if (rc) return BERR_TRACE(rc);
    }
    else {
        BDBG_WRN(("Unable to do accurateSeek position=%d(%#x), decode=%p", position, pts, decode));
    }

    /* start state machine to allow audio to chase video's PTS. This keeps a full audio CDB from
    hanging video as it seeks for its start PTS. the state machine is:
    1) wait for video first PTS
    2) start audio pause (which launches the rap_monitor_timer)
    3) wait for video first PTS passed, which means we've found the start pts
    4) stop audio pause
    */
    p->state.inAccurateSeek = true;
    return 0;
}

/*
Resume normal playback. This should not be called immediately after bplay_start because it's
not needed.

We may come from the following states:
1) stc trick modes.
2) decoder pause from decoder trick or normal play.
3) decoder pause from host trick. requires reset_location.
4) decoder trick.
5) host trick. requires reset_location.

The way to distinguish 2 & 3 is to use the BNAV_Player state. See below.
*/
static NEXUS_Error
bplay_p_play_impl(NEXUS_PlaybackHandle p, bool *restart, bool flush, bmedia_player_pos position)
{
    NEXUS_Error rc = NEXUS_SUCCESS;
    b_trick_settings settings;
    bmedia_player_decoder_mode mode;
    bmedia_player_decoder_config config;

    *restart = false;

    if (flush) {
        b_play_flush(p);
    }

    /* XXX this should be avoided in favor of calling bmedia_player_set_direction, and then handling bmedia_player_decoder_mode */
    b_play_trick_get(p, &settings);
    settings.forward = true;
    settings.state = b_trick_state_normal;
    settings.decode_rate = NEXUS_NORMAL_PLAY_SPEED;
    settings.decode_mode = NEXUS_VideoDecoderDecodeMode_eAll;
    settings.fragmented = false;
    settings.reordering_mode = NEXUS_VideoDecoderReorderingMode_eNone;
    settings.stc_trick = p->params.stcTrick;
    settings.force_source_frame_rate = 0;
    NEXUS_Playback_GetDefaultTrickModeSettings(&p->state.trickmode_params);
    rc = b_play_trick_set(p, &settings);
    if (rc != NEXUS_SUCCESS) { return BERR_TRACE(rc); }

    bmedia_player_get_decoder_config(p->media_player, &config);
    config.host_mode = bmedia_player_host_trick_mode_auto;
    config.mode_modifier = 1; /* unused */
    rc = bmedia_player_set_decoder_config(p->media_player, &config);
    if (rc) return BERR_TRACE(rc);

    if (p->state.decoder_flushed) {
        /* resync player */
        bmedia_player_set_direction(p->media_player, 0, BMEDIA_TIME_SCALE_BASE, &mode); /* normal decode */

        if (p->params.accurateSeek) {
            bplay_p_accurate_seek(p, position);
        }

        *restart = true;
    }

    p->state.direction = 1;
    p->state.mode = NEXUS_PlaybackState_ePlaying;
    p->state.frame_advance = NEXUS_Playback_P_FrameAdvance_Forward;
    return rc;
}

NEXUS_Error
bplay_p_play(NEXUS_PlaybackHandle p, bool *restart, bool flush)
{
    bmedia_player_pos position;

    BDBG_MSG(("resume play"));
    b_play_update_location(p);
    bmedia_player_tell(p->media_player, &position);
    return bplay_p_play_impl(p, restart, flush, position);
}

NEXUS_Error
bplay_p_play_from(NEXUS_PlaybackHandle p, bmedia_player_pos position)
{
    bool restart;
    bmedia_player_seek(p->media_player, position);
    return bplay_p_play_impl(p, &restart, true, position);
}


NEXUS_Error
bplay_p_pause(NEXUS_PlaybackHandle p)
{
    b_trick_settings settings;
    BDBG_MSG(("going to a pause, state.state %d, state.mode %d", p->state.state, p->state.mode));
    if (p->state.mode == NEXUS_PlaybackState_ePaused) {
        return NEXUS_SUCCESS;
    }
    p->state.mode = NEXUS_PlaybackState_ePaused;
    p->state.loopedDuringPause = false;

    /* during pause, we have a timer so we can notify the caller of internal changes trim continuous record trim */
    if (!p->state.timer) {
        p->state.timer = NEXUS_ScheduleTimer(B_FRAME_DISPLAY_TIME * 5, b_play_timer, p);   /* schedule another call into the same function after while */
    }

    b_play_trick_get(p, &settings);
    settings.decode_rate = 0;
    return b_play_trick_set(p, &settings);
}

/**
Callback from brecord
**/
void
NEXUS_Playback_RecordProgress_priv(NEXUS_PlaybackHandle p)
{
    BDBG_OBJECT_ASSERT(p, NEXUS_Playback);
    NEXUS_ASSERT_MODULE();

    if (p->state.start_paused) {
        return;
    }

    if (p->state.state != eWaitingRecord) {
        BDBG_MSG_FLOW(("Got record event, but not waiting for record(%d), ignore", p->state.state));
        if (p->state.state == eWaitingPlayback) {
            goto restart; /* Kickstart playback */
        }
        return;
    }

    BDBG_MSG(("NEXUS_Playback_RecordProgress_priv %d", p->state.read_size));
    if (p->state.read_size==0) {
        bmedia_player_pos pos;
        bmedia_player_status status;

        bmedia_player_tell(p->media_player, &pos);
        bmedia_player_get_status(p->media_player, &status);
        if (pos > status.bounds.first) {
            /* we are waiting for an index, try to get new entry */
            b_play_next_frame(p);
        }
        else {
            /* if we've fallen off the beginning of a continuous record, we need to reposition */
            p->state.state = eWaitingPlayback;
        }
    }
    else {
       /* we are waiting for a data */
        p->state.state = eWaitingIo;
        NEXUS_File_AsyncRead(p->file->file.data, p->state.buf, p->state.read_size, NEXUS_MODULE_SELF, b_play_frame_data, p);
    }

restart:
    b_play_check_buffer(p);
    return;
}

/**
Whatever state you're in, get into a paused state that can be
used for frame advance. This means paused-from-play.
**/
static NEXUS_Error
bplay_p_get_into_paused_play_state(NEXUS_PlaybackHandle p, bool *restart)
{
    NEXUS_Error rc;
    rc = bplay_p_play(p, restart, true);
    if (rc!=NEXUS_SUCCESS) {rc=BERR_TRACE(rc);}
    rc = bplay_p_pause(p);
    if (rc!=NEXUS_SUCCESS) {rc=BERR_TRACE(rc);}
    *restart = true; /* we've already flushed, but we need to restart playback after this */
    p->state.frame_advance = NEXUS_Playback_P_FrameAdvance_Forward;
    return rc;
}

/* set b_trick_settings based on bmedia_player_decoder_mode and (optionally) a NEXUS_PlaybackTrickModeSettings override */
static void
NEXUS_Playback_P_ConvertPlayerDecodeMode(NEXUS_PlaybackHandle p, const bmedia_player_decoder_mode *mode,  b_trick_settings *trick_settings, const NEXUS_PlaybackTrickModeSettings *params)
{
    unsigned abs_time_scale;
    BDBG_CASSERT(NEXUS_VideoDecoderDecodeMode_eAll==(NEXUS_VideoDecoderDecodeMode)bmedia_player_decoder_frames_all);
    BDBG_CASSERT(NEXUS_VideoDecoderDecodeMode_eIP==(NEXUS_VideoDecoderDecodeMode)bmedia_player_decoder_frames_IP);
    BDBG_CASSERT(NEXUS_VideoDecoderDecodeMode_eI==(NEXUS_VideoDecoderDecodeMode)bmedia_player_decoder_frames_I);
    trick_settings->decode_mode = (NEXUS_VideoDecoderDecodeMode)mode->display_frames;

    BDBG_CASSERT(NEXUS_VideoDecoderReorderingMode_eNone==(NEXUS_VideoDecoderReorderingMode)bmedia_player_reordering_mode_none);
    BDBG_CASSERT(NEXUS_VideoDecoderReorderingMode_eSequential==(NEXUS_VideoDecoderReorderingMode)bmedia_player_reordering_mode_sequential);
    BDBG_CASSERT(NEXUS_VideoDecoderReorderingMode_eInterleaved==(NEXUS_VideoDecoderReorderingMode)bmedia_player_reordering_mode_interleaved);
    BDBG_CASSERT(NEXUS_VideoDecoderReorderingMode_eChunkForward==(NEXUS_VideoDecoderReorderingMode)bmedia_player_reordering_mode_forward);
    BDBG_CASSERT(NEXUS_VideoDecoderReorderingMode_eChunkBackward==(NEXUS_VideoDecoderReorderingMode)bmedia_player_reordering_mode_backward);
    trick_settings->reordering_mode = (NEXUS_VideoDecoderReorderingMode)mode->reordering_mode;
    abs_time_scale = mode->time_scale >= 0 ? mode->time_scale : -mode->time_scale;
    if(mode->continuous) {
        trick_settings->decode_rate = abs_time_scale * (NEXUS_NORMAL_PLAY_SPEED/BMEDIA_TIME_SCALE_BASE);
        trick_settings->state = b_trick_state_normal;
    } else {
        trick_settings->decode_rate = NEXUS_NORMAL_PLAY_SPEED;
        if(mode->brcm) {
             trick_settings->state = b_trick_state_brcm_trick_mode;
             trick_settings->decode_rate = (abs_time_scale * (NEXUS_NORMAL_PLAY_SPEED/BMEDIA_TIME_SCALE_BASE));
        } else if(mode->dqt) {
             trick_settings->state = b_trick_state_display_queue_trick_mode;
        } else if(mode->tsm) {
            trick_settings->decode_rate = mode->time_scale * (NEXUS_NORMAL_PLAY_SPEED/BMEDIA_TIME_SCALE_BASE);
            trick_settings->state = b_trick_state_host_paced;
        } else if(mode->fragmented) {
            trick_settings->decode_rate = abs_time_scale * (NEXUS_NORMAL_PLAY_SPEED/BMEDIA_TIME_SCALE_BASE);
            trick_settings->state = b_trick_state_host_trick_mode;
            trick_settings->reordering_mode = trick_settings->forward ? NEXUS_VideoDecoderReorderingMode_eChunkForward : NEXUS_VideoDecoderReorderingMode_eChunkBackward;
        } else if(mode->reordering_mode!=bmedia_player_reordering_mode_none) {
            trick_settings->decode_rate = abs_time_scale * (NEXUS_NORMAL_PLAY_SPEED/BMEDIA_TIME_SCALE_BASE);
            trick_settings->state = b_trick_state_host_trick_mode;
        } else {
            trick_settings->decode_rate = abs_time_scale * (NEXUS_NORMAL_PLAY_SPEED/BMEDIA_TIME_SCALE_BASE);
            trick_settings->state = b_trick_state_host_trick_mode;
        }
    }
    /* apply custom modifications */
    if (params && params->mode!=NEXUS_PlaybackHostTrickMode_eNone) {
        /* override rate control */
        /* decode_rate is unsigned. decoder and STC rate can only be positive. in the future, SW STC could support negative rates. */
        trick_settings->decode_rate = params->rate>0?params->rate:-params->rate;
        trick_settings->stc_trick = (params->rateControl == NEXUS_PlaybackRateControl_eStream && p->params.stcChannel);
        switch(params->mode) {
        case NEXUS_PlaybackHostTrickMode_ePlayI:
            trick_settings->decode_mode = NEXUS_VideoDecoderDecodeMode_eI;
            break;
        case NEXUS_PlaybackHostTrickMode_ePlayIP:
            trick_settings->decode_mode = NEXUS_VideoDecoderDecodeMode_eIP;
            break;
        default:
            break;
        }
    } else {
        trick_settings->stc_trick = p->params.stcTrick;
    }
    return;
}

/**
The type of frame advance depends on the type of pause used. You must always be paused
before doing frame advance/reverse.

Frame advance (i.e. forward) is can be decoder-based or stc based.
Frame reverse is host-based.
**/
static NEXUS_Error
bplay_p_frameadvance(NEXUS_PlaybackHandle p, bool forward, bool *restart)
{
    NEXUS_Error rc;

    BDBG_MSG(("frame %s", forward?"advance":"reverse"));
    *restart = false;

    /* fifoMarkerCounter tells the wait_for_end routine to not check for a certain amount of time after a frame advance.
    If your system checks for static video PTS to detect EOF, this will give it time to move. */
    if (p->state.fifoMarkerCounter == 0) {
        unsigned cdbDepth;

        bplay_get_decode_mark(p, &p->state.fifoMarker, &cdbDepth);
        p->state.fifoMarkerCounter = 5;
    }

    if(forward && p->state.frame_advance != NEXUS_Playback_P_FrameAdvance_Forward) {
        rc = bplay_p_get_into_paused_play_state(p, restart);
        if(rc!=NEXUS_SUCCESS) {rc=BERR_TRACE(rc);}
    } else if(!forward && p->state.frame_advance != NEXUS_Playback_P_FrameAdvance_Reverse) {
        bmedia_player_decoder_mode mode;
        b_trick_settings settings;

        b_play_trick_get(p, &settings);
        b_play_update_location(p);
        bmedia_player_set_direction(p->media_player, -33 /* 33 ms */, -BMEDIA_TIME_SCALE_BASE, &mode);
        NEXUS_Playback_P_ConvertPlayerDecodeMode(p, &mode,  &settings, NULL);
        if(mode.discontinuity) {
            b_play_flush(p);
        }
        p->state.frame_advance = NEXUS_Playback_P_FrameAdvance_Reverse;
        *restart = true;
        settings.decode_rate = 0;
        settings.forward = false;
        b_play_trick_set(p, &settings);
    } else {
        BDBG_MSG(("continuing frame %s", forward?"advance":"reverse"));
    }

    p->state.direction = forward?1:-1;

    rc = b_play_trick_frameadvance(p);
    if(rc!=NEXUS_SUCCESS) {rc=BERR_TRACE(rc);}
    p->state.mode = NEXUS_PlaybackState_ePaused;
    return rc;
}

static NEXUS_Error NEXUS_Playback_P_CheckWaitingIo(NEXUS_PlaybackHandle playback, bool stopping)
{
    unsigned i = 0;
    unsigned ioTimeout = playback->params.ioTimeout; /* exposed in the NEXUS_PlaybackSettings if we support recovery from io error by killing the File i/o thread. */

/* period of 1/10th of a second */
#define IO_TIMEOUT_PERIOD 100
    if (playback->state.state == eWaitingIo) { /* WaitingIo it's non cancelable state, so we should wait for I/O to complete */
        playback->state.state = stopping ? eStopping : eCancelIo;
        BDBG_MSG(("NEXUS_Playback_P_CheckWaitingIo %#lx waiting for I/O to complete", playback));
        do {
            NEXUS_Error rc;
            NEXUS_UnlockModule();
            rc = BKNI_WaitForEvent(playback->ack_event, IO_TIMEOUT_PERIOD);
            NEXUS_LockModule();
            if (rc == BERR_TIMEOUT) {
                BDBG_WRN(("NEXUS_Playback_P_CheckWaitingIo %#lx timed out, keep waiting", (unsigned long)playback));
            }
            else if (rc!=0) {
                return BERR_TRACE(rc);
            }
            if (++i >= ioTimeout / IO_TIMEOUT_PERIOD) {
                BDBG_ERR(("NEXUS_Playback_P_CheckWaitingIo %#lx timed out. Canceling File thread.", (unsigned long)playback));
                NEXUS_FilePlay_Cancel(playback->file);
                i = 0;
                /* we keep looping. File will spawn a new thread and will invoke the callback with an error. Playback should go to eAborted. */
            }
        } while (!(playback->state.state == eIoCanceled || playback->state.state == eStopped || playback->state.state == eAborted));
    }
    if (playback->state.state == eAborted) {
        return -1;
    }
    return 0;
}


/*
* This function is used to synchronize control with
* data pump. it return b_ok if synchronization suceeded,
* false otherwise.
*/
static NEXUS_Error
bplay_sync_playback(NEXUS_PlaybackHandle p)
{
    BERR_Code rc;

    if (p->state.start_paused) {
        /* if playback wasn't started yet, just do nothing. we should be in WaitingPlayback state. */
        BDBG_ASSERT(p->state.state == eWaitingPlayback);
        return NEXUS_SUCCESS;
    }
    if (p->state.state == eStopped) {
        return BERR_TRACE(NEXUS_NOT_SUPPORTED);
    }
    if (p->state.state == eAborted) {
        /* something went wrong. we need the app to stop. */
        return BERR_TRACE(NEXUS_UNKNOWN);
    }

    rc = NEXUS_Playback_P_CheckWaitingIo(p, false);
    if (rc) return BERR_TRACE(rc);

    p->state.reset = false;

    /* still locked */
    return NEXUS_SUCCESS;
}

/* this function is used to jumpstart data pump if it was cancelled because of bplay_sync_playback */
static void
bplay_restart_playback(NEXUS_PlaybackHandle p, bool restart_data_flow)
{
    if (p->state.start_paused) {
        /* if playback wasn't started yet, just do nothing. we should be in WaitingPlayback state. */
        BDBG_ASSERT(p->state.state == eWaitingPlayback);
        return;
    }

    /* if restart_data_flow is false, then either the API has failed or we're in a paused state and
    don't want to restart. in all other cases, it's true. */
    if (restart_data_flow) {
        /* 3 states override this */
        restart_data_flow = (
            p->state.state != eIoCanceled &&
            p->state.state != eWaitingPlayback &&
            p->state.state != eWaitingRecord);
    }

    if (p->state.reset) {
        BDBG_MSG(("I/O reset was requested"));
        if(p->state.media.entry.atom) {
            batom_release(p->state.media.entry.atom);
            p->state.media.entry.atom = NULL;
        }
        b_play_flush(p);
        bplay_p_clear_buffer(p);
        p->state.state = eTransition;
        /* start data flowing */
        b_play_next_frame(p);
    }
    /* PR 21643 - The eWaitingRecord exception was added because if you pause immediately after starting a timeshift record,
    you could be in waiting record state. we need to restart. */
    else if (restart_data_flow)
    {
        BDBG_MSG(("Restart: start data flowing"));
        b_play_next_frame(p);
    }
    else if (p->state.state == eWaitingRecord)
    {
        BDBG_MSG(("Restart: start data flowing in eWaitingRecord"));
        if (p->state.read_size==0) {
            /* we are waiting for an index, try to get new entry */
            b_play_next_frame(p);
        }
        else {
           /* we are waiting for a data */
            p->state.state = eWaitingIo;
            NEXUS_File_AsyncRead(p->file->file.data, p->state.buf, p->state.read_size, NEXUS_MODULE_SELF, b_play_frame_data, p);
        }
    }
    else if (p->state.state == eIoCanceled)  {
        BDBG_MSG(("Restart: I/O was canceled, reviving it"));
        p->state.state = eWaitingIo;
        switch(p->state.io_size) {
        case B_MEDIA_ATOM_MAGIC:
            b_play_media_send_meta(p);
            break;
        case B_MEDIA_NEST_MAGIC:
            b_play_next_frame(p);
            break;
       default:
            b_play_frame_data(p, p->state.io_size);
            break;
        }
    }
    else if (p->state.state == eWaitingPlayback ||
             p->state.state == eTimer)
    {
        /* This section of code needs to handle all normal states that require no change. */
        BDBG_MSG(("Restart: no state change state=%d,mode=%d", p->state.state, p->state.mode));
    }
    else {
        /* If this occurs, something is broken in the state machine and must be fixed immediately. This
        is complex code and small changes can lead to disastrous lockups and reentrancy. */
        BDBG_ERR(("Restart: unknown state %d", p->state.state));
    }

    p->state.decoder_flushed = false;
    b_play_check_buffer(p);
    return;
}

/* this function is used to abort playback if trick/play/seek functions have failed, it's should be called instead of bplay_restart_playback */
void
NEXUS_Playback_P_AbortPlayback(NEXUS_PlaybackHandle p)
{
    BDBG_WRN(("NEXUS_Playback_P_AbortPlayback: %#x aborting", (unsigned)p));
    if (p->state.start_paused) {
        /* if playback wasn't started yet, just do nothing. we should be in WaitingPlayback state. */
        BDBG_ASSERT(p->state.state == eWaitingPlayback);
        return;
    }

    /* save playback position */
    b_play_update_location(p);
    bmedia_player_tell(p->media_player, &p->state.abortPosition);

    b_play_flush(p);
    if(p->state.media.entry.atom) {
        batom_release(p->state.media.entry.atom);
        p->state.media.entry.atom = NULL;
    }
    p->state.state = eAborted;
    p->state.decoder_flushed = false;
    return;
}


/* rest of functions is a public API to control playback */
NEXUS_Error
NEXUS_Playback_Play(NEXUS_PlaybackHandle p)
{
    NEXUS_Error rc;
    BDBG_OBJECT_ASSERT(p, NEXUS_Playback);

    if (p->state.start_paused) {
        BDBG_MSG(("NEXUS_Playback_Play: %#lx starting playback from paused state", (unsigned long)p));
        p->state.start_paused = false;
        p->state.data_source(p);
        return NEXUS_SUCCESS;
    }

    if (p->state.mode == NEXUS_PlaybackState_ePlaying) {
        BDBG_WRN(("Already in the playback mode"));
        return NEXUS_SUCCESS;
    }

    rc = bplay_sync_playback(p);
    if (rc!=NEXUS_SUCCESS) {rc=BERR_TRACE(rc); goto done; }

    rc = bplay_p_play(p, &p->state.reset, false);
    if (rc!=NEXUS_SUCCESS) {rc=BERR_TRACE(rc);} /* fall through so bplay_restart_playback is called */

    if(rc==NEXUS_SUCCESS || p->params.seekErrorHandling==NEXUS_PlaybackErrorHandlingMode_eIgnore) {
        bplay_restart_playback(p, rc==NEXUS_SUCCESS);
    } else {
        NEXUS_Playback_P_AbortPlayback(p);
        rc = BERR_TRACE(rc);
    }
done:
    return rc;
}


NEXUS_Error
NEXUS_Playback_Pause(NEXUS_PlaybackHandle p)
{
    NEXUS_Error rc=NEXUS_SUCCESS;

    BDBG_OBJECT_ASSERT(p, NEXUS_Playback);

    if (p->state.start_paused) {
        BDBG_MSG(("NEXUS_Playback_Play: %#lx starting playback from paused state", (unsigned long)p));
        p->state.start_paused = false;
        p->state.data_source(p);
    } else if (p->state.mode == NEXUS_PlaybackState_ePaused) {
        BDBG_WRN(("Already in pause mode"));
        goto done;
    }

    rc = bplay_p_pause(p);
    if (rc!=NEXUS_SUCCESS) {rc=BERR_TRACE(rc);} /* fall through */

done:
    return rc;
}

NEXUS_Error
NEXUS_Playback_FrameAdvance(NEXUS_PlaybackHandle p, bool forward)
{
    NEXUS_Error rc;

    BDBG_OBJECT_ASSERT(p, NEXUS_Playback);


    if (p->state.mode != NEXUS_PlaybackState_ePaused) {
        BDBG_WRN(("Not in paused state"));
        rc = BERR_TRACE(BERR_NOT_SUPPORTED);
        goto done;
    }

    rc = bplay_sync_playback(p);
    if (rc!=NEXUS_SUCCESS) {rc=BERR_TRACE(rc); goto done; }

    rc = bplay_p_frameadvance(p, forward, &p->state.reset);
    if (rc!=NEXUS_SUCCESS) {rc=BERR_TRACE(rc);} /* fall through so bplay_restart_playback is called */

    bplay_restart_playback(p, rc==BERR_SUCCESS);

done:
    return rc;
}


static NEXUS_Error
b_play_set_media_player_config(NEXUS_PlaybackHandle p, const NEXUS_PlaybackTrickModeSettings *params)
{
    NEXUS_Error rc;
    bmedia_player_decoder_config config;

    BDBG_CASSERT( NEXUS_PlaybackHostTrickMode_eNone == (NEXUS_PlaybackHostTrickMode)bmedia_player_host_trick_mode_auto);
    BDBG_CASSERT( NEXUS_PlaybackHostTrickMode_eNormal ==  (NEXUS_PlaybackHostTrickMode)bmedia_player_host_trick_mode_normal);
    BDBG_CASSERT( NEXUS_PlaybackHostTrickMode_ePlayI == (NEXUS_PlaybackHostTrickMode)bmedia_player_host_trick_mode_I);
    BDBG_CASSERT( NEXUS_PlaybackHostTrickMode_ePlaySkipB == (NEXUS_PlaybackHostTrickMode)bmedia_player_host_trick_mode_skipB);
    BDBG_CASSERT( NEXUS_PlaybackHostTrickMode_ePlayIP == (NEXUS_PlaybackHostTrickMode)bmedia_player_host_trick_mode_IP);
    BDBG_CASSERT( NEXUS_PlaybackHostTrickMode_ePlaySkipP == (NEXUS_PlaybackHostTrickMode)bmedia_player_host_trick_mode_skipP);
    BDBG_CASSERT( NEXUS_PlaybackHostTrickMode_ePlayBrcm == (NEXUS_PlaybackHostTrickMode)bmedia_player_host_trick_mode_brcm);
    BDBG_CASSERT( NEXUS_PlaybackHostTrickMode_ePlayGop == (NEXUS_PlaybackHostTrickMode)bmedia_player_host_trick_mode_gop);
    BDBG_CASSERT( NEXUS_PlaybackHostTrickMode_eTimeSkip == (NEXUS_PlaybackHostTrickMode)bmedia_player_host_trick_mode_time_skip);

    bmedia_player_get_decoder_config(p->media_player, &config);
    b_play_update_media_player_config(p, &config);

    if (params->mode != NEXUS_PlaybackHostTrickMode_eNone && params->skipControl == NEXUS_PlaybackSkipControl_eDecoder) {
        switch(params->mode) {
        case NEXUS_PlaybackHostTrickMode_eNormal:
        case NEXUS_PlaybackHostTrickMode_ePlayI:
        case NEXUS_PlaybackHostTrickMode_ePlayIP:
            config.host_mode = bmedia_player_host_trick_mode_auto;
            break;
        default:
            /* decoder doesn't support other skip modes */
            return BERR_TRACE(BERR_NOT_SUPPORTED);
        }
    }
    else {
        config.host_mode = params->mode;
    }

    config.mode_modifier = params->mode_modifier;
    config.max_decoder_rate = params->maxDecoderRate/(NEXUS_NORMAL_PLAY_SPEED/BMEDIA_TIME_SCALE_BASE);
    if (params->mode != NEXUS_PlaybackHostTrickMode_eNone) {
        config.stc = (params->rateControl == NEXUS_PlaybackRateControl_eStream && p->params.stcChannel);
    }
    else {
        /* p->params.stcTrick is only used for automatic trick modes */
        config.stc = p->params.stcTrick;
    }
    config.brcm = params->brcmTrickMode;
    rc = bmedia_player_set_decoder_config(p->media_player, &config);
    if (rc) return BERR_TRACE(rc);

    return rc;
}


NEXUS_Error
NEXUS_Playback_TrickMode(NEXUS_PlaybackHandle p, const NEXUS_PlaybackTrickModeSettings *params)
{
    NEXUS_Error rc;
    int new_direction;
    b_trick_settings trick_settings;
    bmedia_player_decoder_mode mode;
    NEXUS_PlaybackTrickModeSettings modified_params;

    BDBG_OBJECT_ASSERT(p, NEXUS_Playback);
    if (params->mode >= NEXUS_PlaybackHostTrickMode_eMax) {
        return BERR_TRACE(NEXUS_INVALID_PARAMETER);
    }
    
    if (params->skipControl == NEXUS_PlaybackSkipControl_eDecoder || params->rateControl == NEXUS_PlaybackRateControl_eDecoder) {
        if (!b_play_get_video_decoder(p) && !b_play_has_audio_decoder(p)) {
            BDBG_ERR(("NEXUS_Playback_TrickMode failed because no video or audio decoder was provided in any NEXUS_PlaybackPidChannelSettings."));
            return BERR_TRACE(NEXUS_INVALID_PARAMETER);
        }
    }

    /* validate params based on automatic or custom mode */
    if (params->mode == NEXUS_PlaybackHostTrickMode_eNone) {
        /* in automatic mode, validate all custom trick params are left at default values */
        if (params->rateControl != NEXUS_PlaybackRateControl_eDecoder ||
            params->skipControl != NEXUS_PlaybackSkipControl_eHost ||
            params->mode_modifier != 1)
        {
            return BERR_TRACE(NEXUS_INVALID_PARAMETER);
        }
        new_direction = (params->rate >= 0)?1:-1;
    }
    else {
        /* verify custom mode params */
        if (params->skipControl == NEXUS_PlaybackSkipControl_eDecoder &&
            params->mode_modifier != 1) {
            /* decoder can't do anything with the mode modifier, so ensure its default */
            return BERR_TRACE(NEXUS_INVALID_PARAMETER);
        }
        if (params->mode_modifier >= 0 && params->rate < 0) {
            /* do not make this conversion. fix the app. */
            return BERR_TRACE(NEXUS_INVALID_PARAMETER);
        }
        if (params->mode_modifier < 0 && params->rate >= 0) {
            /* grandfather this conversion */
            BDBG_WRN(("changing trick rate from %d to %d because mode_modifier is negative", params->rate, -1*params->rate));
            modified_params = *params;
            modified_params.rate = -modified_params.rate;
            params = &modified_params;
        }
        /* we may support negative eStream rates in the future using SW STC. */
        new_direction = (params->rate >= 0)?1:-1;
    }

    rc = bplay_sync_playback(p);
    if (rc!=NEXUS_SUCCESS) {rc=BERR_TRACE(rc); goto done; }

    BDBG_CASSERT( (256 * NEXUS_NORMAL_PLAY_SPEED)/BMEDIA_TIME_SCALE_BASE == 256 * (NEXUS_NORMAL_PLAY_SPEED/BMEDIA_TIME_SCALE_BASE));

    b_play_update_location(p);

    rc = b_play_set_media_player_config(p, params);
    if(rc!=BERR_SUCCESS) {rc=BERR_TRACE(NEXUS_NOT_SUPPORTED); goto error;}

    /* set host player rate */
    {
        bmedia_player_step direction;
        bmedia_time_scale time_scale;
        int player_rate;
        
        if (params->skipControl == NEXUS_PlaybackSkipControl_eDecoder) {
            /* if skipControl is eDecoder, then we aren't skipping in the host. */
            player_rate = NEXUS_NORMAL_PLAY_SPEED;
        }
        else {
            player_rate = params->rate;
        }

        direction = (33*player_rate)/NEXUS_NORMAL_PLAY_SPEED;
        if (player_rate && !direction) { /* prevent rounding down to zero */
            direction = player_rate>0?1:-1;
        }
        time_scale = player_rate/(NEXUS_NORMAL_PLAY_SPEED/BMEDIA_TIME_SCALE_BASE);
        if (player_rate && !time_scale) { /* prevent rounding down to zero */
            time_scale = player_rate>0?1:-1;
        }
        
        rc = bmedia_player_set_direction(p->media_player, direction, time_scale, &mode);
        if(rc!=BERR_SUCCESS) {rc=BERR_TRACE(NEXUS_NOT_SUPPORTED); goto error;}
    }

    /* set decoder/stc rate */
    b_play_trick_get(p, &trick_settings);

    NEXUS_Playback_P_ConvertPlayerDecodeMode(p, &mode, &trick_settings, params);
    trick_settings.forward = (new_direction==1);
    trick_settings.avoid_flush = (params->avoidFlush || !p->file->file.index );
    trick_settings.force_source_frame_rate = mode.force_source_frame_rate;

    rc = b_play_trick_set(p, &trick_settings);
    if (rc!=NEXUS_SUCCESS) {rc=BERR_TRACE(rc); } /* fall through. we need to maintain internal Playback state, even on a bad trick mode setting. */

    if(mode.discontinuity) {
        b_play_flush(p);
    }

    if (p->state.decoder_flushed) {
        p->state.reset = true;
    }

    if (rc==NEXUS_SUCCESS) {
        p->state.trickmode_params = *params;
        p->state.direction = new_direction;
        p->state.mode = NEXUS_PlaybackState_eTrickMode;
    }

error:
    if(rc==NEXUS_SUCCESS || p->params.seekErrorHandling==NEXUS_PlaybackErrorHandlingMode_eIgnore) {
        bplay_restart_playback(p, rc==NEXUS_SUCCESS);
    } else {
        NEXUS_Playback_P_AbortPlayback(p);
        rc = BERR_TRACE(rc);
    }

done:
    if(params->rate == -NEXUS_NORMAL_PLAY_SPEED) {
        p->state.frame_advance = NEXUS_Playback_P_FrameAdvance_Reverse;
    } else if(params->rate >=0 && params->rate <= NEXUS_NORMAL_PLAY_SPEED) {
        p->state.frame_advance = NEXUS_Playback_P_FrameAdvance_Forward;
    } else {
        p->state.frame_advance = NEXUS_Playback_P_FrameAdvance_Invalid;
    }
    return rc;
}

NEXUS_Error
NEXUS_Playback_Seek(NEXUS_PlaybackHandle p, NEXUS_PlaybackPosition position)
{
    NEXUS_Error rc;
    int result;

    BDBG_OBJECT_ASSERT(p, NEXUS_Playback);
    rc = bplay_sync_playback(p);
    if(rc!=NEXUS_SUCCESS) {rc = BERR_TRACE(rc); goto done;}

    if (!b_play_get_video_decoder(p) && !b_play_has_audio_decoder(p)) {
        /* no-decoder playback is valid, so this is only a WRN */
        BDBG_WRN(("No video or audio decoder was provided with NEXUS_PlaybackPidChannelSettings; therefore NEXUS_Playback_Seek will not be precise."));
    }

    result = bmedia_player_seek(p->media_player, position);

    if (result!=-1 && p->params.accurateSeek && !p->state.start_paused) {
        bplay_p_accurate_seek(p, position);
    }

    if (result!=-1) {
        p->state.reset = true;
    }
    else {
        /* don't use BERR_TRACE. failed seek is normal. */
        rc = NEXUS_UNKNOWN;
    }
    if(rc!=NEXUS_SUCCESS) {
        if(p->params.seekErrorHandling==NEXUS_PlaybackErrorHandlingMode_eAbort) {
            NEXUS_Playback_P_AbortPlayback(p);
            rc = BERR_TRACE(rc);
            goto done;
        }
    }

    bplay_restart_playback(p, false);
done:
    return rc;
}

NEXUS_Error
NEXUS_Playback_GetStatus(NEXUS_PlaybackHandle p, NEXUS_PlaybackStatus *status)
{
    NEXUS_PlaypumpStatus pumpstatus;
    NEXUS_Error rc=NEXUS_SUCCESS;
    bmedia_player_status player_status;
    bmedia_player_pos position;
    bool need_checkbuffer = false;

    BKNI_Memset(status, 0, sizeof(*status));
    NEXUS_Playback_GetDefaultTrickModeSettings(&status->trickModeSettings);
    switch(p->state.state) {
    case eStopped:
        status->state = NEXUS_PlaybackState_eStopped;
        break;
    case eAborted:
        status->state = NEXUS_PlaybackState_eAborted;
        break;
    default:
        status->state = p->state.mode;
        status->trickModeSettings = p->state.trickmode_params;
        if(!p->state.start_paused) {
            need_checkbuffer = true;
        } else {
            status->state = NEXUS_PlaybackState_ePaused;
        }
        if(status->state == NEXUS_PlaybackState_ePaused) {
            status->trickModeSettings.rate = 0;
        }
        break;
    }

    if (p->state.state != eStopped) {
        BDBG_ASSERT(p->params.playpump);
        rc = NEXUS_Playpump_GetStatus(p->params.playpump, &pumpstatus);
        if(rc==NEXUS_SUCCESS) {
            status->fifoDepth = pumpstatus.fifoDepth;
            status->fifoSize = pumpstatus.fifoSize;
            status->bytesPlayed = pumpstatus.bytesPlayed;
        }
        bmedia_player_get_status(p->media_player, &player_status);
        status->first = player_status.bounds.first;
        status->last = player_status.bounds.last;
        status->indexErrors = p->state.index_error_cnt + player_status.index_error_cnt;
        status->dataErrors = p->state.data_error_cnt + player_status.data_error_cnt;
        status->readPosition = player_status.position;

        if (p->state.state != eAborted) {
            if(!p->state.start_paused) {
                b_play_update_location(p);
            }
            bmedia_player_tell(p->media_player, &position);
            status->position = position;
        }
        else {
            status->position = p->state.abortPosition;
        }
    }
    if(need_checkbuffer) {
        b_play_check_buffer(p);
    }

    return rc;
}

void
NEXUS_Playback_GetDefaultStartSettings(NEXUS_PlaybackStartSettings *pSettings)
{
    BKNI_Memset(pSettings, 0, sizeof(*pSettings));
    pSettings->mode = NEXUS_PlaybackMode_eIndexed;
    pSettings->bitrate = 10 * 1000 * 1000;
    pSettings->mpeg2TsIndexType = NEXUS_PlaybackMpeg2TsIndexType_eAutoDetect;
    pSettings->indexFileIo.mode = NEXUS_PlaybackIndexFileIo_eCallback;
    NEXUS_Thread_GetDefaultSettings(&pSettings->indexFileIo.threadSettings);
    return;
}

static void
NEXUS_Playback_P_PlaypumpThread(void *context)
{
    NEXUS_PlaybackHandle playback = context;
    for(;;) {
        BERR_Code rc;
        BDBG_OBJECT_ASSERT(playback, NEXUS_Playback);
        BDBG_ASSERT(playback->playpump_thread_event);
        rc=BKNI_WaitForEvent(playback->playpump_thread_event, 100);
        if(rc!=BERR_SUCCESS || rc!=BERR_TIMEOUT) {
            rc=BERR_TRACE(rc);
            break;
        }
        NEXUS_LockModule();
        BDBG_ASSERT(playback->playpump_thread_event);
        if(playback->thread_terminate) {
            NEXUS_UnlockModule();
            break;
        }
        if(rc==BERR_SUCCESS && playback->state.state != eStopped) {
            b_play_read_callback(playback);
        }
        NEXUS_UnlockModule();
    }
    BDBG_MSG(("NEXUS_Playback_P_PlaypumpThread: %#x terminated", (unsigned)playback));
    return;
}

NEXUS_Error
NEXUS_Playback_Start(NEXUS_PlaybackHandle playback, NEXUS_FilePlayHandle file, const NEXUS_PlaybackStartSettings *pSettings)
{
    NEXUS_PlaypumpStatus playpump_status;
    NEXUS_Error rc=NEXUS_SUCCESS;
    NEXUS_PlaypumpSettings pumpCfg;
    NEXUS_PlaybackStartSettings defaultStartSettings;

    if (!file) {
        return BERR_TRACE(NEXUS_INVALID_PARAMETER);
    }
    BDBG_OBJECT_ASSERT(playback, NEXUS_Playback);

    if(!pSettings) {
        NEXUS_Playback_GetDefaultStartSettings(&defaultStartSettings);
        pSettings = &defaultStartSettings;
    }
    b_play_capture_open(playback);

    playback->state.media.entry.atom = NULL;

    if (playback->state.state != eStopped) { rc = BERR_TRACE(NEXUS_NOT_SUPPORTED); goto error_state;}
    if (playback->params.playpump == NULL)  { rc = BERR_TRACE(NEXUS_NOT_SUPPORTED); goto error_state;}
    if (file->file.data == NULL) { rc = BERR_TRACE(NEXUS_NOT_SUPPORTED); goto error_state;}

    BDBG_MSG(("NEXUS_Playback_Start: %#lx", playback));
    BKNI_Memset(&playback->state, 0, sizeof(playback->state)); /* wipe-out all temporary state */
    playback->state.validPts = false;
    playback->state.drain_mode = false;
    playback->state.frame_advance = NEXUS_Playback_P_FrameAdvance_Forward;

    switch(pSettings->indexFileIo.mode) {
    case NEXUS_PlaybackIndexFileIo_eCallback:
        /* do nothing */
        break;
    case NEXUS_PlaybackIndexFileIo_eModule:
        if(playback->playpump_event == NULL) {
            rc = BKNI_CreateEvent(&playback->playpump_event);
            if(rc!=BERR_SUCCESS) { rc = BERR_TRACE(rc); goto error_index_mode;}
            playback->playpump_event_callback = NEXUS_RegisterEvent(playback->playpump_event, b_play_read_callback, playback);
            if(playback->playpump_event_callback==NULL) {
                rc = BERR_TRACE(NEXUS_OUT_OF_SYSTEM_MEMORY);
                BKNI_DestroyEvent(playback->playpump_event);
                playback->playpump_event=NULL;
                goto error_index_mode;
            }
        }
        break;
    case NEXUS_PlaybackIndexFileIo_eThread:
        if(playback->playpump_thread_event == NULL) {
            rc = BKNI_CreateEvent(&playback->playpump_thread_event);
            if(rc!=BERR_SUCCESS) {rc=BERR_TRACE(rc);goto error_index_mode;}
        }
        if(playback->playpump_thread) {
            if(BKNI_Memcmp(&playback->playpump_thread_settings, &pSettings->indexFileIo.threadSettings, sizeof(pSettings->indexFileIo.threadSettings))==0) {
                break; /* thread configuration is the same, keep on using old thread */
            }
            NEXUS_Playback_P_KillPlaypumpThread(playback);
        }
        {
            char thread_name[32];
            BKNI_Snprintf(thread_name, sizeof(thread_name), "nx_playback%u", (unsigned)playback);
            playback->playpump_thread = NEXUS_Thread_Create(thread_name, NEXUS_Playback_P_PlaypumpThread, playback, &pSettings->indexFileIo.threadSettings);
            if(!playback->playpump_thread) { rc = BERR_TRACE(NEXUS_OUT_OF_SYSTEM_MEMORY); goto error_index_mode; }
        }
        break;
    default:
        rc = BERR_TRACE(NEXUS_NOT_SUPPORTED);
        goto error_index_mode;
    }
    playback->index_file_mode = pSettings->indexFileIo.mode;

    b_play_trick_init(playback);
    /* trick must know about stcTrick now in case of pause */
    playback->trick.settings.stc_trick = playback->params.stcTrick;
    /* reset any currently attached decoders */
    rc = b_play_trick_set(playback, NULL);
    if (rc) {rc = BERR_TRACE(rc); goto error_state;}

    playback->state.state = eStopped;
    playback->file = file;
    NEXUS_Time_Get(&playback->state.fifoLast); /* get init value */

    rc = NEXUS_Playpump_GetStatus(playback->params.playpump, &playpump_status);
    if (rc) {rc = BERR_TRACE(rc); goto error_state;}

    playback->buf_limit = (uint8_t*)playpump_status.bufferBase + playpump_status.fifoSize - B_IO_BLOCK_LIMIT;
    BDBG_MSG(("playback buffer %#lx(%d)",
        (unsigned long)playpump_status.bufferBase, playpump_status.fifoSize));

    bio_read_attach_priority(playback->file->file.data, NEXUS_P_Playback_GetPriority, playback);

    playback->state.mode = NEXUS_PlaybackState_ePlaying;
    playback->state.encrypted = false ; /* mpeg->encryption.type != bencryption_type_none; */

    playback->state.state = eTransition;
    playback->media_player = NULL;
    /* seek to the beginning of the file */
    playback->file->file.data->seek(playback->file->file.data, 0, SEEK_SET);

    NEXUS_Playpump_GetSettings(playback->params.playpump, &pumpCfg);
    pumpCfg.mode = NEXUS_PlaypumpMode_eFifo;
    rc = NEXUS_Playpump_SetSettings(playback->params.playpump, &pumpCfg);
    if(rc!=NEXUS_SUCCESS) { rc = BERR_TRACE(rc); goto error_playpump_mode; }

    rc = b_play_start_media(playback, file, &playpump_status, pSettings);
    if(rc!=NEXUS_SUCCESS) { rc = BERR_TRACE(rc); goto error_player;}

    NEXUS_StartCallbacks(playback->params.playpump);
    /* assume that playback and decode will start in normal play */
    NEXUS_Playback_GetDefaultTrickModeSettings(&playback->state.trickmode_params);

    playback->state.state = eWaitingPlayback;
    playback->state.start_paused = playback->params.startPaused;
    rc = NEXUS_Playpump_Start(playback->params.playpump);
    if (rc!=NEXUS_SUCCESS) { rc = BERR_TRACE(rc); goto error_playpump; }

    return BERR_SUCCESS;

error_playpump:
    b_play_stop_media(playback);
error_playpump_mode:
error_player:
error_state:
error_index_mode:
    playback->state.state = eStopped;
    /* On any Start failure, we must end in a clean eStopped state that can be restarted. */
    return rc;
}

void
NEXUS_Playback_GetSettings(NEXUS_PlaybackHandle playback, NEXUS_PlaybackSettings *settings)
{
    BDBG_OBJECT_ASSERT(playback, NEXUS_Playback);
    BDBG_ASSERT(settings);
    *settings = playback->params;
    return;
}

static NEXUS_Error
b_play_playpump_read_callback_guard(void *context)
{
    NEXUS_PlaybackHandle playback = (NEXUS_PlaybackHandle)context;

    BDBG_OBJECT_ASSERT(playback, NEXUS_Playback);
    /* no need to acquire lock here, since this mode is only changing when starting playback */
    if(playback->state.state == eStopped) {
        return NEXUS_CALLBACK_DEFLECTED;
    }
    switch(playback->index_file_mode) {
    case NEXUS_PlaybackIndexFileIo_eCallback:
        return NEXUS_SUCCESS;
        break;
    case NEXUS_PlaybackIndexFileIo_eModule:
        BKNI_SetEvent(playback->playpump_event); /* set event and do work inside module's context */
        break;
    case NEXUS_PlaybackIndexFileIo_eThread:
        BKNI_SetEvent(playback->playpump_thread_event); /* set event and do work inside thread */
        break;
    default:
        BDBG_ASSERT(0);
        break;
    }
    return NEXUS_CALLBACK_DEFLECTED;
}

static void
b_play_playpump_read_callback_locked(void *context)
{
    b_play_read_callback(context);
}

NEXUS_Error
NEXUS_Playback_SetSettings(NEXUS_PlaybackHandle playback, const NEXUS_PlaybackSettings *settings)
{
    NEXUS_Error  rc;

    BDBG_OBJECT_ASSERT(playback, NEXUS_Playback);
    BDBG_ASSERT(settings);

    if(settings->endOfStreamAction >= NEXUS_PlaybackLoopMode_eMax) {
        return BERR_TRACE(NEXUS_INVALID_PARAMETER);
    }
    if(settings->beginningOfStreamAction >= NEXUS_PlaybackLoopMode_eMax) {
        return BERR_TRACE(NEXUS_INVALID_PARAMETER);
    }
    if(settings->playErrorHandling>=NEXUS_PlaybackErrorHandlingMode_eMax) {
        return BERR_TRACE(NEXUS_INVALID_PARAMETER);
    }
    if(settings->seekErrorHandling>=NEXUS_PlaybackErrorHandlingMode_eMax) {
        return BERR_TRACE(NEXUS_INVALID_PARAMETER);
    }
    if(settings->trickErrorHandling>=NEXUS_PlaybackErrorHandlingMode_eMax) {
        return BERR_TRACE(NEXUS_INVALID_PARAMETER);
    }
    if(settings->playErrorHandling!=NEXUS_PlaybackErrorHandlingMode_eEndOfStream
        && settings->playErrorHandling!=NEXUS_PlaybackErrorHandlingMode_eAbort) {
        return BERR_TRACE(NEXUS_NOT_SUPPORTED);
    }

    if (settings->stcTrick && !settings->stcChannel) {
        BDBG_ERR(("NEXUS_PlaybackSettings.stcTrick requires NEXUS_PlaybackSettings.stcChannel"));
        return BERR_TRACE(NEXUS_INVALID_PARAMETER);
    }

    if (settings->stcTrick != playback->params.stcTrick && playback->state.state != eStopped) {
        BDBG_ERR(("You must set NEXUS_PlaybackSettings.stcTrick before calling NEXUS_Playback_Start"));
        return BERR_TRACE(NEXUS_INVALID_PARAMETER);
    }

    if(playback->state.state == eStopped && BLST_S_FIRST(&playback->pid_list)==NULL) {
        if(settings->playpump) {
           NEXUS_PlaypumpSettings pumpCfg = settings->playpumpSettings;
            /* replace dataCallback, and don't leak it outside */
           NEXUS_CallbackHandler_PrepareCallback(playback->dataCallbackHandler, pumpCfg.dataCallback);
           pumpCfg.originalTransportType = NEXUS_TransportType_eUnknown;
           switch(pumpCfg.transportType) {
#if 0
           case NEXUS_TransportType_eMp4:
           case NEXUS_TransportType_eMkv:
               pumpCfg.originalTransportType = pumpCfg.transportType;
               pumpCfg.transportType = NEXUS_TransportType_eMpeg2Pes;
               break;
#endif
           case NEXUS_TransportType_eEs:
                if(settings->enableStreamProcessing) {
                    pumpCfg.originalTransportType = pumpCfg.transportType;
                    pumpCfg.transportType = NEXUS_TransportType_eMpeg2Pes;
                }
               break;
           default:
               break;
           }

           playback->actualTransportType = pumpCfg.transportType;
           rc = NEXUS_Playpump_SetSettings(settings->playpump, &pumpCfg);
           if(rc!=NEXUS_SUCCESS) { rc = BERR_TRACE(rc); goto err_playpump; }
        }
    } else {
        if(settings->playpump != playback->params.playpump) { rc = BERR_TRACE(NEXUS_NOT_SUPPORTED);goto err_settings;}
        if(BKNI_Memcmp(&settings->playpumpSettings, &playback->params.playpumpSettings, sizeof(settings->playpumpSettings))!=0) { rc = BERR_TRACE(NEXUS_NOT_SUPPORTED);goto err_settings;}
    }

    if (playback->state.state != eStopped && (playback->state.mode == NEXUS_PlaybackState_eTrickMode || playback->state.trickmode_params.rate != NEXUS_NORMAL_PLAY_SPEED)) {
        if(settings->stcChannel != playback->params.stcChannel) {
            BDBG_ERR(("Cannot change Playback's stcChannel during a trick mode."));
            rc = BERR_TRACE(NEXUS_NOT_SUPPORTED);
            goto err_settings;
        }
    }

    /* cannot call b_play_trick_set here. it is init'd in Start */

    NEXUS_TaskCallback_Set(playback->errorCallback, &settings->errorCallback);
    NEXUS_TaskCallback_Set(playback->endOfStreamCallback, &settings->endOfStreamCallback);
    NEXUS_TaskCallback_Set(playback->beginningOfStreamCallback, &settings->beginningOfStreamCallback);
    NEXUS_TaskCallback_Set(playback->parsingErrorCallback, &settings->parsingErrorCallback);

    if(playback->state.state != eStopped && (!settings->timeshifting && playback->params.timeshifting)) {
        playback->params.timeshifting = false;  /* clear timeshifting flag and simulate notification from record */
        NEXUS_Playback_RecordProgress_priv(playback);
    }

    playback->params = *settings;
    return NEXUS_SUCCESS;
err_playpump:
err_settings:
    return rc;
}

void
NEXUS_Playback_Stop(NEXUS_PlaybackHandle playback)
{
    BERR_Code rc;

    BDBG_OBJECT_ASSERT(playback, NEXUS_Playback);
    BDBG_MSG(("NEXUS_Playback_Stop: %#lx", playback));
    if(playback->state.state == eStopped) {
        BDBG_WRN(("NEXUS_Playback_Stop: %#lx playback already stoped", (unsigned long)playback));
        goto done;
    }

    /* if aborted, we can try to stop. */
    if(playback->state.state != eAborted) {
        rc = NEXUS_Playback_P_CheckWaitingIo(playback, true);
        if (rc) {
            BDBG_ERR(("Playback unable to stop. System is now unstable."));
            rc = BERR_TRACE(rc);
        }
    }

    /* stop timer before unlocking module so that no additional calls to Playpump are made after NEXUS_Playpump_Stop */
    if( playback->state.timer ) {
        BDBG_MSG(("Timer still active, cancelling %#x", playback->state.timer ));
        NEXUS_CancelTimer(playback->state.timer);
        playback->state.timer = NULL;
    }

    BDBG_ASSERT(playback->params.playpump);
    NEXUS_Playpump_Stop(playback->params.playpump);


    b_play_stop_media(playback);
    b_play_trick_shutdown(playback);
    b_play_capture_close(playback);
    playback->state.inAccurateSeek = false;
    playback->state.state = eStopped;

    /* We must unlock because Playback takes the dataReady callback from playpump and acquires
    the Playback module lock inside that callback. If we don't unlock Playback here, we deadlock. */
    NEXUS_UnlockModule();
    NEXUS_StopCallbacks(playback->params.playpump);
    NEXUS_LockModule();


done:
    return ;
}