--enable-crystalhd \

/xbmc/cores/dvdplayer/DVDCodecs/Video/CrystalHD/Makefile

crystalhd_not_found="== Could not find libcrystalhd. CrystalHD support disabled. =="

crystalhd_disabled="== CrystalHD support manually disabled. =="

AC_ARG_ENABLE([crystalhd],

  [AS_HELP_STRING([--enable-crystalhd],

  [enable CrystalHD decoding (default is auto)])],

  [use_crystalhd=$enableval],

  [use_crystalhd=auto])

     use_crystalhd=no

     use_crystalhd=no

# CrystalHD

if test "x$use_crystalhd" != "xno"; then

  SAVE_CFLAGS="$CFLAGS"

  CFLAGS="-D__LINUX_USER__"

  AC_CHECK_HEADER([libcrystalhd/libcrystalhd_if.h], [],

    [ if test "x$use_crystalhd" = "xyes"; then

        AC_MSG_ERROR($crystalhd_not_found)

      else

        use_crystalhd=no

        AC_MSG_RESULT($crystalhd_not_found)

      fi

      USE_CRYSTALHD=0

    ])

    CFLAGS="$SAVE_CFLAGS"

    if test "$host_vendor" != "apple"; then

      XB_FIND_SONAME([CRYSTALHD], [crystalhd], [use_crystalhd])

    fi

    if test "x$use_crystalhd" != "xno"; then

      SAVE_CFLAGS="$CFLAGS"

      CFLAGS="-D__LINUX_USER__ -lcrystalhd"

      # check for new crystalhd lib

      AC_COMPILE_IFELSE(

        [AC_LANG_SOURCE([#include <libcrystalhd/bc_dts_types.h>

          #include <libcrystalhd/bc_dts_defs.h>

          PBC_INFO_CRYSTAL bCrystalInfo;])],

        [ AC_DEFINE([HAVE_LIBCRYSTALHD], [2], [Define to 2 if you have the 'New Broadcom Crystal HD' library.]) ], 

        [ AC_DEFINE([HAVE_LIBCRYSTALHD], [1], [Define to 1 if you have the 'Old Broadcom Crystal HD' library.]) ])

      CFLAGS="$SAVE_CFLAGS"

      USE_CRYSTALHD=1

    fi

else

  AC_MSG_NOTICE($crystalhd_disabled)

  USE_CRYSTALHD=0

fi

if test "x$use_crystalhd" != "xno"; then

  final_message="$final_message\n  CrystalHD:\tYes"

else

  final_message="$final_message\n  CrystalHD:\tNo"

fi

AC_SUBST(USE_CRYSTALHD)

        <setting id="videoplayer.usechd" type="boolean" label="13428" help="36159">

          <requirement>HasCrystalHDDevice</requirement>

          <dependencies>

            <dependency type="enable" setting="videoplayer.decodingmethod" operator="is">1</dependency>

          </dependencies>

          <level>2</level>

          <default>true</default>

          <control type="toggle" />

        </setting>

include ../../Makefile.include

DEPS= ../../Makefile.include

SOURCE=libcrystalhd

all: .installed-$(PLATFORM)

.installed-$(PLATFORM): $(SOURCE)

	mkdir -p $(PREFIX)/include

	cp -rf $(SOURCE) $(PREFIX)/include/

	touch $@

clean:

distclean::

	rm -f .installed-$(PLATFORM)

#if defined(HAVE_LIBCRYSTALHD)

#include "cores/dvdplayer/DVDCodecs/Video/CrystalHD.h"

#endif

#if defined(HAVE_LIBCRYSTALHD)

  CCrystalHD::GetInstance();

#endif

#if defined(HAVE_LIBCRYSTALHD)

    CCrystalHD::RemoveInstance();

#endif

/* broadcom crystalhd */

#if defined(TARGET_DARWIN)

#define DLL_PATH_LIBCRYSTALHD  "libcrystalhd.dylib"

#else

#define DLL_PATH_LIBCRYSTALHD  "@CRYSTALHD_SONAME@"

#endif

#if defined(HAVE_LIBCRYSTALHD)

#include "Video/DVDVideoCodecCrystalHD.h"

#endif

#ifdef HAVE_LIBCRYSTALHD

  hwSupport += "CrystalHD:yes ";

#else

  hwSupport += "CrystalHD:no ";

#endif

#if defined(HAVE_LIBCRYSTALHD)

  if (!hint.software && CSettings::Get().GetBool("videoplayer.usechd"))

  {

    if (CCrystalHD::GetInstance()->DevicePresent())

    {

      switch(hint.codec)

      {

        case AV_CODEC_ID_VC1:

        case AV_CODEC_ID_WMV3:

        case AV_CODEC_ID_H264:

        case AV_CODEC_ID_MPEG2VIDEO:

          if (hint.codec == AV_CODEC_ID_H264 && hint.ptsinvalid)

            break;

          if (hint.codec == AV_CODEC_ID_MPEG2VIDEO && hint.width <= 720)

            break;

          if ( (pCodec = OpenCodec(new CDVDVideoCodecCrystalHD(), hint, options)) ) return pCodec;

        break;

        default:

        break;

      }

    }

  }

#endif

/*

 *      Copyright (C) 2005-2013 Team XBMC

 *      http://xbmc.org

 *

 *  This Program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2, or (at your option)

 *  any later version.

 *

 *  This Program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with XBMC; see the file COPYING.  If not, see

 *  <http://www.gnu.org/licenses/>.

 *

 */

#include "system.h"

#if defined(TARGET_WINDOWS)

#include "WIN32Util.h"

#include "util.h"

#include "dialogs/GUIDialogKaiToast.h"

#include "guilib/LocalizeStrings.h"

#endif

#if defined(HAVE_LIBCRYSTALHD)

#include "CrystalHD.h"

#include "DVDClock.h"

#include "DynamicDll.h"

#include "utils/SystemInfo.h"

#include "threads/Atomics.h"

#include "threads/Thread.h"

#include "utils/log.h"

#include "utils/fastmemcpy.h"

extern "C" {

#include "libswscale/swscale.h"

}

#include "utils/TimeUtils.h"

#include "windowing/WindowingFactory.h"

#include "cores/FFmpeg.h"

namespace BCM

{

  #if defined(TARGET_WINDOWS)

    typedef void		*HANDLE;

  #else

    #ifndef __LINUX_USER__

      #define __LINUX_USER__

    #endif

  #endif

  #include <libcrystalhd/bc_dts_types.h>

  #include <libcrystalhd/bc_dts_defs.h>

  #include <libcrystalhd/libcrystalhd_if.h>

};

#define __MODULE_NAME__ "CrystalHD"

//#define USE_CHD_SINGLE_THREADED_API

class DllLibCrystalHDInterface

{

public:

  virtual ~DllLibCrystalHDInterface() {}

  virtual BCM::BC_STATUS DtsDeviceOpen(void *hDevice, uint32_t mode)=0;

  virtual BCM::BC_STATUS DtsDeviceClose(void *hDevice)=0;

  virtual BCM::BC_STATUS DtsOpenDecoder(void *hDevice, uint32_t StreamType)=0;

  virtual BCM::BC_STATUS DtsCloseDecoder(void *hDevice)=0;

  virtual BCM::BC_STATUS DtsStartDecoder(void *hDevice)=0;

  virtual BCM::BC_STATUS DtsSetVideoParams(void *hDevice, uint32_t videoAlg, int FGTEnable, int MetaDataEnable, int Progressive, uint32_t OptFlags)=0;

  virtual BCM::BC_STATUS DtsStartCapture(void *hDevice)=0;

  virtual BCM::BC_STATUS DtsFlushRxCapture(void *hDevice, int bDiscardOnly)=0;

  virtual BCM::BC_STATUS DtsSetFFRate(void *hDevice, uint32_t rate)=0;

  virtual BCM::BC_STATUS DtsGetDriverStatus(void *hDevice, BCM::BC_DTS_STATUS *pStatus)=0;

  virtual BCM::BC_STATUS DtsProcInput(void *hDevice, uint8_t *pUserData, uint32_t ulSizeInBytes, uint64_t timeStamp, int encrypted)=0;

  virtual BCM::BC_STATUS DtsProcOutput(void *hDevice, uint32_t milliSecWait, BCM::BC_DTS_PROC_OUT *pOut)=0;

  virtual BCM::BC_STATUS DtsProcOutputNoCopy(void *hDevice, uint32_t milliSecWait, BCM::BC_DTS_PROC_OUT *pOut)=0;

  virtual BCM::BC_STATUS DtsReleaseOutputBuffs(void *hDevice, void *Reserved, int fChange)=0;

  virtual BCM::BC_STATUS DtsSetSkipPictureMode(void *hDevice, uint32_t Mode)=0;

  virtual BCM::BC_STATUS DtsFlushInput(void *hDevice, uint32_t SkipMode)=0;

#if (HAVE_LIBCRYSTALHD == 2)

  // new function calls, only present in new driver/library so manually load them

  virtual BCM::BC_STATUS DtsGetVersion(void *hDevice, uint32_t *DrVer, uint32_t *DilVer)=0;

  virtual BCM::BC_STATUS DtsSetInputFormat(void *hDevice, BCM::BC_INPUT_FORMAT *pInputFormat)=0;

  virtual BCM::BC_STATUS DtsGetColorPrimaries(void *hDevice, uint32_t *colorPrimaries)=0;

  virtual BCM::BC_STATUS DtsSetColorSpace(void *hDevice, BCM::BC_OUTPUT_FORMAT Mode422)=0;

  virtual BCM::BC_STATUS DtsGetCapabilities(void *hDevice, BCM::BC_HW_CAPS *CapsBuffer)=0;

  virtual BCM::BC_STATUS DtsSetScaleParams(void *hDevice, BCM::BC_SCALING_PARAMS *ScaleParams)=0;

  virtual BCM::BC_STATUS DtsIsEndOfStream(void *hDevice, uint8_t* bEOS)=0;

  virtual BCM::BC_STATUS DtsCrystalHDVersion(void *hDevice, BCM::BC_INFO_CRYSTAL *CrystalInfo)=0;

#endif

};

class DllLibCrystalHD : public DllDynamic, DllLibCrystalHDInterface

{

  DECLARE_DLL_WRAPPER(DllLibCrystalHD, DLL_PATH_LIBCRYSTALHD)

  DEFINE_METHOD2(BCM::BC_STATUS, DtsDeviceOpen,      (void *p1, uint32_t p2))

  DEFINE_METHOD1(BCM::BC_STATUS, DtsDeviceClose,     (void *p1))

  DEFINE_METHOD2(BCM::BC_STATUS, DtsOpenDecoder,     (void *p1, uint32_t p2))

  DEFINE_METHOD1(BCM::BC_STATUS, DtsCloseDecoder,    (void *p1))

  DEFINE_METHOD1(BCM::BC_STATUS, DtsStartDecoder,    (void *p1))

  DEFINE_METHOD1(BCM::BC_STATUS, DtsStopDecoder,     (void *p1))

  DEFINE_METHOD6(BCM::BC_STATUS, DtsSetVideoParams,  (void *p1, uint32_t p2, int p3, int p4, int p5, uint32_t p6))

  DEFINE_METHOD1(BCM::BC_STATUS, DtsStartCapture,    (void *p1))

  DEFINE_METHOD2(BCM::BC_STATUS, DtsFlushRxCapture,  (void *p1, int p2))

  DEFINE_METHOD2(BCM::BC_STATUS, DtsSetFFRate,       (void *p1, uint32_t p2))

  DEFINE_METHOD2(BCM::BC_STATUS, DtsGetDriverStatus, (void *p1, BCM::BC_DTS_STATUS *p2))

  DEFINE_METHOD5(BCM::BC_STATUS, DtsProcInput,       (void *p1, uint8_t *p2, uint32_t p3, uint64_t p4, int p5))

  DEFINE_METHOD3(BCM::BC_STATUS, DtsProcOutput,      (void *p1, uint32_t p2, BCM::BC_DTS_PROC_OUT *p3))

  DEFINE_METHOD3(BCM::BC_STATUS, DtsProcOutputNoCopy,(void *p1, uint32_t p2, BCM::BC_DTS_PROC_OUT *p3))

  DEFINE_METHOD3(BCM::BC_STATUS, DtsReleaseOutputBuffs,(void *p1, void *p2, int p3))

  DEFINE_METHOD2(BCM::BC_STATUS, DtsSetSkipPictureMode,(void *p1, uint32_t p2))

  DEFINE_METHOD2(BCM::BC_STATUS, DtsFlushInput,      (void *p1, uint32_t p2))

#if (HAVE_LIBCRYSTALHD == 2)

  DEFINE_METHOD3(BCM::BC_STATUS, DtsGetVersion,      (void *p1, uint32_t *p2, uint32_t *p3))

  DEFINE_METHOD2(BCM::BC_STATUS, DtsSetInputFormat,  (void *p1, BCM::BC_INPUT_FORMAT *p2))

  DEFINE_METHOD2(BCM::BC_STATUS, DtsGetColorPrimaries,(void *p1, uint32_t *p2))

  DEFINE_METHOD2(BCM::BC_STATUS, DtsSetColorSpace,   (void *p1, BCM::BC_OUTPUT_FORMAT p2))

  DEFINE_METHOD2(BCM::BC_STATUS, DtsGetCapabilities, (void *p1, BCM::BC_HW_CAPS *p2))

  DEFINE_METHOD2(BCM::BC_STATUS, DtsSetScaleParams,  (void *p1, BCM::BC_SCALING_PARAMS *p2))

  DEFINE_METHOD2(BCM::BC_STATUS, DtsIsEndOfStream,   (void *p1, uint8_t *p2))

  DEFINE_METHOD2(BCM::BC_STATUS, DtsCrystalHDVersion,(void *p1, BCM::BC_INFO_CRYSTAL *p2))

#endif

  BEGIN_METHOD_RESOLVE()

    RESOLVE_METHOD_RENAME(DtsDeviceOpen,      DtsDeviceOpen)

    RESOLVE_METHOD_RENAME(DtsDeviceClose,     DtsDeviceClose)

    RESOLVE_METHOD_RENAME(DtsOpenDecoder,     DtsOpenDecoder)

    RESOLVE_METHOD_RENAME(DtsCloseDecoder,    DtsCloseDecoder)

    RESOLVE_METHOD_RENAME(DtsStartDecoder,    DtsStartDecoder)

    RESOLVE_METHOD_RENAME(DtsStopDecoder,     DtsStopDecoder)

    RESOLVE_METHOD_RENAME(DtsSetVideoParams,  DtsSetVideoParams)

    RESOLVE_METHOD_RENAME(DtsStartCapture,    DtsStartCapture)

    RESOLVE_METHOD_RENAME(DtsFlushRxCapture,  DtsFlushRxCapture)

    RESOLVE_METHOD_RENAME(DtsSetFFRate,       DtsSetFFRate)

    RESOLVE_METHOD_RENAME(DtsGetDriverStatus, DtsGetDriverStatus)

    RESOLVE_METHOD_RENAME(DtsProcInput,       DtsProcInput)

    RESOLVE_METHOD_RENAME(DtsProcOutput,      DtsProcOutput)

    RESOLVE_METHOD_RENAME(DtsProcOutputNoCopy,DtsProcOutputNoCopy)

    RESOLVE_METHOD_RENAME(DtsReleaseOutputBuffs,DtsReleaseOutputBuffs)

    RESOLVE_METHOD_RENAME(DtsSetSkipPictureMode,DtsSetSkipPictureMode)

    RESOLVE_METHOD_RENAME(DtsFlushInput,      DtsFlushInput)

  END_METHOD_RESOLVE()

public:

  bool LoadNewLibFunctions(void)

  {

#if (HAVE_LIBCRYSTALHD == 2)

    int rtn;

    rtn  = m_dll->ResolveExport("DtsGetVersion",       (void**)&m_DtsGetVersion_ptr, false);

    rtn &= m_dll->ResolveExport("DtsSetInputFormat",   (void**)&m_DtsSetInputFormat_ptr, false);

    rtn &= m_dll->ResolveExport("DtsGetColorPrimaries",(void**)&m_DtsGetColorPrimaries_ptr, false);

    rtn &= m_dll->ResolveExport("DtsSetColorSpace",    (void**)&m_DtsSetColorSpace_ptr, false);

    rtn &= m_dll->ResolveExport("DtsGetCapabilities",  (void**)&m_DtsGetCapabilities_ptr, false);

    rtn &= m_dll->ResolveExport("DtsSetScaleParams",   (void**)&m_DtsSetScaleParams_ptr, false);

    rtn &= m_dll->ResolveExport("DtsIsEndOfStream",    (void**)&m_DtsIsEndOfStream_ptr, false);

    rtn &= m_dll->ResolveExport("DtsCrystalHDVersion", (void**)&m_DtsCrystalHDVersion_ptr, false);

    rtn &= m_dll->ResolveExport("DtsSetInputFormat",   (void**)&m_DtsSetInputFormat_ptr, false);

    return(rtn == 1);

#else

    return false;

#endif

  };

};

void PrintFormat(BCM::BC_PIC_INFO_BLOCK &pib);

void BcmDebugLog( BCM::BC_STATUS lResult, std::string strFuncName="");

const char* g_DtsStatusText[] = {

	"BC_STS_SUCCESS",

	"BC_STS_INV_ARG",

	"BC_STS_BUSY",		

	"BC_STS_NOT_IMPL",		

	"BC_STS_PGM_QUIT",		

	"BC_STS_NO_ACCESS",	

	"BC_STS_INSUFF_RES",	

	"BC_STS_IO_ERROR",		

	"BC_STS_NO_DATA",		

	"BC_STS_VER_MISMATCH",

	"BC_STS_TIMEOUT",		

	"BC_STS_FW_CMD_ERR",	

	"BC_STS_DEC_NOT_OPEN",

	"BC_STS_ERR_USAGE",

	"BC_STS_IO_USER_ABORT",

	"BC_STS_IO_XFR_ERROR",

	"BC_STS_DEC_NOT_STARTED",

	"BC_STS_FWHEX_NOT_FOUND",

	"BC_STS_FMT_CHANGE",

	"BC_STS_HIF_ACCESS",

	"BC_STS_CMD_CANCELLED",

	"BC_STS_FW_AUTH_FAILED",

	"BC_STS_BOOTLOADER_FAILED",

	"BC_STS_CERT_VERIFY_ERROR",

	"BC_STS_DEC_EXIST_OPEN",

	"BC_STS_PENDING",

	"BC_STS_CLK_NOCHG"

};

////////////////////////////////////////////////////////////////////////////////////////////

class CMPCOutputThread : public CThread

{

public:

  CMPCOutputThread(void *device, DllLibCrystalHD *dll, bool has_bcm70015);

  virtual ~CMPCOutputThread();

  unsigned int        GetReadyCount(void);

  unsigned int        GetFreeCount(void);

  CPictureBuffer*     ReadyListPop(void);

  void                FreeListPush(CPictureBuffer* pBuffer);

  bool                WaitOutput(unsigned int msec);

protected:

  void                DoFrameRateTracking(double timestamp);

  void                SetFrameRate(uint32_t resolution);

  void                SetAspectRatio(BCM::BC_PIC_INFO_BLOCK *pic_info);

  void                CopyOutAsNV12(CPictureBuffer *pBuffer, BCM::BC_DTS_PROC_OUT *procOut, int w, int h, int stride);

  void                CopyOutAsNV12DeInterlace(CPictureBuffer *pBuffer, BCM::BC_DTS_PROC_OUT *procOut, int w, int h, int stride);

  void                CopyOutAsYV12(CPictureBuffer *pBuffer, BCM::BC_DTS_PROC_OUT *procOut, int w, int h, int stride);

  void                CopyOutAsYV12DeInterlace(CPictureBuffer *pBuffer, BCM::BC_DTS_PROC_OUT *procOut, int w, int h, int stride);

  void                CheckUpperLeftGreenPixelHack(CPictureBuffer *pBuffer);

  bool                GetDecoderOutput(void);

  virtual void        Process(void);

  CSyncPtrQueue<CPictureBuffer> m_FreeList;

  CSyncPtrQueue<CPictureBuffer> m_ReadyList;

  DllLibCrystalHD     *m_dll;

  void                *m_device;

  bool                m_has_bcm70015;

  unsigned int        m_timeout;

  bool                m_format_valid;

  bool                m_is_live_stream;

  int                 m_width;

  int                 m_height;

  uint64_t            m_timestamp;

  bool                m_output_YV12;

  uint64_t            m_PictureNumber;

  uint8_t             m_color_space;

  unsigned int        m_color_range;

  unsigned int        m_color_matrix;

  int                 m_interlace;

  bool                m_framerate_tracking;

  uint64_t            m_framerate_cnt;

  double              m_framerate_timestamp;

  double              m_framerate;

  int                 m_aspectratio_x;

  int                 m_aspectratio_y;

  CEvent              m_ready_event;

  struct SwsContext   *m_sw_scale_ctx;

};

////////////////////////////////////////////////////////////////////////////////////////////

#if defined(TARGET_DARWIN)

#pragma mark -

#endif

CPictureBuffer::CPictureBuffer(ERenderFormat format, int width, int height)

{

  m_width = width;

  m_height = height;

  m_field = CRYSTALHD_FIELD_FULL;

  m_interlace = false;

  m_timestamp = DVD_NOPTS_VALUE;

  m_PictureNumber = 0;

  m_color_space = BCM::MODE420;

  m_color_range = 0;

  m_color_matrix = 4;

  m_format = format;

  m_framerate = 0;

  switch(m_format)

  {

    default:

    case RENDER_FMT_NV12:

      // setup y plane

      m_y_buffer_size = m_width * m_height;

      m_y_buffer_ptr = (unsigned char*)_aligned_malloc(m_y_buffer_size, 16);

      m_u_buffer_size = 0;

      m_v_buffer_size = 0;

      m_u_buffer_ptr = NULL;

      m_v_buffer_ptr = NULL;

      m_uv_buffer_size = m_y_buffer_size / 2;

      m_uv_buffer_ptr = (unsigned char*)_aligned_malloc(m_uv_buffer_size, 16);

    break;

    case RENDER_FMT_YUYV422:

      // setup y plane

      m_y_buffer_size = (2 * m_width) * m_height;

      m_y_buffer_ptr = (unsigned char*)_aligned_malloc(m_y_buffer_size, 16);

      m_uv_buffer_size = 0;

      m_uv_buffer_ptr = NULL;

      m_u_buffer_size = 0;

      m_v_buffer_size = 0;

      m_u_buffer_ptr = NULL;

      m_v_buffer_ptr = NULL;

    break;

    case RENDER_FMT_YUV420P:

      // setup y plane

      m_y_buffer_size = m_width * m_height;

      m_y_buffer_ptr = (unsigned char*)_aligned_malloc(m_y_buffer_size, 16);

      m_uv_buffer_size = 0;

      m_uv_buffer_ptr = NULL;

      m_u_buffer_size = m_y_buffer_size / 4;

      m_v_buffer_size = m_y_buffer_size / 4;

      m_u_buffer_ptr = (unsigned char*)_aligned_malloc(m_u_buffer_size, 16);

      m_v_buffer_ptr = (unsigned char*)_aligned_malloc(m_v_buffer_size, 16);

    break;

  }

}

CPictureBuffer::~CPictureBuffer()

{

  if (m_y_buffer_ptr) _aligned_free(m_y_buffer_ptr);

  if (m_u_buffer_ptr) _aligned_free(m_u_buffer_ptr);

  if (m_v_buffer_ptr) _aligned_free(m_v_buffer_ptr);

  if (m_uv_buffer_ptr) _aligned_free(m_uv_buffer_ptr);

}

/////////////////////////////////////////////////////////////////////////////////////////////

#if defined(TARGET_DARWIN)

#pragma mark -

#endif

CMPCOutputThread::CMPCOutputThread(void *device, DllLibCrystalHD *dll, bool has_bcm70015) :

  CThread("MPCOutput"),

  m_dll(dll),

  m_device(device),

  m_has_bcm70015(has_bcm70015),

  m_timeout(20),

  m_format_valid(false),

  m_is_live_stream(false),

  m_width(0),

  m_height(0),

  m_timestamp(0),

  m_PictureNumber(0),

  m_color_space(0),

  m_color_range(0),

  m_color_matrix(0),

  m_interlace(0),

  m_framerate_tracking(false),

  m_framerate_cnt(0),

  m_framerate_timestamp(0.0),

  m_framerate(0.0),

  m_aspectratio_x(1),

  m_aspectratio_y(1)

{

  m_sw_scale_ctx = NULL;

  if (g_Windowing.GetRenderQuirks() & RENDER_QUIRKS_YV12_PREFERED)

    m_output_YV12 = true;

  else

    m_output_YV12 = false;

}

CMPCOutputThread::~CMPCOutputThread()

{

  while(m_ReadyList.Count())

    delete m_ReadyList.Pop();

  while(m_FreeList.Count())

    delete m_FreeList.Pop();

  if (m_sw_scale_ctx)

    sws_freeContext(m_sw_scale_ctx);

}

unsigned int CMPCOutputThread::GetReadyCount(void)

{

  return m_ReadyList.Count();

}

unsigned int CMPCOutputThread::GetFreeCount(void)

{

  return m_FreeList.Count();

}

CPictureBuffer* CMPCOutputThread::ReadyListPop(void)

{

  CPictureBuffer *pBuffer = m_ReadyList.Pop();

  return pBuffer;

}

void CMPCOutputThread::FreeListPush(CPictureBuffer* pBuffer)

{

  m_FreeList.Push(pBuffer);

}

bool CMPCOutputThread::WaitOutput(unsigned int msec)

{

  return m_ready_event.WaitMSec(msec);

}

void CMPCOutputThread::DoFrameRateTracking(double timestamp)

{

  if (timestamp != DVD_NOPTS_VALUE)

  {

    double duration;

    // if timestamp does not start at a low value we 

    // came in the middle of an online live stream

    // 250 ms is a fourth of a 25fps source

    // if timestamp is larger than that at the beginning

    // we are much more out of sync than with the rough 

    // calculation. To cover these 250 ms we need

    // roughly 5 seconds of video stream to get back

    // in sync

    if (m_framerate_cnt == 0 && timestamp > 250000.0)

      m_is_live_stream = true;

    duration = timestamp - m_framerate_timestamp;

    if (duration > 0.0)

    {

      double framerate;

      // cnt count has to be done here, cause we miss frames

      // if framerate will not calculated correctly and

      // duration has to be > 0.0 so we do not calc images twice

      m_framerate_cnt++;

      m_framerate_timestamp += duration;

      framerate = DVD_TIME_BASE / duration;

      // qualify framerate, we don't care about absolute value, just

      // want to to verify range. Timestamp could be borked so ignore

      // anything that does not verify.

      // 60, 59.94 -> 60

      // 50, 49.95 -> 50

      // 30, 29.97 -> 30

      // 25, 24.975 -> 25

      // 24, 23.976 -> 24

      switch ((int)(0.5 + framerate))

      {

        case 60:

        case 50:

        case 30:

        case 25:

        case 24:

          // if we have such a live stream framerate is more exact than calculating

          // cause of m_framerate_cnt and timestamp do not match in any way

          m_framerate = m_is_live_stream ? framerate : DVD_TIME_BASE / (m_framerate_timestamp/m_framerate_cnt);

        break;

      }

    }

  }

}

void CMPCOutputThread::SetFrameRate(uint32_t resolution)

{

  m_interlace = FALSE;

  switch (resolution)

  {

    case BCM::vdecRESOLUTION_1080p30:

      m_framerate = 30.0;

    break;

    case BCM::vdecRESOLUTION_1080p29_97:

      m_framerate = 30.0 * 1000.0 / 1001.0;

    break;

    case BCM::vdecRESOLUTION_1080p25 :

      m_framerate = 25.0;

    break;

    case BCM::vdecRESOLUTION_1080p24:

      m_framerate = 24.0;

    break;

    case BCM::vdecRESOLUTION_1080p23_976:

      m_framerate = 24.0 * 1000.0 / 1001.0;

    break;

    case BCM::vdecRESOLUTION_1080p0:

      // 1080p0 is ambiguious, could be 23.976 or 29.97 fps, decoder

      // just does not know. 1080p@23_976 is more common but this

      // will mess up 1080p@29_97 playback. We really need to verify

      // which framerate with duration tracking.

      m_framerate_tracking = true;

      m_framerate = 24.0 * 1000.0 / 1001.0;

    break;

    case BCM::vdecRESOLUTION_1080i29_97:

      m_framerate = 30.0 * 1000.0 / 1001.0;

      m_interlace = TRUE;

    break;

    case BCM::vdecRESOLUTION_1080i0:

      m_framerate = 30.0 * 1000.0 / 1001.0;

      m_interlace = TRUE;

    break;

    case BCM::vdecRESOLUTION_1080i:

      m_framerate = 30.0 * 1000.0 / 1001.0;

      m_interlace = TRUE;

    break;

    case BCM::vdecRESOLUTION_1080i25:

      m_framerate = 25.0 * 1000.0 / 1001.0;

      m_interlace = TRUE;

    break;

    case BCM::vdecRESOLUTION_720p59_94:

      m_framerate = 60.0 * 1000.0 / 1001.0;

    break;

    case BCM::vdecRESOLUTION_720p:

      m_framerate = 60.0 * 1000.0 / 1001.0;

    break;

    case BCM::vdecRESOLUTION_720p50:

      m_framerate = 50.0 * 1000.0 / 1001.0;

    break;

    case BCM::vdecRESOLUTION_720p29_97:

      m_framerate = 30.0 * 1000.0 / 1001.0;

    break;

    case BCM::vdecRESOLUTION_720p24:

      m_framerate = 24.0;

    break;

    case BCM::vdecRESOLUTION_720p23_976:

      // some 720p/25 will be identifed as this, enable tracking.

      m_framerate_tracking = true;

      m_framerate = 24.0 * 1000.0 / 1001.0;

    break;

    case BCM::vdecRESOLUTION_720p0:

      // 720p0 is ambiguious, could be 23.976, 29.97 or 59.97 fps, decoder

      // just does not know. 720p@23_976 is more common but this

      // will mess up other playback. We really need to verify

      // which framerate with duration tracking.

      m_framerate_tracking = true;

      m_framerate = 24.0 * 1000.0 / 1001.0;

    break;

    case BCM::vdecRESOLUTION_576p25:

      m_framerate = 25.0;

    break;

    case BCM::vdecRESOLUTION_576p0:

      m_framerate = 25.0;

    break;

    case BCM::vdecRESOLUTION_PAL1:

      m_framerate = 25.0 * 1000.0 / 1001.0;

      m_interlace = TRUE;

    break;

    case BCM::vdecRESOLUTION_480p0:

      m_framerate = 60.0;

    break;

    case BCM::vdecRESOLUTION_480p:

      m_framerate = 60.0 * 1000.0 / 1001.0;

    break;

    case BCM::vdecRESOLUTION_480p29_97:

      m_framerate = 30.0 * 1000.0 / 1001.0;

    break;

    case BCM::vdecRESOLUTION_480p23_976:

      m_framerate = 24.0 * 1000.0 / 1001.0;

    break;

    case BCM::vdecRESOLUTION_480i0:

      m_framerate = 30.0 * 1000.0 / 1001.0;

      m_interlace = TRUE;

    break;

    case BCM::vdecRESOLUTION_480i:

      m_framerate = 30.0 * 1000.0 / 1001.0;

      m_interlace = TRUE;

    break;

    case BCM::vdecRESOLUTION_NTSC:

      m_framerate = 30.0 * 1000.0 / 1001.0;

      m_interlace = TRUE;

    break;

    default:

      m_framerate_tracking = true;

      m_framerate = 24.0 * 1000.0 / 1001.0;

    break;

  }

  CLog::Log(LOGDEBUG, "%s: resolution = %x  interlace = %d", __MODULE_NAME__, resolution, m_interlace);

}

void CMPCOutputThread::SetAspectRatio(BCM::BC_PIC_INFO_BLOCK *pic_info)

{

	switch(pic_info->aspect_ratio)

  {

    case BCM::vdecAspectRatioSquare:

      m_aspectratio_x = 1;

      m_aspectratio_y = 1;

    break;

    case BCM::vdecAspectRatio12_11:

      m_aspectratio_x = 12;

      m_aspectratio_y = 11;

    break;

    case BCM::vdecAspectRatio10_11:

      m_aspectratio_x = 10;

      m_aspectratio_y = 11;

    break;

    case BCM::vdecAspectRatio16_11:

      m_aspectratio_x = 16;

      m_aspectratio_y = 11;

    break;

    case BCM::vdecAspectRatio40_33:

      m_aspectratio_x = 40;

      m_aspectratio_y = 33;

    break;

    case BCM::vdecAspectRatio24_11:

      m_aspectratio_x = 24;

      m_aspectratio_y = 11;

    break;

    case BCM::vdecAspectRatio20_11:

      m_aspectratio_x = 20;

      m_aspectratio_y = 11;

    break;

    case BCM::vdecAspectRatio32_11:

      m_aspectratio_x = 32;

      m_aspectratio_y = 11;

    break;

    case BCM::vdecAspectRatio80_33:

      m_aspectratio_x = 80;

      m_aspectratio_y = 33;

    break;

    case BCM::vdecAspectRatio18_11:

      m_aspectratio_x = 18;

      m_aspectratio_y = 11;

    break;

    case BCM::vdecAspectRatio15_11:

      m_aspectratio_x = 15;

      m_aspectratio_y = 11;

    break;

    case BCM::vdecAspectRatio64_33:

      m_aspectratio_x = 64;

      m_aspectratio_y = 33;

    break;

    case BCM::vdecAspectRatio160_99:

      m_aspectratio_x = 160;

      m_aspectratio_y = 99;

    break;

    case BCM::vdecAspectRatio4_3:

      m_aspectratio_x = 4;

      m_aspectratio_y = 3;

    break;

    case BCM::vdecAspectRatio16_9:

      m_aspectratio_x = 16;

      m_aspectratio_y = 9;

    break;

    case BCM::vdecAspectRatio221_1:

      m_aspectratio_x = 221;

      m_aspectratio_y = 1;

    break;

    case BCM::vdecAspectRatioUnknown:

      m_aspectratio_x = 0;

      m_aspectratio_y = 0;

    break;

    case BCM::vdecAspectRatioOther:

      m_aspectratio_x = pic_info->custom_aspect_ratio_width_height & 0x0000ffff;

      m_aspectratio_y = pic_info->custom_aspect_ratio_width_height >> 16;

    break;

  }

  if(m_aspectratio_x == 0)

  {

    m_aspectratio_x = 1;

    m_aspectratio_y = 1;

  }

  CLog::Log(LOGDEBUG, "%s: dec_par x = %d, dec_par y = %d", __MODULE_NAME__, m_aspectratio_x, m_aspectratio_y);

}

void CMPCOutputThread::CopyOutAsYV12(CPictureBuffer *pBuffer, BCM::BC_DTS_PROC_OUT *procOut, int w, int h, int stride)

{

  // copy y

  if (w == stride)

  {

    fast_memcpy(pBuffer->m_y_buffer_ptr, procOut->Ybuff, w * h);

  }

  else

  {

    uint8_t *s_y = procOut->Ybuff;

    uint8_t *d_y = pBuffer->m_y_buffer_ptr;

    for (int y = 0; y < h; y++, s_y += stride, d_y += w)

      fast_memcpy(d_y, s_y, w);

  }

  //copy chroma

  //copy uv packed to u,v planes (1/2 the width and 1/2 the height of y)

  uint8_t *d_u = pBuffer->m_u_buffer_ptr;

  uint8_t *d_v = pBuffer->m_v_buffer_ptr;

  for (int y = 0; y < h/2; y++)

  {

    uint8_t *s_uv = procOut->UVbuff + (y * stride);

    for (int x = 0; x < w/2; x++)

    {

      *d_u++ = *s_uv++;

      *d_v++ = *s_uv++;

    }

  }

}

void CMPCOutputThread::CopyOutAsYV12DeInterlace(CPictureBuffer *pBuffer, BCM::BC_DTS_PROC_OUT *procOut, int w, int h, int stride)

{

  // copy luma

  uint8_t *s_y = procOut->Ybuff;

  uint8_t *d_y = pBuffer->m_y_buffer_ptr;

  for (int y = 0; y < h/2; y++, s_y += stride)

  {

    fast_memcpy(d_y, s_y, w);

    d_y += w;

    fast_memcpy(d_y, s_y, w);

    d_y += w;

  }

  //copy chroma

  //copy uv packed to u,v planes (1/2 the width and 1/2 the height of y)

  uint8_t *d_u = pBuffer->m_u_buffer_ptr;

  uint8_t *d_v = pBuffer->m_v_buffer_ptr;

  for (int y = 0; y < h/4; y++)

  {

    uint8_t *s_uv = procOut->UVbuff + (y * stride);

    for (int x = 0; x < w/2; x++)

    {

      *d_u++ = *s_uv++;

      *d_v++ = *s_uv++;

    }

    s_uv = procOut->UVbuff + (y * stride);

    for (int x = 0; x < w/2; x++)

    {

      *d_u++ = *s_uv++;

      *d_v++ = *s_uv++;

    }

  }

  pBuffer->m_interlace = false;

}

void CMPCOutputThread::CopyOutAsNV12(CPictureBuffer *pBuffer, BCM::BC_DTS_PROC_OUT *procOut, int w, int h, int stride)

{

  if (w == stride)

  {

    int bytes = w * h;

    // copy y

    fast_memcpy(pBuffer->m_y_buffer_ptr, procOut->Ybuff, bytes);

    // copy uv

    fast_memcpy(pBuffer->m_uv_buffer_ptr, procOut->UVbuff, bytes/2 );

  }

  else

  {

    // copy y

    uint8_t *s = procOut->Ybuff;

    uint8_t *d = pBuffer->m_y_buffer_ptr;

    for (int y = 0; y < h; y++, s += stride, d += w)

      fast_memcpy(d, s, w);

    // copy uv

    s = procOut->UVbuff;

    d = pBuffer->m_uv_buffer_ptr;

    for (int y = 0; y < h/2; y++, s += stride, d += w)

      fast_memcpy(d, s, w);

  }

}

void CMPCOutputThread::CopyOutAsNV12DeInterlace(CPictureBuffer *pBuffer, BCM::BC_DTS_PROC_OUT *procOut, int w, int h, int stride)

{

  // do simple line doubling de-interlacing.

  // copy luma

  uint8_t *s_y = procOut->Ybuff;

  uint8_t *d_y = pBuffer->m_y_buffer_ptr;

  for (int y = 0; y < h/2; y++, s_y += stride)

  {

    fast_memcpy(d_y, s_y, w);

    d_y += w;

    fast_memcpy(d_y, s_y, w);

    d_y += w;

  }

  //copy chroma

  uint8_t *s_uv = procOut->UVbuff;

  uint8_t *d_uv = pBuffer->m_uv_buffer_ptr;

  for (int y = 0; y < h/4; y++, s_uv += stride) {

    fast_memcpy(d_uv, s_uv, w);

    d_uv += w;

    fast_memcpy(d_uv, s_uv, w);

    d_uv += w;

  }

  pBuffer->m_interlace = false;

}

void CMPCOutputThread::CheckUpperLeftGreenPixelHack(CPictureBuffer *pBuffer)

{

  // crystalhd driver sends internal info in 1st pixel location, then restores

  // original pixel value but sometimes, the info is broked and the

  // driver cannot do the restore and zeros the pixel. This is wrong for

  // yuv color space, uv values should be set to 128 otherwise we get a

  // bright green pixel in upper left.

  // We fix this by replicating the 2nd pixel to the 1st.

  switch(pBuffer->m_format)

  {

    default:

    case RENDER_FMT_YUV420P:

    {

      uint8_t *d_y = pBuffer->m_y_buffer_ptr;

      uint8_t *d_u = pBuffer->m_u_buffer_ptr;

      uint8_t *d_v = pBuffer->m_v_buffer_ptr;

      d_y[0] = d_y[1];

      d_u[0] = d_u[1];

      d_v[0] = d_v[1];

    }

    break;

    case RENDER_FMT_NV12:

    {

      uint8_t  *d_y  = pBuffer->m_y_buffer_ptr;

      uint16_t *d_uv = (uint16_t*)pBuffer->m_uv_buffer_ptr;

      d_y[0] = d_y[1];

      d_uv[0] = d_uv[1];

    }

    break;

    case RENDER_FMT_YUYV422:

    {

      uint32_t *d_yuyv = (uint32_t*)pBuffer->m_y_buffer_ptr;

      d_yuyv[0] = d_yuyv[1];

    }

    break;

  }

}

bool CMPCOutputThread::GetDecoderOutput(void)

{

  BCM::BC_STATUS ret;

  BCM::BC_DTS_PROC_OUT procOut;

  CPictureBuffer *pBuffer = NULL;

  bool got_picture = false;

  // Setup output struct

  memset(&procOut, 0, sizeof(BCM::BC_DTS_PROC_OUT));

  // Fetch data from the decoder

  ret = m_dll->DtsProcOutputNoCopy(m_device, m_timeout, &procOut);

  switch (ret)

  {

    case BCM::BC_STS_SUCCESS:

      if (m_format_valid && (procOut.PoutFlags & BCM::BC_POUT_FLAGS_PIB_VALID))

      {

        if (procOut.PicInfo.timeStamp && 

          m_timestamp != procOut.PicInfo.timeStamp &&

          m_width == (int)procOut.PicInfo.width && 

          m_height == (int)procOut.PicInfo.height)

        {

          m_timestamp = procOut.PicInfo.timeStamp;

          m_PictureNumber = procOut.PicInfo.picture_number;

          if (m_framerate_tracking)

            DoFrameRateTracking((double)m_timestamp / 1000.0);

          // do not let FreeList to get greater than 10

          if (m_FreeList.Count() > 10)

            delete m_FreeList.Pop();

          // Get next output buffer from the free list

          pBuffer = m_FreeList.Pop();

          if (!pBuffer)

          {

            // No free pre-allocated buffers so make one

            if (m_output_YV12)

            {

              // output YV12, nouveau driver has slow NV12, YUY2 capability.

              pBuffer = new CPictureBuffer(RENDER_FMT_YUV420P, m_width, m_height);

            }

            else

            {

              if (m_color_space == BCM::MODE422_YUY2)

                pBuffer = new CPictureBuffer(RENDER_FMT_YUYV422, m_width, m_height);

              else

                pBuffer = new CPictureBuffer(RENDER_FMT_NV12, m_width, m_height);

            }

            CLog::Log(LOGDEBUG, "%s: Added a new Buffer, ReadyListCount: %d", __MODULE_NAME__, m_ReadyList.Count());

            while (!m_bStop && m_ReadyList.Count() > 10)

              Sleep(1);

          }

          pBuffer->m_width = m_width;

          pBuffer->m_height = m_height;

          pBuffer->m_field = CRYSTALHD_FIELD_FULL;

          pBuffer->m_interlace = m_interlace > 0 ? true : false;

          pBuffer->m_framerate = m_framerate;

          pBuffer->m_timestamp = m_timestamp;

          pBuffer->m_color_space = m_color_space;

          pBuffer->m_color_range = m_color_range;

          pBuffer->m_color_matrix = m_color_matrix;

          pBuffer->m_PictureNumber = m_PictureNumber;

          int w = m_width;

          int h = m_height;

          // frame that are not equal in width to 720, 1280 or 1920

          // need to be copied by a quantized stride (possible lib/driver bug) so force it.

          int stride = m_width;

          if (!m_has_bcm70015)

          {

            // bcm70012 uses quantized strides

            if (w <= 720)

              stride = 720;

            else if (w <= 1280)

              stride = 1280;

            else

              stride = 1920;

          }

          if (pBuffer->m_color_space == BCM::MODE420)

          {

            switch(pBuffer->m_format)

            {

              case RENDER_FMT_NV12:

                if (pBuffer->m_interlace)

                  CopyOutAsNV12DeInterlace(pBuffer, &procOut, w, h, stride);

                else

                  CopyOutAsNV12(pBuffer, &procOut, w, h, stride);

              break;

              case RENDER_FMT_YUV420P:

                if (pBuffer->m_interlace)

                  CopyOutAsYV12DeInterlace(pBuffer, &procOut, w, h, stride);

                else

                  CopyOutAsYV12(pBuffer, &procOut, w, h, stride);

              break;

              default:

              break;

            }

          }

          else

          {

            switch(pBuffer->m_format)

            {

              case RENDER_FMT_YUYV422:

                if (pBuffer->m_interlace)

                {

                  // do simple line doubling de-interlacing.

                  // copy luma

                  int yuy2_w = w * 2;

                  int yuy2_stride = stride*2;

                  uint8_t *s_y = procOut.Ybuff;

                  uint8_t *d_y = pBuffer->m_y_buffer_ptr;

                  for (int y = 0; y < h/2; y++, s_y += yuy2_stride)

                  {

                    fast_memcpy(d_y, s_y, yuy2_w);

                    d_y += yuy2_w;

                    fast_memcpy(d_y, s_y, yuy2_w);

                    d_y += yuy2_w;

                  }

                  pBuffer->m_interlace = false;

                }

                else

                {

                  fast_memcpy(pBuffer->m_y_buffer_ptr,  procOut.Ybuff, pBuffer->m_y_buffer_size);

                }

              break;

              case RENDER_FMT_YUV420P:

                // TODO: deinterlace for yuy2 -> yv12, icky

                {

                  // Perform the color space conversion.

                  uint8_t* src[] =       { procOut.Ybuff, NULL, NULL, NULL };

                  int      srcStride[] = { stride*2, 0, 0, 0 };

                  uint8_t* dst[] =       { pBuffer->m_y_buffer_ptr, pBuffer->m_u_buffer_ptr, pBuffer->m_v_buffer_ptr, NULL };

                  int      dstStride[] = { pBuffer->m_width, pBuffer->m_width/2, pBuffer->m_width/2, 0 };

                  m_sw_scale_ctx = sws_getCachedContext(m_sw_scale_ctx,

                    pBuffer->m_width, pBuffer->m_height, PIX_FMT_YUYV422,

                    pBuffer->m_width, pBuffer->m_height, PIX_FMT_YUV420P,

                    SWS_FAST_BILINEAR | SwScaleCPUFlags(), NULL, NULL, NULL);

                  sws_scale(m_sw_scale_ctx, src, srcStride, 0, pBuffer->m_height, dst, dstStride);

                }

              break;

              default:

              break;

            }

          }

          CheckUpperLeftGreenPixelHack(pBuffer);

          m_ReadyList.Push(pBuffer);

          m_ready_event.Set();

          got_picture = true;

        }

        else

        {

          if (m_PictureNumber != procOut.PicInfo.picture_number)

            CLog::Log(LOGDEBUG, "%s: No timestamp detected: %" PRIu64, __MODULE_NAME__, procOut.PicInfo.timeStamp);

          m_PictureNumber = procOut.PicInfo.picture_number;

        }

      }

      m_dll->DtsReleaseOutputBuffs(m_device, NULL, FALSE);

    break;

    case BCM::BC_STS_FMT_CHANGE:

      CLog::Log(LOGDEBUG, "%s: Format Change Detected. Flags: 0x%08x", __MODULE_NAME__, procOut.PoutFlags);

      if ((procOut.PoutFlags & BCM::BC_POUT_FLAGS_PIB_VALID) && (procOut.PoutFlags & BCM::BC_POUT_FLAGS_FMT_CHANGE))

      {

        PrintFormat(procOut.PicInfo);

        if (procOut.PicInfo.height == 1088) {

          procOut.PicInfo.height = 1080;

        }

        m_width = procOut.PicInfo.width;

        m_height = procOut.PicInfo.height;

        m_timestamp = DVD_NOPTS_VALUE;

        m_color_space = procOut.b422Mode;

        m_color_range = 0;

        m_color_matrix = procOut.PicInfo.colour_primaries;

        SetAspectRatio(&procOut.PicInfo);

        SetFrameRate(procOut.PicInfo.frame_rate);

        if (procOut.PicInfo.flags & VDEC_FLAG_INTERLACED_SRC)

        {

          m_interlace = true;

        }

        m_timeout = 2000;

        m_format_valid = true;

        m_ready_event.Set();

      }

    break;

    case BCM::BC_STS_DEC_NOT_OPEN:

    break;

    case BCM::BC_STS_DEC_NOT_STARTED:

    break;

    case BCM::BC_STS_IO_USER_ABORT:

    break;

    case BCM::BC_STS_NO_DATA:

    break;

    case BCM::BC_STS_TIMEOUT:

    break;

    default:

      if (ret > 26)

        CLog::Log(LOGDEBUG, "%s: DtsProcOutput returned %d.", __MODULE_NAME__, ret);

      else

        CLog::Log(LOGDEBUG, "%s: DtsProcOutput returned %s.", __MODULE_NAME__, g_DtsStatusText[ret]);

    break;

  }

  return got_picture;

}

void CMPCOutputThread::Process(void)

{

  BCM::BC_STATUS ret;

  BCM::BC_DTS_STATUS decoder_status;

  m_PictureNumber = 0;

  CLog::Log(LOGDEBUG, "%s: Output Thread Started...", __MODULE_NAME__);

  // wait for decoder startup, calls into DtsProcOutputXXCopy will

  // return immediately until decoder starts getting input packets. 

  while (!m_bStop)

  {

    memset(&decoder_status, 0, sizeof(decoder_status));

    ret = m_dll->DtsGetDriverStatus(m_device, &decoder_status);

    if (ret == BCM::BC_STS_SUCCESS && decoder_status.ReadyListCount)

    {

      GetDecoderOutput();

      break;

    }

    Sleep(10);

  }

  // decoder is primed so now calls in DtsProcOutputXXCopy will block

  while (!m_bStop)

  {

    memset(&decoder_status, 0, sizeof(decoder_status));

    ret = m_dll->DtsGetDriverStatus(m_device, &decoder_status);

    if (ret == BCM::BC_STS_SUCCESS && decoder_status.ReadyListCount != 0)

      GetDecoderOutput();

    else

      Sleep(1);

#ifdef USE_CHD_SINGLE_THREADED_API

    while (!m_bStop)

    {

      ret = m_dll->DtsGetDriverStatus(m_device, &decoder_status);

      if (ret == BCM::BC_STS_SUCCESS && decoder_status.ReadyListCount != 0)

      {

        double pts = (double)decoder_status.NextTimeStamp / 1000.0;

        fprintf(stdout, "cpbEmptySize(%d), NextTimeStamp(%f)\n", decoder_status.cpbEmptySize, pts);

        break;

      }

      Sleep(10);

    }

#endif

  }

  CLog::Log(LOGDEBUG, "%s: Output Thread Stopped...", __MODULE_NAME__);

}

////////////////////////////////////////////////////////////////////////////////////////////

#if defined(TARGET_DARWIN)

#pragma mark -

#endif

CCrystalHD* CCrystalHD::m_pInstance = NULL;

CCrystalHD::CCrystalHD() :

  m_device(NULL),

  m_device_preset(false),

  m_new_lib(false),

  m_decoder_open(false),

  m_has_bcm70015(false),

  m_color_space(BCM::MODE420),

  m_drop_state(false),

  m_skip_state(false),

  m_timeout(0),

  m_wait_timeout(0),

  m_field(0),

  m_width(0),

  m_height(0),

  m_reset(0),

  m_last_pict_num(0),

  m_last_demuxer_pts(0.0),

  m_last_decoder_pts(0.0),

  m_pOutputThread(NULL),

  m_sps_pps_size(0),

  m_convert_bitstream(false)

{

#if (HAVE_LIBCRYSTALHD == 2)

  memset(&m_bc_info_crystal, 0, sizeof(m_bc_info_crystal));

#endif

  memset(&m_chd_params, 0, sizeof(m_chd_params));

  memset(&m_sps_pps_context, 0, sizeof(m_sps_pps_context));

  m_dll = new DllLibCrystalHD;

#ifdef TARGET_WINDOWS

  std::string  strDll;

  if(CWIN32Util::GetCrystalHDLibraryPath(strDll) && m_dll->SetFile(strDll) && m_dll->Load() && m_dll->IsLoaded() )

#else

  if (m_dll->Load() && m_dll->IsLoaded() )

#endif

  {

#if (HAVE_LIBCRYSTALHD == 2)

    m_new_lib = m_dll->LoadNewLibFunctions();

#endif

    OpenDevice();

#if (HAVE_LIBCRYSTALHD == 2)

    if (m_device && m_new_lib)

    {

      m_dll->DtsCrystalHDVersion(m_device, (BCM::PBC_INFO_CRYSTAL)&m_bc_info_crystal);

      m_has_bcm70015 = (m_bc_info_crystal.device == 1);

      // bcm70012 can do nv12 (420), yuy2 (422) and uyvy (422)

      // bcm70015 can do only yuy2 (422)

      if (m_has_bcm70015)

        m_color_space = BCM::OUTPUT_MODE422_YUY2;

    }

#endif

  }

  // delete dll if device open fails, minimizes ram footprint

  if (!m_device)

  {

    delete m_dll;

    m_dll = NULL;

    CLog::Log(LOGDEBUG, "%s: broadcom crystal hd not found", __MODULE_NAME__);

  }

  else

  {

    // we know there's a device present now, close the device until doing playback

    CloseDevice();

  }

}

CCrystalHD::~CCrystalHD()

{

  if (m_decoder_open)

    CloseDecoder();

  if (m_device)

    CloseDevice();

  if (m_dll)

    delete m_dll;

}

bool CCrystalHD::DevicePresent(void)

{

  return m_device_preset;

}

void CCrystalHD::RemoveInstance(void)

{

  if (m_pInstance)

  {

    delete m_pInstance;

    m_pInstance = NULL;

  }

}

CCrystalHD* CCrystalHD::GetInstance(void)

{

  if (!m_pInstance)

  {

    m_pInstance = new CCrystalHD();

  }

  return m_pInstance;

}

void CCrystalHD::OpenDevice()

{

  uint32_t mode = BCM::DTS_PLAYBACK_MODE          |

                  BCM::DTS_LOAD_FILE_PLAY_FW      |

#ifdef USE_CHD_SINGLE_THREADED_API

                  BCM::DTS_SINGLE_THREADED_MODE   |

#endif

                  BCM::DTS_SKIP_TX_CHK_CPB        |

                  BCM::DTS_PLAYBACK_DROP_RPT_MODE |

                  DTS_DFLT_RESOLUTION(BCM::vdecRESOLUTION_720p23_976);

  BCM::BC_STATUS res= m_dll->DtsDeviceOpen(&m_device, mode);

  if (res != BCM::BC_STS_SUCCESS)

  {

    m_device = NULL;

    if( res == BCM::BC_STS_DEC_EXIST_OPEN )

      CLog::Log(LOGDEBUG, "%s: device owned by another application", __MODULE_NAME__);

    else

      CLog::Log(LOGDEBUG, "%s: device open failed , returning(0x%x)", __MODULE_NAME__, res);

    m_device_preset = false;

  }

  else

  {

    #if (HAVE_LIBCRYSTALHD == 2)

      if (m_new_lib)

        CLog::Log(LOGDEBUG, "%s(new API): device opened", __MODULE_NAME__);

      else

        CLog::Log(LOGDEBUG, "%s(old API): device opened", __MODULE_NAME__);

    #else

      CLog::Log(LOGDEBUG, "%s: device opened", __MODULE_NAME__);

    #endif

    m_device_preset = true;

  }

}

void CCrystalHD::CloseDevice()

{

  if (m_device)

  {

    m_dll->DtsDeviceClose(m_device);

    m_device = NULL;

    CLog::Log(LOGDEBUG, "%s: device closed", __MODULE_NAME__);

  }

}

bool CCrystalHD::OpenDecoder(CRYSTALHD_CODEC_TYPE codec_type, CDVDStreamInfo &hints)

{

  BCM::BC_STATUS res;

  uint32_t StreamType;

#if (HAVE_LIBCRYSTALHD == 2)

  BCM::BC_MEDIA_SUBTYPE Subtype;

#endif

  if (!m_device_preset)

    return false;

  if (m_decoder_open)

    CloseDecoder();

  OpenDevice();

  if (!m_device)

    return false;

#if (HAVE_LIBCRYSTALHD == 2) && defined(TARGET_WINDOWS)

  // Drivers prior to 3.6.9.32 don't have proper support for CRYSTALHD_CODEC_ID_AVC1

  // The internal version numbers are different for some reason...

  if (   (m_bc_info_crystal.dilVersion.dilRelease < 3)

      || (m_bc_info_crystal.dilVersion.dilRelease == 3 && m_bc_info_crystal.dilVersion.dilMajor < 22)

      || (m_bc_info_crystal.drvVersion.drvRelease < 3)

      || (m_bc_info_crystal.drvVersion.drvRelease == 3 && m_bc_info_crystal.drvVersion.drvMajor < 7) )

  {

    CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Warning, "CrystalHD", g_localizeStrings.Get(2101));

    CLog::Log(LOGWARNING, "CrystalHD drivers too old, please upgrade to 3.6.9 or later. Make sure to uninstall the old version first or the upgrade won't work.");

    if (codec_type == CRYSTALHD_CODEC_ID_AVC1)

      return false;

  }

#endif

  uint32_t videoAlg = 0;

  switch (codec_type)

  {

    case CRYSTALHD_CODEC_ID_VC1:

      videoAlg = BCM::BC_VID_ALGO_VC1;

      StreamType = BCM::BC_STREAM_TYPE_ES;

      m_convert_bitstream = false;

    break;

    case CRYSTALHD_CODEC_ID_WVC1:

      videoAlg = BCM::BC_VID_ALGO_VC1MP;

      StreamType = BCM::BC_STREAM_TYPE_ES;

      m_convert_bitstream = false;

    break;

    case CRYSTALHD_CODEC_ID_WMV3:

      if (!m_has_bcm70015)

        return false;

      videoAlg = BCM::BC_VID_ALGO_VC1MP;

      StreamType = BCM::BC_STREAM_TYPE_ES;

      m_convert_bitstream = false;

    break;

    case CRYSTALHD_CODEC_ID_H264:

      videoAlg = BCM::BC_VID_ALGO_H264;

      StreamType = BCM::BC_STREAM_TYPE_ES;

      m_convert_bitstream = false;

    break;

    case CRYSTALHD_CODEC_ID_AVC1:

      videoAlg = BCM::BC_VID_ALGO_H264;

      StreamType = BCM::BC_STREAM_TYPE_ES;

      if (!m_new_lib)

        m_convert_bitstream = bitstream_convert_init((uint8_t*)hints.extradata, hints.extrasize);

      else

        m_convert_bitstream = false;

    break;

    case CRYSTALHD_CODEC_ID_MPEG2:

      videoAlg = BCM::BC_VID_ALGO_MPEG2;

      StreamType = BCM::BC_STREAM_TYPE_ES;

      m_convert_bitstream = false;

    break;

    //BC_VID_ALGO_DIVX:

    //BC_VID_ALGO_VC1MP:

    default:

      return false;

    break;

  }

#if (HAVE_LIBCRYSTALHD == 2)

  uint8_t *pMetaData = NULL;

  uint32_t metaDataSz = 0;

  uint32_t startCodeSz = 4;

  m_chd_params.sps_pps_buf = NULL;

  switch (codec_type)

  {

    case CRYSTALHD_CODEC_ID_VC1:

      Subtype = BCM::BC_MSUBTYPE_VC1;

      pMetaData = (uint8_t*)hints.extradata;

      metaDataSz = hints.extrasize;

    break;

    case CRYSTALHD_CODEC_ID_WVC1:

      Subtype = BCM::BC_MSUBTYPE_WVC1;

    break;

    case CRYSTALHD_CODEC_ID_WMV3:

      Subtype = BCM::BC_MSUBTYPE_WMV3;

      pMetaData = (uint8_t*)hints.extradata;

      metaDataSz = hints.extrasize;

    break;

    case CRYSTALHD_CODEC_ID_H264:

      Subtype = BCM::BC_MSUBTYPE_H264;

      pMetaData = (uint8_t*)hints.extradata;

      metaDataSz = hints.extrasize;

    break;

    case CRYSTALHD_CODEC_ID_AVC1:

      Subtype = BCM::BC_MSUBTYPE_AVC1;

      m_chd_params.sps_pps_buf = (uint8_t*)malloc(1000);

			if (!extract_sps_pps_from_avcc(hints.extrasize, hints.extradata))

      {

        free(m_chd_params.sps_pps_buf);

        m_chd_params.sps_pps_buf = NULL;

			}

      else

      {

        pMetaData = m_chd_params.sps_pps_buf;

        metaDataSz = m_chd_params.sps_pps_size;

        startCodeSz = m_chd_params.nal_size_bytes;

      }

    break;

    case CRYSTALHD_CODEC_ID_MPEG2:

      Subtype = BCM::BC_MSUBTYPE_MPEG2VIDEO;

      pMetaData = (uint8_t*)hints.extradata;

      metaDataSz = hints.extrasize;

    break;

    //BC_VID_ALGO_DIVX:

    //BC_VID_ALGO_VC1MP:

  }

#endif

  do

  {

#if (HAVE_LIBCRYSTALHD == 2)

    if (m_new_lib)

    {

      BCM::BC_INPUT_FORMAT bcm_input_format;

      memset(&bcm_input_format, 0, sizeof(BCM::BC_INPUT_FORMAT));

      bcm_input_format.FGTEnable = FALSE;

      bcm_input_format.Progressive = TRUE;

      bcm_input_format.OptFlags = 0x80000000 | BCM::vdecFrameRate23_97;

      #ifdef USE_CHD_SINGLE_THREADED_API

        bcm_input_format.OptFlags |= 0x80;

      #endif

      bcm_input_format.width = hints.width;

      bcm_input_format.height = hints.height;

      bcm_input_format.mSubtype = Subtype;

      bcm_input_format.pMetaData = pMetaData;

      bcm_input_format.metaDataSz = metaDataSz;

      bcm_input_format.startCodeSz = startCodeSz;

      res = m_dll->DtsSetInputFormat(m_device, &bcm_input_format);

      if (res != BCM::BC_STS_SUCCESS)

      {

        CLog::Log(LOGERROR, "%s: set input format failed", __MODULE_NAME__);

        break;

      }

      res = m_dll->DtsOpenDecoder(m_device, StreamType);

      if (res != BCM::BC_STS_SUCCESS)

      {

        CLog::Log(LOGERROR, "%s: open decoder failed", __MODULE_NAME__);

        break;

      }

      if (m_has_bcm70015)

        res = m_dll->DtsSetColorSpace(m_device, BCM::OUTPUT_MODE422_YUY2); 

      else

        res = m_dll->DtsSetColorSpace(m_device, BCM::OUTPUT_MODE420); 

      if (res != BCM::BC_STS_SUCCESS)

      { 

        CLog::Log(LOGERROR, "%s: set color space failed", __MODULE_NAME__); 

        break; 

      }

    }

    else

#endif

    {

      res = m_dll->DtsOpenDecoder(m_device, StreamType);

      if (res != BCM::BC_STS_SUCCESS)

      {

        CLog::Log(LOGERROR, "%s: open decoder failed", __MODULE_NAME__);

        break;

      }

      uint32_t OptFlags = 0x80000000 | BCM::vdecFrameRate23_97;

      res = m_dll->DtsSetVideoParams(m_device, videoAlg, FALSE, FALSE, TRUE, OptFlags);

      if (res != BCM::BC_STS_SUCCESS)

      {

        CLog::Log(LOGERROR, "%s: set video params failed", __MODULE_NAME__);

        break;

      }

    }

    res = m_dll->DtsStartDecoder(m_device);

    if (res != BCM::BC_STS_SUCCESS)

    {

      CLog::Log(LOGERROR, "%s: start decoder failed", __MODULE_NAME__);

      break;

    }

    res = m_dll->DtsStartCapture(m_device);

    if (res != BCM::BC_STS_SUCCESS)

    {

      CLog::Log(LOGERROR, "%s: start capture failed", __MODULE_NAME__);

      break;

    }

    m_pOutputThread = new CMPCOutputThread(m_device, m_dll, m_has_bcm70015);

    m_pOutputThread->Create();

    m_drop_state = false;

    m_skip_state = false;

    m_decoder_open = true;

    // set output timeout to 1ms during startup,

    // this will get reset once we get a picture back.

    // the effect is to speed feeding demux packets during startup.

    m_wait_timeout = 1;

    m_reset = 0;

    m_last_pict_num = 0;

    m_last_demuxer_pts = DVD_NOPTS_VALUE;

    m_last_decoder_pts = DVD_NOPTS_VALUE;

  } while(false);

  return m_decoder_open;

}

void CCrystalHD::CloseDecoder(void)

{

  if (m_pOutputThread)

  {

    while(m_BusyList.Count())

      m_pOutputThread->FreeListPush( m_BusyList.Pop() );

    m_pOutputThread->StopThread();

    delete m_pOutputThread;

    m_pOutputThread = NULL;

  }

  if (m_convert_bitstream)

  {

    if (m_sps_pps_context.sps_pps_data)

    {

      free(m_sps_pps_context.sps_pps_data);

      m_sps_pps_context.sps_pps_data = NULL;

    }

  }

#if (HAVE_LIBCRYSTALHD == 2)

	if (m_chd_params.sps_pps_buf)

  {

		free(m_chd_params.sps_pps_buf);

		m_chd_params.sps_pps_buf = NULL;

	}

#endif

  if (m_decoder_open)

  {

    // DtsFlushRxCapture must release internal queues when

    // calling DtsStopDecoder/DtsCloseDecoder or the next

    // DtsStartCapture will fail. This is a driver/lib bug

    // with new chd driver. The existing driver ignores the

    // bDiscardOnly arg.

    if (!m_has_bcm70015)

      m_dll->DtsFlushRxCapture(m_device, false);

    m_dll->DtsStopDecoder(m_device);

    m_dll->DtsCloseDecoder(m_device);

    m_decoder_open = false;

  }

  CloseDevice();

}

void CCrystalHD::Reset(void)

{

  if (!m_has_bcm70015)

  {

    // Calling for non-error flush, Flushes all the decoder

    //  buffers, input, decoded and to be decoded. 

    m_reset = 10;

    m_wait_timeout = 1;

    m_dll->DtsFlushInput(m_device, 2);

  }

  while (m_BusyList.Count())

    m_pOutputThread->FreeListPush( m_BusyList.Pop() );

  while (m_pOutputThread->GetReadyCount())

  {

    ::Sleep(1);

    m_pOutputThread->FreeListPush( m_pOutputThread->ReadyListPop() );

  }

}

bool CCrystalHD::AddInput(unsigned char *pData, size_t size, double dts, double pts)

{

  if (pData)

  {

    BCM::BC_STATUS ret;

    uint64_t int_pts = pts * 1000;

    int demuxer_bytes = size;

    uint8_t *demuxer_content = pData;

    bool free_demuxer_content  = false;

    if (m_convert_bitstream)

    {

      // convert demuxer packet from bitstream (AVC1) to bytestream (AnnexB)

      int bytestream_size = 0;

      uint8_t *bytestream_buff = NULL;

      bitstream_convert(demuxer_content, demuxer_bytes, &bytestream_buff, &bytestream_size);

      if (bytestream_buff && (bytestream_size > 0))

      {

        if (bytestream_buff != demuxer_content)

          free_demuxer_content = true;

        demuxer_bytes = bytestream_size;

        demuxer_content = bytestream_buff;

      }

    }

    do

    {

      ret = m_dll->DtsProcInput(m_device, demuxer_content, demuxer_bytes, int_pts, 0);

      if (ret == BCM::BC_STS_SUCCESS)

      {

        m_last_demuxer_pts = pts;

      }

      else if (ret == BCM::BC_STS_BUSY)

      {

        CLog::Log(LOGDEBUG, "%s: DtsProcInput returned BC_STS_BUSY", __MODULE_NAME__);

        ::Sleep(1); // Buffer is full, sleep it empty

      }

    } while (ret != BCM::BC_STS_SUCCESS);

    if (free_demuxer_content)

      free(demuxer_content);

    if (!m_has_bcm70015)

    {

      if (m_reset)

      {

        m_reset--;

        if (!m_skip_state)

        {

          m_skip_state = true;

          m_dll->DtsSetSkipPictureMode(m_device, 1);

        }

      }

      else

      {

        if (m_skip_state)

        {

          m_skip_state = false;

          m_dll->DtsSetSkipPictureMode(m_device, 0);

        }

      }