Ticket #4270: 4270-mythtv-v1.patch

libs/libmythtv/NuppelVideoPlayer.cpp

@@ -13 +13 @@
 #include <fcntl.h>
 #include <sched.h>
 #include <sys/time.h>
-#include <sys/ioctl.h>
 
 // C++ headers
 #include <algorithm>
@@ -6609 +6608 @@
 
                 OSDTypeImage* image = new OSDTypeImage();
                 image->SetPosition(QPoint(rect->x, rect->y), hmult, vmult);
-                image->LoadFromQImage(qImage);
+                image->Load(qImage);
 
                 subtitleOSD->AddType(image);
 
@@ -6924 +6923 @@
 
         OSDTypeImage* image = new OSDTypeImage();
         image->SetPosition(QPoint(btnX, btnY), hmult, vmult);
-        image->LoadFromQImage(hl_button);
+        image->Load(hl_button);
         image->SetDontRoundPosition(true);
 
         subtitleOSD->AddType(image);

libs/libmythtv/osdlistbtntype.cpp

@@ -709 +709 @@
         QImage img(data, width, height, 32, NULL, 65536 * 65536,
                    QImage::LittleEndian);
         img.setAlphaBuffer(alpha<255);
-        osdImg.LoadFromQImage(img);
+        osdImg.Load(img);
     }
     delete[] data;
 }
@@ -717 +717 @@
 void OSDListBtnType::LoadPixmap(OSDTypeImage& pix, const QString& fileName)
 {
     QString path = gContext->GetThemesParentDir() + "default/lb-";
-    pix.LoadImage(path + fileName + ".png", m_wmult, m_hmult);
+    pix.Load(path + fileName + ".png", m_wmult, m_hmult);
 }
 
 /////////////////////////////////////////////////////////////////////////////

libs/libmythtv/videoout_d3d.cpp

@@ +1 @@
+// -*- Mode: c++ -*-
+
+#include <map>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+
+#define _WIN32_WINNT 0x500
+#include "mythcontext.h"
+#include "videoout_d3d.h"
+#include "filtermanager.h"
+#include "fourcc.h"
+
+#include "mmsystem.h"
+#include "tv.h"
+
+#include <qapplication.h>
+
+#undef UNICODE
+
+extern "C" {
+#include "../libavcodec/avcodec.h"
+}
+
+typedef struct
+{
+    FLOAT       x;          // vertex untransformed x position
+    FLOAT       y;          // vertex untransformed y position
+    FLOAT       z;          // vertex untransformed z position
+    FLOAT       rhw;        // eye distance
+    D3DCOLOR    diffuse;    // diffuse color
+    FLOAT       tu;         // texture u coordinate
+    FLOAT       tv;         // texture v coordinate
+} CUSTOMVERTEX;
+
+#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZRHW|D3DFVF_DIFFUSE|D3DFVF_TEX1)
+
+const int kNumBuffers = 31;
+const int kNeedFreeFrames = 1;
+const int kPrebufferFramesNormal = 10;
+const int kPrebufferFramesSmall = 4;
+const int kKeepPrebuffer = 2;
+
+#define LOC      QString("VideoOutputD3D: ")
+#define LOC_WARN QString("VideoOutputD3D Warning: ")
+#define LOC_ERR  QString("VideoOutputD3D Error: ")
+
+VideoOutputD3D::VideoOutputD3D(void)
+    : VideoOutput(), m_InputCX(0), m_InputCY(0),
+      m_lock(true), m_RefreshRate(60), m_hWnd(NULL),
+      m_ddFormat(D3DFMT_UNKNOWN), m_pD3D(NULL), m_pd3dDevice(NULL),
+      m_pSurface(NULL), m_pTexture(NULL), m_pVertexBuffer(NULL)
+{
+    VERBOSE(VB_PLAYBACK, LOC + "ctor");
+    m_pauseFrame.buf = NULL;
+}
+
+VideoOutputD3D::~VideoOutputD3D()
+{
+    Exit();
+}
+
+void VideoOutputD3D::Exit(void)
+{
+    VERBOSE(VB_PLAYBACK, LOC + "Exit()");
+    QMutexLocker locker(&m_lock);
+    vbuffers.DeleteBuffers();
+    if (m_pauseFrame.buf)
+    {
+        delete [] m_pauseFrame.buf;
+        m_pauseFrame.buf = NULL;
+    }
+    UnInitD3D();
+}
+
+void VideoOutputD3D::UnInitD3D(void)
+{
+    QMutexLocker locker(&m_lock);
+
+    if (m_pVertexBuffer)
+    {
+        m_pVertexBuffer->Release();
+        m_pVertexBuffer = NULL;
+    }
+
+    if (m_pTexture)
+    {
+        m_pTexture->Release();
+        m_pTexture = NULL;
+    }
+
+    if (m_pSurface)
+    {
+        m_pSurface->Release();
+        m_pSurface = NULL;
+    }
+
+    if (m_pd3dDevice)
+    {
+        m_pd3dDevice->Release();
+        m_pd3dDevice = NULL;
+    }
+
+    if (m_pD3D)
+    {
+        m_pD3D->Release();
+        m_pD3D = NULL;
+    }
+}
+
+bool VideoOutputD3D::InputChanged(const QSize &input_size,
+                                  float        aspect,
+                                  MythCodecID  av_codec_id,
+                                  void        *codec_private)
+{
+    QMutexLocker locker(&m_lock);
+    VideoOutput::InputChanged(input_size, aspect, av_codec_id, codec_private);
+    db_vdisp_profile->SetVideoRenderer("didect3d");
+
+    if (input_size.width()  == m_InputCX &&
+        input_size.height() == m_InputCY)
+    {
+        MoveResize();
+        return true;
+    }
+
+    m_InputCX = input_size.width();
+    m_InputCY = input_size.height();
+    VERBOSE(VB_PLAYBACK, LOC + "InputChanged, x="<< m_InputCX
+            << ", y=" << m_InputCY);
+
+    video_dim = input_size;
+    vbuffers.DeleteBuffers();
+
+    MoveResize();
+
+    if (!vbuffers.CreateBuffers(m_InputCX, m_InputCY))
+    {
+        VERBOSE(VB_IMPORTANT, LOC + "InputChanged(): "
+                "Failed to recreate buffers");
+        errored = true;
+    }
+
+    if (!InitD3D())
+        UnInitD3D();
+
+    if (m_pauseFrame.buf)
+    {
+        delete [] m_pauseFrame.buf;
+        m_pauseFrame.buf = NULL;
+    }
+
+    m_pauseFrame.height = vbuffers.GetScratchFrame()->height;
+    m_pauseFrame.width  = vbuffers.GetScratchFrame()->width;
+    m_pauseFrame.bpp    = vbuffers.GetScratchFrame()->bpp;
+    m_pauseFrame.size   = vbuffers.GetScratchFrame()->size;
+    m_pauseFrame.buf    = new unsigned char[m_pauseFrame.size + 128];
+    m_pauseFrame.frameNumber = vbuffers.GetScratchFrame()->frameNumber;
+
+    return true;
+}
+
+bool VideoOutputD3D::InitD3D()
+{
+    VERBOSE(VB_PLAYBACK, LOC + QString("InitD3D start (x=%1, y=%2)")
+            .arg(m_InputCX).arg(m_InputCY));
+
+    QMutexLocker locker(&m_lock);
+    D3DCAPS9 d3dCaps;
+
+    typedef LPDIRECT3D9 (WINAPI *LPFND3DC)(UINT SDKVersion);
+    static LPFND3DC OurDirect3DCreate9 = NULL;
+    static HINSTANCE hD3DLib = NULL;
+
+    if (!hD3DLib)
+    {
+        hD3DLib = LoadLibrary(TEXT("D3D9.DLL"));
+        if (!hD3DLib)
+        {
+            VERBOSE(VB_IMPORTANT, LOC_ERR + "Cannot load d3d9.dll (Direct3D)");
+            return false;
+        }
+    }
+
+    if (!OurDirect3DCreate9)
+    {
+        OurDirect3DCreate9 = (LPFND3DC) GetProcAddress(
+            hD3DLib, TEXT("Direct3DCreate9"));
+
+        if (!OurDirect3DCreate9)
+        {
+            VERBOSE(VB_IMPORTANT, LOC_ERR + "Cannot locate reference to "
+                    "Direct3DCreate9 ABI in DLL");
+
+            return false;
+        }
+    }
+
+    /* Create the D3D object. */
+    m_pD3D = OurDirect3DCreate9(D3D_SDK_VERSION);
+    if (!m_pD3D)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR +
+                "Could not create Direct3D9 instance.");
+
+        return false;
+    }
+
+    // Get device capabilities
+    ZeroMemory(&d3dCaps, sizeof(d3dCaps));
+
+    if (D3D_OK != m_pD3D->GetDeviceCaps(
+            D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &d3dCaps))
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR +
+                "Could not read adapter capabilities.");
+
+        return false;
+    }
+
+    D3DDISPLAYMODE d3ddm;
+    // Get the current desktop display mode, so we can set up a back
+    // buffer of the same format
+    if (D3D_OK != m_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm))
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR +
+                "Could not read adapter display mode.");
+
+        return false;
+    }
+    m_RefreshRate = d3ddm.RefreshRate;
+
+    m_ddFormat = d3ddm.Format;
+    D3DPRESENT_PARAMETERS d3dpp;
+
+    /* Set up the structure used to create the D3DDevice. */
+    ZeroMemory(&d3dpp, sizeof(D3DPRESENT_PARAMETERS));
+    d3dpp.Flags                  = D3DPRESENTFLAG_VIDEO;
+    d3dpp.Windowed               = TRUE;
+    d3dpp.hDeviceWindow          = m_hWnd;
+    d3dpp.BackBufferWidth        = m_InputCX;
+    d3dpp.BackBufferHeight       = m_InputCY;
+    d3dpp.SwapEffect             = D3DSWAPEFFECT_COPY;
+    d3dpp.MultiSampleType        = D3DMULTISAMPLE_NONE;
+    d3dpp.PresentationInterval   = D3DPRESENT_INTERVAL_ONE;
+    d3dpp.BackBufferFormat       = d3ddm.Format;
+    d3dpp.BackBufferCount        = 1;
+    d3dpp.EnableAutoDepthStencil = FALSE;
+
+    // Create the D3DDevice
+    if (D3D_OK != m_pD3D->CreateDevice(D3DADAPTER_DEFAULT,
+                                       D3DDEVTYPE_HAL, m_hWnd,
+                                       D3DCREATE_SOFTWARE_VERTEXPROCESSING,
+                                       &d3dpp, &m_pd3dDevice))
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Could not create the D3D device!");
+        return false;
+    }
+
+    //input seems to always be PIX_FMT_YUV420P
+    //MAKEFOURCC('I','4','2','0');
+    //D3DFMT_G8R8_G8B8???
+
+    D3DFORMAT format = D3DFMT_X8R8G8B8;
+    /* test whether device can create a surface of that format */
+    HRESULT hr = m_pD3D->CheckDeviceFormat(
+        D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, m_ddFormat, 0,
+        D3DRTYPE_SURFACE, format);
+
+    if (SUCCEEDED(hr))
+    {
+        /* test whether device can perform color-conversion
+        ** from that format to target format
+        */
+        hr = m_pD3D->CheckDeviceFormatConversion(
+            D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
+            format, m_ddFormat);
+
+        if (FAILED(hr))
+        {
+            VERBOSE(VB_IMPORTANT, LOC_ERR +
+                    "CheckDeviceFormatConversion failed");
+
+            return false;
+        }
+    }
+    else
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "CheckDeviceFormat failed");
+        return false;
+    }
+
+    hr = m_pd3dDevice->CreateOffscreenPlainSurface(
+        m_InputCX,
+        m_InputCY,
+        format,
+        D3DPOOL_DEFAULT,
+        &m_pSurface,
+        NULL);
+
+    if (FAILED(hr))
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to create picture surface");
+        return false;
+    }
+
+    /* fill surface with black color */
+    m_pd3dDevice->ColorFill(m_pSurface, NULL, D3DCOLOR_ARGB(0xFF, 0, 0, 0) );
+
+    /*
+    ** Create a texture for use when rendering a scene
+    ** for performance reason, texture format is identical to backbuffer
+    ** which would usually be a RGB format
+    */
+    hr = m_pd3dDevice->CreateTexture(
+        m_InputCX,
+        m_InputCY,
+        1,
+        D3DUSAGE_RENDERTARGET,
+        m_ddFormat,
+        D3DPOOL_DEFAULT,
+        &m_pTexture,
+        NULL);
+
+    if (FAILED(hr))
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to create texture");
+        return false;
+    }
+
+    /*
+    ** Create a vertex buffer for use when rendering scene
+    */
+    hr = m_pd3dDevice->CreateVertexBuffer(
+        sizeof(CUSTOMVERTEX)*4,
+        D3DUSAGE_DYNAMIC|D3DUSAGE_WRITEONLY,
+        D3DFVF_CUSTOMVERTEX,
+        D3DPOOL_DEFAULT,
+        &m_pVertexBuffer,
+        NULL);
+    if (FAILED(hr))
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to create vertex buffer");
+        return false;
+    }
+
+    /* Update the vertex buffer */
+    CUSTOMVERTEX *p_vertices;
+    hr = m_pVertexBuffer->Lock(0, 0, (VOID **)(&p_vertices), D3DLOCK_DISCARD);
+
+    if (FAILED(hr))
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to lock vertex buffer");
+        return false;
+    }
+
+    /* Setup vertices */
+    p_vertices[0].x       = 0.0f;       // left
+    p_vertices[0].y       = 0.0f;       // top
+    p_vertices[0].z       = 0.0f;
+    p_vertices[0].diffuse = D3DCOLOR_ARGB(255, 255, 255, 255);
+    p_vertices[0].rhw     = 1.0f;
+    p_vertices[0].tu      = 0.0f;
+    p_vertices[0].tv      = 0.0f;
+
+    p_vertices[1].x       = (float)m_InputCX;    // right
+    p_vertices[1].y       = 0.0f;       // top
+    p_vertices[1].z       = 0.0f;
+    p_vertices[1].diffuse = D3DCOLOR_ARGB(255, 255, 255, 255);
+    p_vertices[1].rhw     = 1.0f;
+    p_vertices[1].tu      = 1.0f;
+    p_vertices[1].tv      = 0.0f;
+
+    p_vertices[2].x       = (float)m_InputCX;    // right
+    p_vertices[2].y       = (float)m_InputCY;   // bottom
+    p_vertices[2].z       = 0.0f;
+    p_vertices[2].diffuse = D3DCOLOR_ARGB(255, 255, 255, 255);
+    p_vertices[2].rhw     = 1.0f;
+    p_vertices[2].tu      = 1.0f;
+    p_vertices[2].tv      = 1.0f;
+
+    p_vertices[3].x       = 0.0f;       // left
+    p_vertices[3].y       = (float)m_InputCY;   // bottom
+    p_vertices[3].z       = 0.0f;
+    p_vertices[3].diffuse = D3DCOLOR_ARGB(255, 255, 255, 255);
+    p_vertices[3].rhw     = 1.0f;
+    p_vertices[3].tu      = 0.0f;
+    p_vertices[3].tv      = 1.0f;
+
+    hr = m_pVertexBuffer->Unlock();
+    if (FAILED(hr))
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to unlock vertex buffer");
+        return false;
+    }
+
+    // Texture coordinates outside the range [0.0, 1.0] are set
+    // to the texture color at 0.0 or 1.0, respectively.
+    m_pd3dDevice->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
+    m_pd3dDevice->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
+
+    // Set linear filtering quality
+    m_pd3dDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
+    m_pd3dDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
+
+    // set maximum ambient light
+    m_pd3dDevice->SetRenderState(D3DRS_AMBIENT, D3DCOLOR_XRGB(255,255,255));
+
+    // Turn off culling
+    m_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
+
+    // Turn off the zbuffer
+    m_pd3dDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_FALSE);
+
+    // Turn off lights
+    m_pd3dDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
+
+    // Enable dithering
+    m_pd3dDevice->SetRenderState(D3DRS_DITHERENABLE, TRUE);
+
+    // disable stencil
+    m_pd3dDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE);
+
+    // manage blending
+    m_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
+    m_pd3dDevice->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
+    m_pd3dDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);
+    m_pd3dDevice->SetRenderState(D3DRS_ALPHATESTENABLE,TRUE);
+    m_pd3dDevice->SetRenderState(D3DRS_ALPHAREF, 0x10);
+    m_pd3dDevice->SetRenderState(D3DRS_ALPHAFUNC,D3DCMP_GREATER);
+
+    // Set texture states
+    m_pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP,D3DTOP_MODULATE);
+    m_pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1,D3DTA_TEXTURE);
+    m_pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2,D3DTA_DIFFUSE);
+
+    // turn off alpha operation
+    m_pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
+
+    VERBOSE(VB_GENERAL, LOC +
+            "Direct3D device adapter successfully initialized");
+
+    return true;
+}
+
+int VideoOutputD3D::GetRefreshRate(void)
+{
+    return 1000000 / m_RefreshRate;
+}
+
+bool VideoOutputD3D::Init(int width, int height, float aspect,
+                          WId winid, int winx, int winy, int winw,
+                          int winh, WId embedid)
+{
+    VERBOSE(VB_PLAYBACK, LOC_ERR +
+            "Init w=" << width << " h=" << height);
+
+    db_vdisp_profile->SetVideoRenderer("direct3d");
+
+    vbuffers.Init(kNumBuffers, true, kNeedFreeFrames,
+                  kPrebufferFramesNormal, kPrebufferFramesSmall,
+                  kKeepPrebuffer);
+
+    VideoOutput::Init(width, height, aspect, winid,
+                      winx, winy, winw, winh, embedid);
+
+    m_hWnd = winid;
+
+    m_InputCX  = width;
+    m_InputCY = height;
+
+    if (!vbuffers.CreateBuffers(width, height))
+        return false;
+
+    if (!InitD3D())
+    {
+        UnInitD3D();
+        return false;
+    }
+
+    m_pauseFrame.height = vbuffers.GetScratchFrame()->height;
+    m_pauseFrame.width  = vbuffers.GetScratchFrame()->width;
+    m_pauseFrame.bpp    = vbuffers.GetScratchFrame()->bpp;
+    m_pauseFrame.size   = vbuffers.GetScratchFrame()->size;
+    m_pauseFrame.buf    = new unsigned char[m_pauseFrame.size + 128];
+    m_pauseFrame.frameNumber = vbuffers.GetScratchFrame()->frameNumber;
+
+    MoveResize();
+
+    return true;
+}
+
+void VideoOutputD3D::PrepareFrame(VideoFrame *buffer, FrameScanType t)
+{
+    if (IsErrored())
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR +
+                "PrepareFrame() called while IsErrored is true.");
+        return;
+    }
+
+    if (!buffer)
+        buffer = vbuffers.GetScratchFrame();
+
+    framesPlayed = buffer->frameNumber + 1;
+    AVPicture image_in, image_out;
+
+    D3DLOCKED_RECT d3drect;
+    /* Lock the surface to get a valid pointer to the picture buffer */
+    HRESULT hr = m_pSurface->LockRect(&d3drect, NULL, 0);
+    if (FAILED(hr))
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to lock picture surface");
+        return;
+    }
+
+    avpicture_fill(&image_out, (uint8_t*) d3drect.pBits,
+                   PIX_FMT_RGBA32, m_InputCX, m_InputCY);
+    image_out.linesize[0] = d3drect.Pitch;
+    avpicture_fill(&image_in, buffer->buf,
+                   PIX_FMT_YUV420P, m_InputCX, m_InputCY);
+    img_convert(&image_out, PIX_FMT_RGBA32, &image_in,
+                PIX_FMT_YUV420P, m_InputCX, m_InputCY);
+
+#if 0
+    static int c = 0;
+    for (int y = 0; y < m_InputCY; y++)
+    {
+        for (int x = 0; x < m_InputCX; x++)
+        {
+            ((int*)d3drect.pBits)[y * d3drect.Pitch / 4 + x] =
+                ((x + c) & 0xff) << 8;
+        }
+    }
+    c += 5;
+#endif
+
+    hr = m_pSurface->UnlockRect();
+    if (FAILED(hr))
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to unlock picture surface");
+        return;
+    }
+}
+
+void VideoOutputD3D::Show(FrameScanType )
+{
+    if (IsErrored())
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR +
+                "Show() called while IsErrored is true.");
+
+        return;
+    }
+
+    if (m_pd3dDevice)
+    {
+        LPDIRECT3DSURFACE9      p_d3ddest;
+        HRESULT hr;
+
+        // check if device is still available
+        hr = m_pd3dDevice->TestCooperativeLevel();
+        if (FAILED(hr))
+        {
+            if (D3DERR_DEVICENOTRESET != hr)
+            {
+                // device is not usable at present
+                // (lost device, out of video mem ?)
+                goto RenderError;
+            }
+        }
+
+        /* Clear the backbuffer and the zbuffer */
+        hr = m_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET,
+                                 D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
+        if (FAILED(hr))
+            goto RenderError;
+
+        /* retrieve texture top-level surface */
+        hr = m_pTexture->GetSurfaceLevel(0, &p_d3ddest);
+        if (FAILED(hr))
+            goto RenderError;
+
+        /* Copy picture surface into texture surface,
+           color space conversion happens here */
+        hr = m_pd3dDevice->StretchRect(m_pSurface, NULL, p_d3ddest,
+                                       NULL, D3DTEXF_NONE);
+        p_d3ddest->Release();
+        if (FAILED(hr))
+            goto RenderError;
+
+        // Begin the scene
+        hr = m_pd3dDevice->BeginScene();
+        if (FAILED(hr))
+            goto RenderError;
+
+        // Setup our texture. Using textures introduces the texture
+        // stage states, which govern how textures get blended together
+        // (in the case of multiple textures) and lighting information.
+        // In this case, we are modulating (blending) our texture with
+        // the diffuse color of the vertices.
+        hr = m_pd3dDevice->SetTexture(0, (LPDIRECT3DBASETEXTURE9)m_pTexture);
+        if (FAILED(hr))
+        {
+            m_pd3dDevice->EndScene();
+            goto RenderError;
+        }
+
+        // Render the vertex buffer contents
+        hr = m_pd3dDevice->SetStreamSource(0, m_pVertexBuffer,
+                                           0, sizeof(CUSTOMVERTEX));
+        if (FAILED(hr))
+        {
+            m_pd3dDevice->EndScene();
+            goto RenderError;
+        }
+
+        // we use FVF instead of vertex shader
+        hr = m_pd3dDevice->SetVertexShader(NULL);
+        if (FAILED(hr))
+        {
+            m_pd3dDevice->EndScene();
+            goto RenderError;
+        }
+
+        hr = m_pd3dDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
+        if (FAILED(hr))
+        {
+            m_pd3dDevice->EndScene();
+            goto RenderError;
+        }
+
+        // draw rectangle
+        hr = m_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLEFAN, 0, 2);
+        if (FAILED(hr))
+        {
+            m_pd3dDevice->EndScene();
+            goto RenderError;
+        }
+
+        // End the scene
+        hr = m_pd3dDevice->EndScene();
+        if (FAILED(hr))
+        {
+            goto RenderError;
+        }
+
+        {
+            RECT rc_dest;
+            if (!embedding)
+            {
+                ::GetClientRect(m_hWnd, &rc_dest);
+                rc_dest.right--;
+                rc_dest.bottom--;
+            }
+            else
+            {
+                rc_dest.left = display_visible_rect.left();
+                rc_dest.top = display_visible_rect.top();
+                rc_dest.right = display_visible_rect.right();
+                rc_dest.bottom = display_visible_rect.bottom();
+            }
+
+            RECT rc_src =
+                {0, 0, m_InputCX-1, m_InputCY-1};
+
+            // A
+            if (display_video_rect.height() < rc_dest.bottom - rc_dest.top)
+            {
+                rc_dest.top    = display_video_rect.top();
+                rc_dest.bottom = display_video_rect.bottom();
+                rc_src.left    = (display_video_rect.width() -
+                                  (rc_dest.right - rc_dest.left)) / 2;
+                rc_src.right  -= rc_src.left;
+            }
+            // B
+            if (display_video_rect.width() < rc_dest.right - rc_dest.left)
+            {
+                rc_dest.left   = display_video_rect.left();
+                rc_dest.right  = display_video_rect.right();
+                rc_src.top     = (display_video_rect.height() -
+                                  (rc_dest.bottom - rc_dest.top)) / 2;
+                rc_src.bottom -= rc_src.top;
+            }
+
+            m_rcDest = rc_dest;
+            hr = m_pd3dDevice->Present(&rc_src, &rc_dest, NULL, NULL);
+        }
+
+        if (FAILED(hr))
+            RenderError:
+
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Video rendering failed");
+
+        qApp->wakeUpGuiThread();
+    }
+    else
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Direct3D device not initialized");
+    }
+}
+
+void VideoOutputD3D::Zoom(ZoomDirection direction)
+{
+    RECT rc;
+    ::GetClientRect(m_hWnd, &rc);
+
+    HDC hdc = ::GetDC(m_hWnd);
+    if (hdc)
+    {
+        ::FillRect(hdc, &rc, (HBRUSH)::GetStockObject(BLACK_BRUSH));
+        ::ReleaseDC(m_hWnd, hdc);
+    }
+}
+
+void VideoOutputD3D::UpdatePauseFrame(void)
+{
+    QMutexLocker locker(&m_lock);
+    VideoFrame *used_frame = vbuffers.head(kVideoBuffer_used);
+    if (!used_frame)
+        used_frame = vbuffers.GetScratchFrame();
+
+    CopyFrame(&m_pauseFrame, used_frame);
+}
+
+void VideoOutputD3D::ProcessFrame(VideoFrame *frame, OSD *osd,
+                                  FilterChain *filterList,
+                                  NuppelVideoPlayer *pipPlayer)
+{
+    QMutexLocker locker(&m_lock);
+    if (IsErrored())
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR +
+                "ProcessFrame() called while IsErrored is true.");
+        return;
+    }
+
+    if (!frame)
+    {
+        frame = vbuffers.GetScratchFrame();
+        CopyFrame(vbuffers.GetScratchFrame(), &m_pauseFrame);
+    }
+
+    if (m_deinterlacing && m_deintFilter != NULL)
+        m_deintFilter->ProcessFrame(frame);
+
+    if (filterList)
+        filterList->ProcessFrame(frame);
+
+    ShowPip(frame, pipPlayer);
+    DisplayOSD(frame, osd);
+}
+
+float VideoOutputD3D::GetDisplayAspect(void) const
+{
+    VERBOSE(VB_PLAYBACK, LOC + "GetDisplayAspect");
+
+    float width  = display_visible_rect.width();
+    float height = display_visible_rect.height();
+
+    if (height <= 0.0001f)
+        return 16.0f / 9.0f;
+
+    return width / height;
+}
+
+QStringList VideoOutputD3D::GetAllowedRenderers(
+    MythCodecID myth_codec_id, const QSize &video_dim)
+{
+    QStringList list;
+    list += "direct3d";
+    return list;
+}

libs/libmythtv/osdtypes.cpp

@@ -1299 +1299 @@
     m_dontround = false;
     m_cacheitem = NULL;
 
-    LoadImage(filename, wmult, hmult, scalew, scaleh);
+    Load(filename, wmult, hmult, scalew, scaleh);
 }
 
 OSDTypeImage::OSDTypeImage(const OSDTypeImage &other)
@@ -1417 +1417 @@
         QPoint((int)round(m_unbiasedpos.x() * wmult),
                (int)round(m_unbiasedpos.y() * hmult));
 
-    LoadImage(m_filename, wmult, hmult, m_scalew, m_scaleh);
+    Load(m_filename, wmult, hmult, m_scalew, m_scaleh);
 }
 
-void OSDTypeImage::LoadImage(const QString &filename, float wmult, float hmult,
-                             int scalew, int scaleh, bool usecache)
+void OSDTypeImage::Load(const QString &filename, float wmult, float hmult,
+                        int scalew, int scaleh, bool usecache)
 {
     QString ckey;
 
@@ -1535 +1535 @@
     }
 }
 
-void OSDTypeImage::LoadFromQImage(const QImage &img)
+void OSDTypeImage::Load(const QImage &img)
 {
     // this method is not cached
 
@@ -1835 +1835 @@
     m_scaleh = scaleh;
     m_cacheitem = NULL;
 
-    LoadImage(m_redname, wmult, hmult, scalew, scaleh, false);
+    Load(m_redname, wmult, hmult, scalew, scaleh, false);
     if (m_isvalid)
     {
         m_risvalid = m_isvalid;
@@ -1850 +1850 @@
         m_alpha = m_yuv = NULL;
     }
 
-    LoadImage(m_bluename, wmult, hmult, scalew, scaleh, false);
+    Load(m_bluename, wmult, hmult, scalew, scaleh, false);
 }
 
 OSDTypeEditSlider::~OSDTypeEditSlider()
@@ -1871 +1871 @@
 
     m_displaypos = m_displayrect.topLeft();
 
-    LoadImage(m_redname, wmult, hmult, m_scalew, m_scaleh, false);
+    Load(m_redname, wmult, hmult, m_scalew, m_scaleh, false);
     if (m_isvalid)
     {
         m_risvalid = m_isvalid;
@@ -1886 +1886 @@
         m_alpha = m_yuv = NULL;
     }
 
-    LoadImage(m_bluename, wmult, hmult, m_scalew, m_scaleh, false);
+    Load(m_bluename, wmult, hmult, m_scalew, m_scaleh, false);
 }
 
 void OSDTypeEditSlider::ClearAll(void)

libs/libmythtv/jobqueue.cpp

@@ -8 +8 @@
 
 #include <sys/types.h>
 #include <sys/stat.h>
-#include <sys/wait.h>
-#include <sys/resource.h>
 
 #include <iostream>
 #include <cstdlib>
@@ -23 +21 @@
 #include "NuppelVideoPlayer.h"
 #include "mythdbcon.h"
 #include "previewgenerator.h"
+#include "compat.h"
 
 #define LOC     QString("JobQueue: ")
 #define LOC_ERR QString("JobQueue Error: ")

libs/libmythtv/DVDRingBuffer.cpp

@@ -7 +7 @@
 #include "iso639.h"
 
 #include "NuppelVideoPlayer.h"
+#include "compat.h"
 
 #define LOC QString("DVDRB: ")
 #define LOC_ERR QString("DVDRB, Error: ")

libs/libmythtv/libmythtv.pro

@@ -7 +7 @@
 target.path = $${LIBDIR}
 INSTALLS = target
 
-INCLUDEPATH += ../.. ..
+INCLUDEPATH += ../.. .. .
 INCLUDEPATH += ../libmyth ../libavcodec ../libavutil ../libmythmpeg2
 INCLUDEPATH += ./dvbdev ./mpeg ./iptv
 INCLUDEPATH += ../libmythlivemedia/BasicUsageEnvironment/include
@@ -43 +43 @@
 TARGETDEPS += ../libmythmpeg2/libmythmpeg2-$${MYTH_LIB_EXT}
 TARGETDEPS += ../libmythdvdnav/libmythdvdnav-$${MYTH_LIB_EXT}
 TARGETDEPS += ../libmythfreemheg/libmythfreemheg-$${MYTH_SHLIB_EXT}
-TARGETDEPS += ../libmythlivemedia/libmythlivemedia-$${MYTH_SHLIB_EXT}
+using_live: TARGETDEPS += ../libmythlivemedia/libmythlivemedia-$${MYTH_SHLIB_EXT}
 
 
 DEFINES += _LARGEFILE_SOURCE
@@ -114 +114 @@
 
 # Headers needed by frontend & backend
 HEADERS += filter.h                 format.h
-HEADERS += frame.h
+HEADERS += frame.h                  compat.h
 
 # LZO / RTjpegN, used by NuppelDecoder & NuppelVideoRecorder
 HEADERS += lzoconf.h
@@ -497 +497 @@
     QMAKE_CXXFLAGS += -fvisibility=hidden
 }
 
+mingw {
+    DEFINES -= USING_OPENGL_VSYNC
+    DEFINES += USING_D3D USING_MINGW
+
+    HEADERS -= util-opengl.h   openglcontext.h
+    HEADERS += videoout_d3d.h
+    SOURCES -= util-opengl.cpp openglcontext.cpp
+    SOURCES += videoout_d3d.cpp
+
+    LIBS += -lpthread
+    LIBS += -L../libmythfreemheg -lmythfreemheg-$${LIBVERSION}
+    LIBS += -L. -lmythui-bootstrap
+
+    target.path = $${PREFIX}/bin
+    implib.target = libmythui-bootstrap.a
+    implib.commands = test -e libmythui-bootstrap.a || dlltool --input-def ../libmythui/libmythui.def --dllname libmythui-$${LIBVERSION}.dll --output-lib libmythui-bootstrap.a -k
+    QMAKE_EXTRA_WIN_TARGETS += implib
+    POST_TARGETDEPS += libmythui-bootstrap.a
+}
+
 # install headers required by mytharchive
 inc.path = $${PREFIX}/include/mythtv/libmythtv/
 inc.files = programinfo.h remoteutil.h recordingtypes.h

libs/libmythtv/osdtypeteletext.h

@@ -21 +21 @@
 class OSDTypeTeletext;
 class TV;
 
-class TTColor
+typedef enum
 {
-  public:
-    static const uint BLACK       = 0;
-    static const uint RED         = 1;
-    static const uint GREEN       = 2;
-    static const uint YELLOW      = 3;
-    static const uint BLUE        = 4;
-    static const uint MAGENTA     = 5;
-    static const uint CYAN        = 6;
-    static const uint WHITE       = 7;
-    static const uint TRANSPARENT = 8;
-};
+    kTTColorBlack       = 0,
+    kTTColorRed         = 1,
+    kTTColorGreen       = 2,
+    kTTColorYellow      = 3,
+    kTTColorBlue        = 4,
+    kTTColorMagenta     = 5,
+    kTTColorCyan        = 6,
+    kTTColorWhite       = 7,
+    kTTColorTransparent = 8,
+} TTColor;
 
 class TTKey
 {

libs/libmythtv/ThreadedFileWriter.cpp

@@ -13 +13 @@
 // MythTV headers
 #include "ThreadedFileWriter.h"
 #include "mythcontext.h"
+#include "compat.h"
 
 #if defined(_POSIX_SYNCHRONIZED_IO) && _POSIX_SYNCHRONIZED_IO > 0
 #define HAVE_FDATASYNC

libs/libmythtv/osdtypes.h

@@ -310 +310 @@
     void SetName(const QString &name);
     void Reinit(float wmult, float hmult);
 
-    void LoadImage(const QString &filename, float wmult, float hmult, 
-                   int scalew = -1, int scaleh = -1, bool usecache = true);
-    void LoadFromQImage(const QImage &img);
+    void Load(const QString &filename, float wmult, float hmult, 
+              int scalew = -1, int scaleh = -1, bool usecache = true);
+    void Load(const QImage &img);
 
     void SetStaticSize(int scalew, int scaleh) { m_scalew = scalew;
                                                  m_scaleh = scaleh; }

libs/libmythtv/dsmcccache.h

@@ -106 +106 @@
     void SetGateway(const DSMCCCacheReference &ref);
 
     // Return the contents.
-    int GetObject(QStringList &objectPath, QByteArray &result);
+    int GetDSMObject(QStringList &objectPath, QByteArray &result);
 
   protected:
     // Find File, Directory or Gateway by reference.

libs/libmythtv/guidegrid.cpp

@@ -1167 +1167 @@
                 else if (type)
                     iconsize = type->GetSize();
                 if (!chinfo->iconload)
-                    chinfo->LoadIcon(iconsize);
+                    chinfo->LoadChannelIcon(iconsize);
                 if (chinfo->iconload)
                 {
                     if (itype)
@@ -1195 +1195 @@
                 else if (type)
                     iconsize = type->GetSize();
                 if (!chinfo->iconload)
-                    chinfo->LoadIcon(iconsize);
+                    chinfo->LoadChannelIcon(iconsize);
                 if (chinfo->iconload)
                     type->SetIcon(y, chinfo->icon);
                 else
@@ -1316 +1316 @@
             int iconsize = 0;
             iconsize = itype->GetSize().width();
             if (!chinfo->iconload)
-                chinfo->LoadIcon(iconsize);
+                chinfo->LoadChannelIcon(iconsize);
             if (chinfo->iconload)
                 itype->SetImage(chinfo->icon);
             else

libs/libmythtv/siscan.cpp

@@ -30 +30 @@
 #include "dvbchannel.h"
 #include "hdhrchannel.h"
 #include "channel.h"
+#include "compat.h"
 
 QString SIScan::loc(const SIScan *siscan)
 {

libs/libmythtv/fifowriter.cpp

@@ -12 +12 @@
 
 #include "fifowriter.h"
 #include "mythcontext.h"
+#include "compat.h"
 
 #include "config.h"
 #ifdef CONFIG_DARWIN

libs/libmythtv/videoout_d3d.h

@@ +1 @@
+// -*- Mode: c++ -*-
+
+#ifndef VIDEOOUT_D3D_H_
+#define VIDEOOUT_D3D_H_
+
+/* ACK! <windows.h> and <d3d3.h> should only be in cpp's compiled in
+ * windows only. Some of the variables in VideoOutputDX need to be
+ * moved to a private class before removing these includes though.
+ */
+#include <windows.h> // HACK HACK HACK
+#include <d3d9.h>    // HACK HACK HACK
+
+// MythTV headers
+#include "videooutbase.h"
+
+class VideoOutputD3D : public VideoOutput
+{
+  public:
+    VideoOutputD3D();
+   ~VideoOutputD3D();
+
+    bool Init(int width, int height, float aspect, WId winid,
+              int winx, int winy, int winw, int winh, WId embedid = 0);
+
+    bool InitD3D();
+    void UnInitD3D();
+    void PrepareFrame(VideoFrame *buffer, FrameScanType);
+    void ProcessFrame(VideoFrame *frame, OSD *osd,
+                      FilterChain *filterList,
+                      NuppelVideoPlayer *pipPlayer);
+    void Show(FrameScanType );
+
+    bool InputChanged(const QSize &input_size,
+                      float        aspect,
+                      MythCodecID  av_codec_id,
+                      void        *codec_private);
+    int GetRefreshRate(void);
+    void UpdatePauseFrame(void);
+    void DrawUnusedRects(bool) {};
+    void Zoom(ZoomDirection direction);
+
+    float GetDisplayAspect(void) const;
+
+    static QStringList GetAllowedRenderers(MythCodecID myth_codec_id,
+                                           const QSize &video_dim);
+
+  private:
+    void Exit(void);
+
+  private:
+    int                     m_InputCX;
+    int                     m_InputCY;
+    RECT                    m_rcDest;
+
+    VideoFrame              m_pauseFrame;
+    QMutex                  m_lock;
+
+    int                     m_RefreshRate;
+    HWND                    m_hWnd;
+    D3DFORMAT               m_ddFormat;
+    IDirect3D9             *m_pD3D;
+    IDirect3DDevice9       *m_pd3dDevice;
+    IDirect3DSurface9      *m_pSurface;
+    IDirect3DTexture9      *m_pTexture;
+    IDirect3DVertexBuffer9 *m_pVertexBuffer;
+};
+
+#endif

libs/libmythtv/channelbase.cpp

@@ -7 +7 @@
 #include <unistd.h>
 #include <fcntl.h>
 #include <signal.h>
-#include <sys/ioctl.h>
+#include <sys/stat.h>
 #include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/wait.h>
 
 // C++ headers
 #include <iostream>
@@ -26 +24 @@
 #include "mythdbcon.h"
 #include "cardutil.h"
 #include "channelutil.h"
+#include "compat.h"
 
 #define LOC QString("ChannelBase(%1): ").arg(GetCardID())
 #define LOC_ERR QString("ChannelBase(%1) Error: ").arg(GetCardID())
@@ -225 +224 @@
 
 bool ChannelBase::ChangeExternalChannel(const QString &channum)
 {
+#ifdef USING_MINGW
+    VERBOSE(VB_IMPORTANT, LOC_WARN +
+            QString("ChangeExternalChannel is not implemented in MinGW."));
+    return false;
+#else
     InputMap::const_iterator it = inputs.find(currentInputID);
     QString changer = (*it)->externalChanger;
 
@@ -312 +316 @@
     }
 
     return true;
+#endif // !USING_MINGW
 }
 
 /** \fn ChannelBase::GetCardID(void) const

libs/libmythtv/cc708decoder.h

@@ -9 +9 @@
 #include <qstringlist.h>
 
 #include "format.h"
+#include "compat.h"
 
 #ifndef __CC_CALLBACKS_H__
 /** EIA-708-A closed caption packet */

libs/libmythtv/vbitext/vbi.c

@@ +1 @@
+// POSIX headers
+#include <unistd.h>
+#include <fcntl.h>
+
+#ifndef _WIN32
+#include <sys/ioctl.h>
+#endif
+
+// ANSI C headers
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
-#include <fcntl.h>
 #include <stdio.h>
-#include <sys/ioctl.h>
 #include <stdarg.h>
-//#include "os.h"
+
+// vbitext headers
 #include "vt.h"
 #include "vbi.h"
 #include "hamm.h"
-//#include "lang.h"
 
 #define FAC    (1<<16)         // factor for fix-point arithmetic
 

libs/libmythtv/vbitext/cc.cpp

@@ -20 +20 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <cstdio>
 #include <cstdlib>
 #include <cstdarg>
 #include <unistd.h>
@@ -28 +27 @@
 #include <cctype>
 #include <cerrno>
 #include <fcntl.h>
-#include <sys/ioctl.h>
 #include <sys/types.h>
 #ifdef HAVE_GETOPT_H
 # include <getopt.h>

libs/libmythtv/dsmcccache.cpp

@@ -271 +271 @@
 // Returns zero for success, -1 if we know the object does not
 // currently exist and +1 if the carousel has not so far loaded
 // the object or one of the parent files. 
-int DSMCCCache::GetObject(QStringList &objectPath, QByteArray &result)
+int DSMCCCache::GetDSMObject(QStringList &objectPath, QByteArray &result)
 {
     DSMCCCacheDir *dir = FindGateway(m_GatewayRef);
     if (dir == NULL)

libs/libmythtv/filtermanager.cpp

@@ -1 +1 @@
 // POSIX headers
+#ifndef USING_MINGW // dlfcn for mingw defined in compat.h
 #include <dlfcn.h> // needed for dlopen(), dlerror(), dlsym(), and dlclose()
+#else
+#include "compat.h"
+#endif
 
 // Qt headers
 #include <qdir.h>

libs/libmythtv/infostructs.h

@@ -5 +5 @@
 
 #include "mythexp.h"
 
+#ifdef USING_MINGW
+#undef LoadIcon
+#endif
+
 class QPixmap;
 
 class MPUBLIC ChannelInfo
@@ -13 +17 @@
     ChannelInfo() {}
    ~ChannelInfo() {}
 
-    void LoadIcon(int width, int height=0);
+    void LoadChannelIcon(int width, int height = 0);
     QString Text(QString format);
 
     QString callsign;

libs/libmythtv/previewgenerator.cpp

@@ -6 +6 @@
 #include <sys/stat.h>  // for stat
 #include <unistd.h>    // for stat
 #include <sys/time.h>
-#include <sys/resource.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
@@ -25 +24 @@
 #include "mythsocket.h"
 #include "remotefile.h"
 #include "storagegroup.h"
+#include "util.h"
 
 #define LOC QString("Preview: ")
 #define LOC_ERR QString("Preview Error: ")
@@ -606 +606 @@
         if (!invalid)
         {
             // Check size too, QFileInfo can not handle large files
-            struct stat status;
-            stat(filename.ascii(), &status);
-            // Using off_t requires a lot of 32/64 bit checking.
-            // So just get the size in blocks.
-            unsigned long long bsize = status.st_blksize;
-            unsigned long long nblk  = status.st_blocks;
-            unsigned long long approx_size = nblk * bsize;
-            invalid = (approx_size < 8*1024);
+            unsigned long long fsize =
+                myth_get_approximate_large_file_size(filename);
+            invalid = (fsize < 8*1024);
         }
         if (invalid)
         {

libs/libmythtv/DeviceReadBuffer.h

@@ -6 +6 @@
 
 #include <unistd.h>
 #include <pthread.h>
-#include <sys/poll.h>
 
 #include <qmutex.h>
 #include <qwaitcondition.h>

libs/libmythtv/infostructs.cpp

@@ -9 +9 @@
 #include "infostructs.h"
 #include "mythcontext.h"
 
-void ChannelInfo::LoadIcon(int width, int height)
+void ChannelInfo::LoadChannelIcon(int width, int height)
 {
     QImage tempimage(iconpath);
 

libs/libmythtv/signalmonitor.cpp

@@ -9 +9 @@
 // MythTV headers
 #include "mythcontext.h"
 #include "signalmonitor.h"
+#include "compat.h"
 
 extern "C" {
 #include "../libavcodec/avcodec.h"

libs/libmythtv/dsmcc.cpp

@@ -479 +479 @@
     // Can we actually have more than one carousel?
     for (; (car = it.current()) != NULL; ++it)
     {
-        int res = car->filecache.GetObject(objectPath, result);
+        int res = car->filecache.GetDSMObject(objectPath, result);
         if (res != -1)
             return res;
     }

libs/libmythtv/RingBuffer.cpp

@@ -31 +31 @@
 #include "livetvchain.h"
 #include "DVDRingBuffer.h"
 #include "util.h"
+#include "compat.h"
 
 #ifndef O_STREAMING
 #define O_STREAMING 0

libs/libmythtv/vsync.cpp

@@ -22 +22 @@
 #include <unistd.h>
 #include <fcntl.h>
 
-#include <sys/ioctl.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include "compat.h"
+
+#ifndef _WIN32
+#include <sys/ioctl.h>
 #include <sys/poll.h>
+#endif
 
 #include <mythcontext.h>
 #include "mythdialogs.h" // for OpenGL VSync
@@ -86 +90 @@
         m_forceskip = 0;
     }
     
+#ifndef _WIN32
     TESTVIDEOSYNC(nVidiaVideoSync);
     TESTVIDEOSYNC(DRMVideoSync);
     if (tryOpenGL)
         TESTVIDEOSYNC(OpenGLVideoSync);
+#endif // _WIN32
 #ifdef __linux__
     TESTVIDEOSYNC(RTCVideoSync);
-#endif
+#endif // __linux__
+
     TESTVIDEOSYNC(BusyWaitVideoSync);
 
     tryingVideoSync=false;
@@ -238 +245 @@
     struct drm_wait_vblank_reply reply;
 } drm_wait_vblank_t;
 
+#ifndef _WIN32
 #define DRM_IOCTL_BASE                  'd'
 #define DRM_IOWR(nr,type)               _IOWR(DRM_IOCTL_BASE,nr,type)
 
 #define DRM_IOCTL_WAIT_VBLANK           DRM_IOWR(0x3a, drm_wait_vblank_t)
+#endif
 
 static int drmWaitVBlank(int fd, drm_wait_vblank_t *vbl)
 {
@@ -363 +372 @@
 
 bool nVidiaVideoSync::dopoll() const
 {
+#ifdef _WIN32
+    return false;
+#else
     int ret;
     struct pollfd polldata;
     polldata.fd = m_nvidia_fd;
@@ -377 +389 @@
         return false;
     }
     return true;
+#endif
 }
 
 bool nVidiaVideoSync::TryInit(void)
@@ -711 +724 @@
 
 bool RTCVideoSync::TryInit(void)
 {
+#ifdef _WIN32
+    return false;
+#else
     m_rtcfd = open("/dev/rtc", O_RDONLY);
     if (m_rtcfd < 0)
     {
@@ -735 +751 @@
     }
     
     return true;
+#endif
 }
 
 void RTCVideoSync::WaitForFrame(int sync_delay)

libs/libmythtv/osdtypeteletext.cpp

@@ -684 +684 @@
 {
     QColor color;
 
-    switch (ttcolor & ~TTColor::TRANSPARENT)
+    switch (ttcolor & ~kTTColorTransparent)
     {
-        case TTColor::BLACK:   color = OSDTypeTeletext::kColorBlack;   break;
-        case TTColor::RED:     color = OSDTypeTeletext::kColorRed;     break;
-        case TTColor::GREEN:   color = OSDTypeTeletext::kColorGreen;   break;
-        case TTColor::YELLOW:  color = OSDTypeTeletext::kColorYellow;  break;
-        case TTColor::BLUE:    color = OSDTypeTeletext::kColorBlue;    break;
-        case TTColor::MAGENTA: color = OSDTypeTeletext::kColorMagenta; break;
-        case TTColor::CYAN:    color = OSDTypeTeletext::kColorCyan;    break;
-        case TTColor::WHITE:   color = OSDTypeTeletext::kColorWhite;   break;
+        case kTTColorBlack:   color = OSDTypeTeletext::kColorBlack;   break;
+        case kTTColorRed:     color = OSDTypeTeletext::kColorRed;     break;
+        case kTTColorGreen:   color = OSDTypeTeletext::kColorGreen;   break;
+        case kTTColorYellow:  color = OSDTypeTeletext::kColorYellow;  break;
+        case kTTColorBlue:    color = OSDTypeTeletext::kColorBlue;    break;
+        case kTTColorMagenta: color = OSDTypeTeletext::kColorMagenta; break;
+        case kTTColorCyan:    color = OSDTypeTeletext::kColorCyan;    break;
+        case kTTColorWhite:   color = OSDTypeTeletext::kColorWhite;   break;
     }
 
     return color;
@@ -702 +702 @@
 /** \fn OSDTypeTeletext::SetForegroundColor(int) const
  *  \brief Set the font color to the given color.
  *
- *   NOTE: TTColor::TRANSPARENT does not do anything!
+ *   NOTE: kTTColorTransparent does not do anything!
  *  \sa TTColor
  */
 void OSDTypeTeletext::SetForegroundColor(int ttcolor) const
@@ -732 +732 @@
     m_bgcolor_y = (uint8_t)(y);
     m_bgcolor_u = (uint8_t)(127 + u);
     m_bgcolor_v = (uint8_t)(127 + v);
-    m_bgcolor_a = (ttcolor & TTColor::TRANSPARENT) ? 0x00 : 0xff;
+    m_bgcolor_a = (ttcolor & kTTColorTransparent) ? 0x00 : 0xff;
 }
 
 /** \fn OSDTypeTeletext::DrawBackground(OSDSurface*,int,int) const
@@ -890 +890 @@
     char last_ch = ' ';
     char ch;
 
-    uint fgcolor = TTColor::WHITE;
-    uint bgcolor = TTColor::BLACK;
-    uint newfgcolor = TTColor::WHITE;
-    uint newbgcolor = TTColor::BLACK;
+    uint fgcolor = kTTColorWhite;
+    uint bgcolor = kTTColorBlack;
+    uint newfgcolor = kTTColorWhite;
+    uint newbgcolor = kTTColorBlack;
 
     if (m_curpage_issubtitle || m_transparent)
     {
-        bgcolor    = TTColor::TRANSPARENT;
-        newbgcolor = TTColor::TRANSPARENT;
+        bgcolor    = kTTColorTransparent;
+        newbgcolor = kTTColorTransparent;
     }
 
     SetForegroundColor(fgcolor);
@@ -925 +925 @@
     {
         if (startbox)
         {
-            bgcolor = TTColor::BLACK;
+            bgcolor = kTTColorBlack;
             startbox = false;
         }
 
         if (endbox)
         {
-            bgcolor = TTColor::TRANSPARENT;
+            bgcolor = kTTColorTransparent;
             endbox = false;
         }
 
@@ -982 +982 @@
                 seperation = true;
                 goto ctrl;
             case 0x1c: // black background
-                bgcolor = TTColor::BLACK;
+                bgcolor = kTTColorBlack;
                 goto ctrl;
             case 0x1d: // new background
                 bgcolor = fgcolor;
@@ -1034 +1034 @@
         if ((row != 0) || (x > 7))
         {
             if (m_transparent)
-                SetBackgroundColor(TTColor::TRANSPARENT);
+                SetBackgroundColor(kTTColorTransparent);
 
             DrawBackground(surface, x, row);
             if (doubleheight && row < (uint)kTeletextRows)
@@ -1128 +1128 @@
 
 void OSDTypeTeletext::DrawStatus(OSDSurface *surface) const
 {
-    SetForegroundColor(TTColor::WHITE);
-    SetBackgroundColor(TTColor::BLACK);
+    SetForegroundColor(kTTColorWhite);
+    SetBackgroundColor(kTTColorBlack);
 
     if (!m_transparent)
         for (int i = 0; i < 40; ++i)
@@ -1144 +1144 @@
 
     if (!ttpage)
     {
-        SetBackgroundColor(TTColor::BLACK);
-        SetForegroundColor(TTColor::WHITE);
+        SetBackgroundColor(kTTColorBlack);
+        SetForegroundColor(kTTColorWhite);
 
         if (!m_transparent)
             for (int i = 7; i < 40; i++)
@@ -1208 +1208 @@
         str = "  <" + str.mid(startPos * 3, 27) + " > ";
     }
 
-    SetForegroundColor(TTColor::WHITE);
+    SetForegroundColor(kTTColorWhite);
     for (int x = 0; x < 11; x++)
     {
         if (m_transparent)
-            SetBackgroundColor(TTColor::TRANSPARENT);
+            SetBackgroundColor(kTTColorTransparent);
         else
-            SetBackgroundColor(TTColor::BLACK);
+            SetBackgroundColor(kTTColorBlack);
 
         DrawBackground(surface, x * 3 + 7, 0);
 
         if (str[x * 3] == '*')
         {
             str[x * 3] = ' ';
-            SetBackgroundColor(TTColor::RED);
+            SetBackgroundColor(kTTColorRed);
         }
 
         DrawBackground(surface, x * 3 + 8, 0);

libs/libmythtv/tv_play.cpp

@@ -41 +41 @@
 #include "datadirect.h"
 #include "sourceutil.h"
 #include "util-osx-cocoa.h"
+#include "compat.h"
 
 #ifndef HAVE_ROUND
 #define round(x) ((int) ((x) + 0.5))

libs/libmythtv/videooutbase.cpp

@@ -25 +25 @@
 #include "videoout_dx.h"
 #endif
 
+#ifdef USING_D3D
+#include "videoout_d3d.h"
+#endif
+
 #ifdef Q_OS_MACX
 #include "videoout_quartz.h"
 #endif
@@ -70 +74 @@
     renderers += VideoOutputDirectfb::GetAllowedRenderers(codec_id, video_dim);
 #endif // USING_DIRECTFB
 
+#ifdef USING_D3D
+    renderers += VideoOutputD3D::GetAllowedRenderers(codec_id, video_dim);
+#endif
+
 #ifdef USING_DIRECTX
-    renderers += VideoOutputDX::GetAllowedRenderers(coded_id, video_dim);
+    renderers += VideoOutputDX::GetAllowedRenderers(codec_id, video_dim);
 #endif // USING_DIRECTX
 
 #ifdef USING_XV
@@ -129 +137 @@
             vo = new VideoOutputDirectfb();
 #endif // USING_DIRECTFB
 
+#ifdef USING_D3D
+        if (renderer == "direct3d")
+            vo = new VideoOutputD3D();
+#endif // USING_D3D
+
 #ifdef USING_DIRECTX
         if (renderer == "directx")
             vo = new VideoOutputDX();

libs/libmythtv/vsync.h

@@ -197 +197 @@
  *  \sa http://www.ac3.edu.au/SGI_Developer/books/OpenGLonSGI/sgi_html/ch10.html#id37188
  *  \sa http://www.inb.mu-luebeck.de/~boehme/xvideo_sync.html
  */
+#ifndef USING_MINGW
 class OpenGLVideoSync : public VideoSync
 {
   public:
@@ -217 +218 @@
   private:
     QMutex      m_lock;
 };
+#endif // USING_MINGW
 
 #ifdef __linux__
 /** \brief Video synchronization class employing /dev/rtc

libs/libmythtv/cardutil.cpp

@@ -1 +1 @@
 // Standard UNIX C headers
 #include <fcntl.h>
-#include <sys/ioctl.h>
 #include <unistd.h>
 
+#if defined(USING_V4L) || defined(USING_DVB)
+#include <sys/ioctl.h>
+#endif
+
 // MythTV headers
 #include "cardutil.h"
 #include "videosource.h"

libs/libmythtv/fifowriter.h

@@ -1 +1 @@
 #ifndef FIFOWRITER
 #define FIFOWRITER
 
-#include <vector>
+// POSIX headers
+#include <pthread.h>
+
+// Qt headers
 #include <qstring.h>
 #include <qmutex.h>
 #include <qptrqueue.h>
 
+// MythTV headers
 #include "mythexp.h"
 
 using namespace std;

libs/libmythtv/videosource.cpp

@@ -3 +3 @@
 // Standard UNIX C headers
 #include <unistd.h>
 #include <fcntl.h>
-#include <sys/ioctl.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 

libs/libmythtv/frequencytables.cpp

@@ -1 +1 @@
 #include "frequencies.h"
 #include "frequencytables.h"
 #include "channelutil.h"
+#include "compat.h"
 
 freq_table_map_t frequencies;
 

libs/libmythtv/udpnotify.cpp

@@ -25 +25 @@
 match they will be ignored.
 */
 
-
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <unistd.h>
 #include <pthread.h>
 #include <sys/types.h>
-#include <sys/socket.h>
 
 #include <qapplication.h>
 #include <qsocketdevice.h>
 #include <qsocketnotifier.h>
 #include <qhostaddress.h>
 
-#include <iostream>
-using namespace std;
-
 #include "udpnotify.h"
 #include "mythcontext.h"
 #include "osd.h"
 #include "tv_play.h"
+#include "compat.h"
 
 UDPNotifyOSDSet::UDPNotifyOSDSet(const QString &name)
 {

libs/libmythtv/DeviceReadBuffer.cpp

@@ -4 +4 @@
 #include "DeviceReadBuffer.h"
 #include "mythcontext.h"
 #include "tspacket.h"
+#include "compat.h"
 
+#ifndef USING_MINGW
+#include <sys/poll.h>
+#endif
+
 /// Set this to 1 to report on statistics
 #define REPORT_RING_STATS 0
 
@@ -282 +287 @@
 
 bool DeviceReadBuffer::Poll(void) const
 {
+#ifdef USING_MINGW
+#warning mingw DeviceReadBuffer::Poll
+    VERBOSE(VB_IMPORTANT, LOC_ERR + 
+            "mingw DeviceReadBuffer::Poll is not implemented");
+    return false;
+#else
     bool retval = true;
     while (true)
     {
@@ -310 +321 @@
         usleep(2500);
     }
     return retval;
+#endif //!USING_MINGW
 }
 
 bool DeviceReadBuffer::CheckForErrors(ssize_t len, uint &errcnt)
 {
+#ifdef USING_MINGW
+#warning mingw DeviceReadBuffer::CheckForErrors
+    VERBOSE(VB_IMPORTANT, LOC_ERR +
+            "mingw DeviceReadBuffer::CheckForErrors is not implemented");
+    return false;
+#else
     if (len < 0)
     {
         if (EINTR == errno)
@@ -360 +378 @@
         return false;
     }
     return true;
+#endif
 }
 
 /** \fn DeviceReadBuffer::Read(unsigned char*, const uint)

libs/libmythtv/filtermanager.h

@@ -9 +9 @@
 #include <qdict.h>
 #include <qptrlist.h>
 #include <qstring.h>
-#include <cstdlib>
-#include <dlfcn.h>
 
 using namespace std;
 

libs/libmythtv/eitscanner.cpp

@@ -2 +2 @@
 
 // POSIX headers
 #include <sys/time.h>
-#include <sys/resource.h>
+#include "compat.h"
 
 #include <cstdlib>
 

libs/libmythtv/osdsurface.cpp

@@ -1 +1 @@
 #include "osdsurface.h"
 #include "dithertable.h"
 #include "mythcontext.h"
+#include "compat.h"
 
 #include <algorithm>
 using namespace std;

libs/libmythtv/dtvsignalmonitor.cpp

@@ -7 +7 @@
 #include "mpegtables.h"
 #include "atsctables.h"
 #include "dvbtables.h"
+#include "compat.h"
 
 #undef DBG_SM
 #define DBG_SM(FUNC, MSG) VERBOSE(VB_CHANNEL, \

libs/libmythtv/osd.cpp

@@ -26 +26 @@
 #include "textsubtitleparser.h"
 #include "libmyth/oldsettings.h"
 #include "udpnotify.h"
+#include "compat.h"
 
 #include "osdtypeteletext.h"
 #include "osdlistbtntype.h"
@@ -1244 +1245 @@
         filename = themepath + filename;
 
     image->SetStaticSize(scale.x(), scale.y());
-    image->LoadImage(filename, wmult, hmult, scale.x(), scale.y());
+    image->Load(filename, wmult, hmult, scale.x(), scale.y());
 
     container->AddType(image);
 }
@@ -1646 +1647 @@
         if (cs)
         {
             if ((infoMap.contains("iconpath")) && (infoMap["iconpath"] != ""))
-                cs->LoadImage(infoMap["iconpath"], wmult, hmult, 30, 30);
+                cs->Load(infoMap["iconpath"], wmult, hmult, 30, 30);
             else
-                cs->LoadImage(" ", wmult, hmult, 30, 30);
+                cs->Load(" ", wmult, hmult, 30, 30);
         }
 
         m_setsvisible = true;
@@ -1669 +1670 @@
         if (cs)
         {
             if ((infoMap.contains("iconpath")) && (infoMap["iconpath"] != ""))
-                cs->LoadImage(infoMap["iconpath"], wmult, hmult, 30, 30);
+                cs->Load(infoMap["iconpath"], wmult, hmult, 30, 30);
             else
-                cs->LoadImage(" ", wmult, hmult, 30, 30);
+                cs->Load(" ", wmult, hmult, 30, 30);
         }
 
         container->DisplayFor(length * 1000000);
@@ -1725 +1726 @@
             type->SetText(callsign.left(5));
         OSDTypeImage *cs = (OSDTypeImage *)container->GetType("channelicon");
         if (cs)
-            cs->LoadImage(iconpath, wmult, hmult, 30, 30);
+            cs->Load(iconpath, wmult, hmult, 30, 30);
 
         container->DisplayFor(length * 1000000);
         m_setsvisible = true;

libs/libmythtv/diseqc.cpp

@@ -17 +17 @@
 #include "mythdbcon.h"
 #include "diseqc.h"
 #include "dtvmultiplex.h"
+#include "compat.h"
 
 #ifdef USING_DVB
 #   include "dvbtypes.h"

libs/libmythtv/mhi.cpp

@@ -424 +424 @@
     {
         OSDTypeImage* image = new OSDTypeImage();
         image->SetPosition(QPoint(data->m_x, data->m_y), 1.0, 1.0);
-        image->LoadFromQImage(data->m_image);
+        image->Load(data->m_image);
         osdSet->AddType(image);
     }
 }

libs/libmythtv/videodisplayprofile.cpp

@@ -1282 +1282 @@
     safe_custom += "xshm";
     safe_custom += "directfb";
     safe_custom += "directx";
+    safe_custom += "direct3d";
     safe_custom += "quartz-blit";
     safe_custom += "xv-blit";
     safe_custom += "opengl";
@@ -1344 +1345 @@
         safe_renderer[*it2] += "xshm";
         safe_renderer[*it2] += "directfb";
         safe_renderer[*it2] += "directx";
+        safe_renderer[*it2] += "direct3d";
         safe_renderer[*it2] += "quartz-blit";
         safe_renderer[*it2] += "xv-blit";
         safe_renderer[*it2] += "opengl";
@@ -1367 +1369 @@
     safe_renderer_priority["xvmc-opengl"]  = 100;
     safe_renderer_priority["directfb"]     =  60;
     safe_renderer_priority["directx"]      =  50;
+    safe_renderer_priority["direct3d"]     =  55;
     safe_renderer_priority["quartz-blit"]  =  70;
     safe_renderer_priority["quartz-accel"] =  80;
     safe_renderer_priority["ivtv"]         =  40;

libs/libmythtv/videobuffers.cpp

@@ -8 +8 @@
 #include "../libavcodec/avcodec.h"
 }
 #include "fourcc.h"
+#include "compat.h"
 
 #ifdef USING_XVMC
 #include "videoout_xv.h" // for xvmc stuff

libs/libmythtv/videoout_dx.cpp

@@ -10 +10 @@
 #include "fourcc.h"
 
 #include "mmsystem.h"
-#ifdef CONFIG_CYGWIN
 #include "tv.h"
-#endif
 
+#undef UNICODE
+
 extern "C" {
 #include "../libavcodec/avcodec.h"
 }
@@ -201 +201 @@
 
     MoveResize();
 
-#ifndef CONFIG_CYGWIN    
-    if (!CreateVideoBuffers())
-        return false;
-#endif
-
     pauseFrame.height = vbuffers.GetScratchFrame()->height;
     pauseFrame.width  = vbuffers.GetScratchFrame()->width;
     pauseFrame.bpp    = vbuffers.GetScratchFrame()->bpp;
@@ -1174 +1169 @@
 
             outputpictures = 1;
 
-            VERBOSE(VB_IMPORTANT, "created plain surface of chroma: " << PRINT_FOURCC(chroma) );
+            VERBOSE(VB_IMPORTANT, "created plain surface");
         }
     }
 
@@ -1360 +1355 @@
         int diff_x  = display_visible_rect.left();
         diff_x     -= display_video_rect.left();
         int diff_w  = display_video_rect.width();
-        diff_x     -= display_visible_rect.width()
+        diff_x     -= display_visible_rect.width();
 
         rect_src.left  += (XJ_width * diff_x) / display_video_rect.width();
         rect_src.right -= ((XJ_width * (diff_w - diff_x)) /
@@ -1383 +1378 @@
         int diff_h  = display_video_rect.height();
         diff_h     -= display_visible_rect.height();
 
-        rect_src.top += ((video_rect.width() * diff_x) /
+        rect_src.top += ((video_rect.width() * diff_y) /
                          display_video_rect.height());
 
         rect_src.bottom -= (video_rect.height() * (diff_h - diff_y) /

libs/libavcodec/libavcodec.pro

@@ -7 +7 @@
 target.path = $${LIBDIR}
 INSTALLS = target
 
-INCLUDEPATH = ../ ../../ ../libavutil ../libswscale
+INCLUDEPATH = ./ ../ ../../ ../libavutil ../libswscale
 
 # remove MMX define since it clashes with a libmp3lame enum
 DEFINES -= MMX
@@ -28 +28 @@
 }
 
 cygwin:LIBS += -lz
+mingw:target.path = $${PREFIX}/bin
 
 !profile:QMAKE_CFLAGS_DEBUG += -O
 

libs/libavcodec/rtjpeg.h

@@ -23 +23 @@
 #define FFMPEG_RTJPEG_H
 
 #include <stdint.h>
-#include <dsputil.h>
+#include "dsputil.h"
 
 typedef struct {
     int w, h;

libs/libavutil/libavutil.pro

@@ -52 +52 @@
     QMAKE_LFLAGS_SHLIB += -single_module
     QMAKE_LFLAGS_SHLIB += -seg1addr 0xC2000000
 }
+
+mingw:  target.path = $${PREFIX}/bin

libs/libavformat/utils.c

@@ -26 +26 @@
 #include <sys/time.h>
 #include <time.h>
 
+#ifdef _WIN32
+#define gmtime_r(X, Y)    (memcpy(Y, gmtime(X),    sizeof(struct tm)), Y)
+#define localtime_r(X, Y) (memcpy(Y, localtime(X), sizeof(struct tm)), Y)
+#endif
+
 #undef NDEBUG
 #include <assert.h>
 

libs/libavformat/libavformat.pro

@@ -15 +15 @@
 
 cygwin :LIBS += -lz
 
+mingw:  target.path = $${PREFIX}/bin
+
 QMAKE_CLEAN += $(TARGET) $(TARGETA) $(TARGETD) $(TARGET0) $(TARGET1) $(TARGET2)
 
 # Input
@@ -197 +199 @@
 #    SOURCES            += audio-darwin.c
 }
 
+mingw:SOURCES -= audio.c

libs/libmythui/mythpainter_qt.cpp

@@ -4 +4 @@
 #include "mythpainter_qt.h"
 #include "mythfontproperties.h"
 #include "mythmainwindow.h"
+#include "compat.h"
 
 class MythQtImage : public MythImage
 {

libs/libmythui/mythmainwindow.cpp

@@ -611 +611 @@
 /* FIXME compatability only */
 void MythMainWindow::attach(QWidget *child)
 {
+#ifdef USING_MINGW
+#warning TODO FIXME MythMainWindow::attach() not implemented on MS Windows!
+    // if windows are created on different threads,
+    // or if setFocus() is called from a thread other than the main UI thread,
+    // setFocus() hangs the thread that called it
+    // currently, it's impossible to switch to program guide from livetv
+    VERBOSE(VB_IMPORTANT,
+            QString("MythMainWindow::attach old: %1, new: %2, thread: %3")
+            .arg(currentWidget() ? currentWidget()->name() : "none")
+            .arg(child->name())
+            .arg(::GetCurrentThreadId()));
+#endif
     if (currentWidget())
         currentWidget()->setEnabled(false);
 
@@ -1506 +1518 @@
     float floatSize = pointSize;
     float desired = 100.0;
 
+#ifdef USING_MINGW
+#warning TODO FIXME DPI needs to be calculated on MS Windows systems..
+    int logicalDpiY = 100;
+#else
+    int logicalDpiY = pdm.logicalDpiY();
+#endif
+
     // adjust for screen resolution relative to 100 dpi
-    floatSize = floatSize * desired / pdm.logicalDpiY();
+    floatSize = floatSize * desired / logicalDpiY;
     // adjust for myth GUI size relative to 800x600
     floatSize = floatSize * d->hmult;
     // adjust by the configurable fine tuning percentage
@@ -1518 +1537 @@
     return pointSize;
 }
 
-QFont MythMainWindow::CreateFont(const QString &face, int pointSize, 
-                                 int weight, bool italic)
+QFont MythMainWindow::CreateQFont(const QString &face, int pointSize, 
+                                  int weight, bool italic)
 {
     QFont font = QFont(face);
     if (!font.exactMatch())

libs/libmythui/mythuitype.cpp

@@ -471 +471 @@
         (*it)->AddFocusableChildrenToList(focusList);
 }
 
-QFont MythUIType::CreateFont(const QString &face, int pointSize,
-                             int weight, bool italic)
+QFont MythUIType::CreateQFont(const QString &face, int pointSize,
+                              int weight, bool italic)
 {
-    return GetMythMainWindow()->CreateFont(face, pointSize, weight, italic);
+    return GetMythMainWindow()->CreateQFont(face, pointSize, weight, italic);
 }
 
 QRect MythUIType::NormRect(const QRect &rect)

libs/libmythui/mythuitext.cpp

@@ -6 +6 @@
 #include "mythfontproperties.h"
 
 #include "mythcontext.h"
+#include "compat.h"
 
 MythUIText::MythUIText(MythUIType *parent, const char *name)
           : MythUIType(parent, name)

libs/libmythui/myththemedmenu.cpp

@@ -687 +687 @@
         }
     }
 
-    QFont font = GetMythMainWindow()->CreateFont(fontname, fontsize, 
-                                                 weight, italic);
+    QFont font = GetMythMainWindow()->CreateQFont(
+        fontname, fontsize, weight, italic);
 
     attributes.font.SetFace(font);
 

libs/libmythui/mythpainter.h

@@ -7 +7 @@
 
 //  #include "mythfontproperties.h"
 
+#include "compat.h"
 
 class MythFontProperties;
 class MythImage;

libs/libmythui/mythpainter_qt.h

@@ -3 +3 @@
 
 #include "mythpainter.h"
 #include "mythimage.h"
+#include "compat.h"
 
 class QPainter;
 class QPixmap;

libs/libmythui/mythmainwindow.h

@@ -105 +105 @@
     QRect GetUIScreenRect();
 
     int NormalizeFontSize(int pointSize);
-    QFont CreateFont(const QString &face, int pointSize = 12,
-                     int weight = QFont::Normal, bool italic = FALSE);
+    QFont CreateQFont(const QString &face, int pointSize = 12,
+                      int weight = QFont::Normal, bool italic = FALSE);
     QRect NormRect(const QRect &rect);
     QPoint NormPoint(const QPoint &point);
     QSize NormSize(const QSize &size);

libs/libmythui/libmythui.pro

@@ -72 +72 @@
 }
 
 cygwin:DEFINES += _WIN32
+
+mingw {
+    DEFINES += USING_MINGW
+    target.path = $${PREFIX}/bin
+    using_opengl {
+        LIBS += -lopengl32
+        DEFINES += USE_OPENGL_PAINTER
+        SOURCES += mythpainter_ogl.cpp
+        HEADERS += mythpainter_ogl.h
+        inc.files += mythpainter_ogl.h
+    }
+}

libs/libmythui/mythuitype.h

@@ -109 +109 @@
 
     int CalcAlpha(int alphamod);
 
-    QFont CreateFont(const QString &face, int pointSize = 12,
-                     int weight = QFont::Normal, bool italic = FALSE);
+    QFont CreateQFont(const QString &face, int pointSize = 12,
+                      int weight = QFont::Normal, bool italic = FALSE);
     QRect NormRect(const QRect &rect);
     QPoint NormPoint(const QPoint &point);
     int NormX(const int width);

libs/libmyth/lcddevice.cpp

@@ -7 +7 @@
     (c) 2002, 2003 Thor Sigvaldason, Dan Morphis and Isaac Richards
 */
 
-#include "lcddevice.h"
-#include "mythcontext.h"
-#include "mythdialogs.h"
+// ANSI C headers
+#include <cstdlib>
+#include <cmath>
 
-#include "libmythui/mythmainwindow.h"
-
+// POSIX headers
 #include <unistd.h>
-#ifndef USING_MINGW
-#include <stdlib.h>
-#include <sys/wait.h>   // For WIFEXITED on Mac OS X
-#else
-#include "compat.h"
-#endif
-#include <cmath>
 
+// Qt headers
 #include <qapplication.h>
 #include <qregexp.h>
 
+// MythTV headers
+#include "libmythui/mythmainwindow.h"
+#include "lcddevice.h"
+#include "mythcontext.h"
+#include "mythdialogs.h"
+#include "compat.h"
 
 /*
   LCD_DEVICE_DEBUG control how much debug info we get

libs/libmyth/util.cpp

@@ -9 +9 @@
 #include <fcntl.h>
 
 // System specific C headers
+#include "compat.h"
 #ifdef USING_MINGW
 # include <sys/types.h>
 # include <sys/stat.h>
 # include <sys/param.h>
-# include "compat.h"
 #else
 # include <sys/types.h>
 # include <sys/wait.h>
@@ -857 +857 @@
 QString createTempFile(QString name_template, bool dir)
 {
 #ifdef USING_MINGW
-#warning Implement createTempFile
-        return "";
+    char *tmp = new char[MAX_PATH+1];
+    QFileInfo fi(name_template);
+    ::GetTempFileNameA(fi.filePath(), fi.baseName(), 0, tmp);
+    return QString(tmp);
 #else
     const char *tmp = name_template.ascii();
     char *ctemplate = strdup(tmp);
@@ -898 +900 @@
 #endif // USING_X11
     return pixelAspect;
 }
+
+unsigned long long myth_get_approximate_large_file_size(const QString &fname)
+{
+    // .local8Bit() not thread-safe.. even with Qt4, make a deep copy first..
+    QString filename = QDeepCopy<QString>(fname);
+#ifdef USING_MINGW
+    struct _stati64 status;
+    _stati64(filename.local8Bit(), &status);
+    return status.st_size;
+#else
+    struct stat status;
+    stat(filename.local8Bit(), &status);
+    // Using off_t requires a lot of 32/64 bit checking.
+    // So just get the size in blocks.
+    unsigned long long bsize = status.st_blksize;
+    unsigned long long nblk  = status.st_blocks;
+    unsigned long long approx_size = nblk * bsize;
+    return approx_size;
+#endif
+}

libs/libmyth/compat.h

@@ -13 +13 @@
 #ifdef _WIN32
 #define close wsock_close
 #include <windows.h>
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#define setsockopt(a, b, c, d, e) setsockopt(a, b, c, (const char*)(d), e)
 #undef close
+#else
+#include <sys/resource.h> // for setpriority
+#include <sys/socket.h>
+#include <sys/wait.h>   // For WIFEXITED on Mac OS X
 #endif
 
 #ifdef _WIN32
@@ -22 +29 @@
 
 #ifdef _WIN32
 #undef DialogBox
+#undef DrawText
 #endif
 
 // Dealing with Microsoft min/max mess: 
@@ -54 +62 @@
 #endif
 
 #ifdef USING_MINGW
-#define gmtime_r(x, y) gmtime((x))
-#define localtime_r(x, y) localtime((x))
+#define gmtime_r(X, Y)    (memcpy(Y, gmtime(X),    sizeof(struct tm)), Y)
+#define localtime_r(X, Y) (memcpy(Y, localtime(X), sizeof(struct tm)), Y)
+#define lseek(X,Y,Z) lseek64(X,Y,Z)
+#define fsync(FD) 0
+#define signal(X,Y) 0
 //used in videodevice only - that code is not windows-compatible anyway
-#define minor(x) 0
+#define minor(X) 0
 #endif
 
 #if defined(__cplusplus) && defined(USING_MINGW)
@@ -69 +80 @@
 #endif // USING_MINGW
 
 #if defined(__cplusplus) && defined(USING_MINGW)
+#define setenv(x, y, z) ::SetEnvironmentVariableA(x, y)
+#define unsetenv(x) 0
+#endif
+
+#if defined(__cplusplus) && defined(USING_MINGW)
 #include <pthread.h>
 inline bool operator==(const pthread_t& pt, const int n)
 {

libs/libmyth/util.h

@@ -77 +77 @@
 MPUBLIC long long copy(QFile &dst, QFile &src, uint block_size = 0);
 MPUBLIC QString createTempFile(QString name_template = "/tmp/mythtv_XXXXXX",
                                bool dir = false);
+MPUBLIC unsigned long long myth_get_approximate_large_file_size(
+    const QString &fname);
 
 MPUBLIC double MythGetPixelAspectRatio(void);
 

libs/libmythfreemheg/libmythfreemheg.pro

@@ -24 +24 @@
 
 LIBS += $$EXTRA_LIBS
 
+mingw {
+    DEFINES += USING_MINGW
+    target.path = $${PREFIX}/bin
+}

libs/libmythupnp/upnptasknotify.cpp

@@ -8 +8 @@
 //                                                                            
 //////////////////////////////////////////////////////////////////////////////
 
-#include "upnp.h"
-#include "multicast.h"
-#include "broadcast.h"
+// ANSI C headers
+#include <cstdlib>
 
+// POSIX headers
 #include <unistd.h>
-#include <stdlib.h>
+#include <sys/time.h>
+
+// Qt headers
 #include <qstringlist.h>
 #include <quuid.h> 
 #include <qdom.h> 
 #include <qfile.h>
-#include <sys/time.h>
 
+// MythTV headers
+#include "upnp.h"
+#include "multicast.h"
+#include "broadcast.h"
+#include "compat.h"
 
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

libs/libmythupnp/httpserver.cpp

@@ -9 +9 @@
 //                                                                            
 //////////////////////////////////////////////////////////////////////////////
 
+// ANSI C headers
+#include <cmath>
+
+// POSIX headers
 #include <unistd.h>
+#include <sys/time.h>
+#ifndef USING_MINGW
+#include <sys/utsname.h> 
+#endif
 
+// Qt headers
 #include <qregexp.h>
 #include <qstringlist.h>
 #include <qtextstream.h>
 #include <qdatetime.h>
-#include <math.h>
-#include <sys/time.h>
 
-#include <sys/utsname.h> 
-
+// MythTV headers
 #include "httpserver.h"
 #include "upnputil.h"
+#include "upnp.h" // only needed for Config... remove once config is moved.
+#include "compat.h"
 
-#include "upnp.h"       // only needed for Config... remove once config is moved.
-
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
 //
@@ -51 +57 @@
     // Build Platform String
     // ----------------------------------------------------------------------
 
+#ifdef USING_MINGW
+    g_sPlatform = QString( "Windows %1.%1" )
+        .arg(LOBYTE(LOWORD(GetVersion())))
+        .arg(HIBYTE(LOWORD(GetVersion())));
+#else
     struct utsname uname_info;
 
     uname( &uname_info );
 
     g_sPlatform = QString( "%1 %2" ).arg( uname_info.sysname )
                                     .arg( uname_info.release );
+#endif
 
     // -=>TODO: Load Config XML
     // -=>TODO: Load & initialize - HttpServerExtensions

libs/libmythupnp/multicast.h

@@ -11 +11 @@
 #ifndef __MULTICAST_H__
 #define __MULTICAST_H__
 
+// Qt headers
 #include <qsocketdevice.h>
 
+// MythTV headers
+#include "compat.h"
+
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
 //

libs/libmythupnp/upnputil.cpp

@@ -8 +8 @@
 //
 //////////////////////////////////////////////////////////////////////////////
 
-#include "mythconfig.h"
-#include "upnputil.h"
-#include "upnp.h"
+// POSIX headers
+#include <sys/types.h>
+#include <sys/time.h>
 
-#include <quuid.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
+#ifndef USING_MINGW
 #include <net/if.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <sys/utsname.h> 
-#include <sys/time.h>
+#endif // USING_MINGW
+
+#include "mythconfig.h" // for HAVE_GETIFADDRS
 #ifdef HAVE_GETIFADDRS
 #include <ifaddrs.h>
 #endif
 
+// Qt headers
+#include <quuid.h>
+
+// MythTV headers
+#include "upnputil.h"
+#include "upnp.h"
+#include "compat.h"
+
 /////////////////////////////////////////////////////////////////////////////
 //
 /////////////////////////////////////////////////////////////////////////////
@@ -117 +121 @@
 
 long GetIPAddressList( QStringList &sStrList )
 {
+#ifdef USING_MINGW
+    VERBOSE(VB_UPNP, QString("GetIPAddressList() not implemented in MinGW"));
+    return 0;
+#else
+
     sStrList.clear();
 
     QSocketDevice socket( QSocketDevice::Datagram );
@@ -179 +188 @@
     }
 
     return( sStrList.count() );
+#endif // !USING_MINGW
 }
 
 #endif // HAVE_GETIFADDRS

libs/libmythupnp/bufferedsocketdevice.h

@@ -11 +11 @@
 #ifndef __BUFFEREDSOCKETDEVICE_H__
 #define __BUFFEREDSOCKETDEVICE_H__
 
+// Qt headers
 #include <qsocketdevice.h>
-#include <sys/socket.h>
 
+// MythTV headers
 #include "private/qinternal_p.h"
+#include "compat.h"
 
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

libs/libmythupnp/httprequest.cpp

@@ -18 +18 @@
 #include <qfileinfo.h>
 
 #include "mythconfig.h"
-#if defined CONFIG_DARWIN || defined CONFIG_CYGWIN || defined(__FreeBSD__)
+#if defined CONFIG_DARWIN || defined CONFIG_CYGWIN || defined(__FreeBSD__) || defined(USING_MINGW)
 #include "darwin-sendfile.h"
 #else
 #define USE_SETSOCKOPT
 #include <sys/sendfile.h>
 #endif
-#include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/stat.h>
-#include <netinet/tcp.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <fcntl.h>
 
+#ifndef USING_MINGW
+#include <netinet/tcp.h>
+#endif
+
 #include "util.h"
 #include "mythcontext.h"  // for VERBOSE
 #include "upnp.h"
+#include "compat.h"
 
 #ifndef O_LARGEFILE
 #define O_LARGEFILE 0

libs/libmythupnp/libmythupnp.pro

@@ -40 +40 @@
 
 TARGETDEPS += ../libmyth/libmyth-$${MYTH_SHLIB_EXT}
 
+mingw {
+    DEFINES += USING_MINGW
+    HEADERS += darwin-sendfile.h
+    SOURCES += darwin-sendfile.c
+    target.path = $${PREFIX}/bin
+}
+
 inc.path = $${PREFIX}/include/mythtv/upnp/
 
 inc.files  = httprequest.h upnp.h ssdp.h taskqueue.h bufferedsocketdevice.h

libs/libmythupnp/upnptasksearch.h

@@ -11 +11 @@
 #ifndef __UPNPTASKSEARCH_H__
 #define __UPNPTASKSEARCH_H__
 
-#include <qsocketdevice.h>
-
+// POSIX headers
 #include <sys/types.h>
-#include <sys/socket.h>
+#ifndef USING_MINGW
 #include <netinet/in.h>
 #include <arpa/inet.h>
+#endif
 
+// Qt headers
+#include <qsocketdevice.h>
+
+// MythTV headers
 #include "upnp.h"
+#include "compat.h"
 
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

libs/libmythupnp/upnptasknotify.h

@@ -11 +11 @@
 #ifndef __UPNPTASKNOTIFY_H__
 #define __UPNPTASKNOTIFY_H__
 
-#include <qsocketdevice.h>
-
+// POSIX headers
 #include <sys/types.h>
-#include <sys/socket.h>
+#ifdef USING_MINGW
 #include <netinet/in.h>
 #include <arpa/inet.h>
+#endif
 
+// Qt headers
+#include <qsocketdevice.h>
+
+// MythTV headers
 #include "upnp.h"
 #include "multicast.h"
+#include "compat.h"
 
 /////////////////////////////////////////////////////////////////////////////
 // Typedefs

libs/libmythupnp/httpserver.h

@@ -12 +12 @@
 #ifndef __HTTPSERVER_H__
 #define __HTTPSERVER_H__
 
+// POSIX headers
+#include <sys/types.h>
+#ifdef USING_MINGW
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#endif
+
+// Qt headers
 #include <qthread.h>
 #include <qserversocket.h>
 #include <qsocketdevice.h>
@@ -21 +29 @@
 #include <qtimer.h>
 #include <qptrlist.h>
 
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-
+// MythTV headers
 #include "upnputil.h"
 #include "httprequest.h"
 #include "threadpool.h"
 #include "refcounted.h"
+#include "compat.h"
 
-
 typedef struct timeval  TaskTime;
 
 class HttpWorkerThread;

libs/libmythupnp/taskqueue.h

@@ -11 +11 @@
 #ifndef __TASKQUEUE_H__
 #define __TASKQUEUE_H__
 
-#include <qthread.h>
-#include <qsocketdevice.h>
-
+// POSIX headers
 #include <sys/types.h>
+#ifndef USING_MINGW
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
+#endif // USING_MINGW
+
+// C++ headers
 #include <map>
 
+// Qt headers
+#include <qthread.h>
+#include <qsocketdevice.h>
+
+// MythTV headers
 #include "upnputil.h"
 #include "refcounted.h"
 

libs/libmythupnp/upnptasksearch.cpp

@@ -10 +10 @@
 
 #include "upnp.h"
 #include "upnptasksearch.h"
+#include "compat.h"
 
 #include <unistd.h>
 #include <stdlib.h>

libs/libmythdvdnav/decoder.h

@@ -26 +26 @@
 #define DECODER_H_INCLUDED
 
 #include <inttypes.h>
+
+#ifndef USING_MINGW
 #include <sys/time.h>
+#endif
 
 #include "ifo_types.h" /*  vm_cmd_t */
 #include "dvdnav_internal.h"

libs/libmythdvdnav/dvdnav_internal.h

@@ -24 +24 @@
 #ifndef DVDNAV_INTERNAL_H_INCLUDED
 #define DVDNAV_INTERNAL_H_INCLUDED
 
-#include "config.h"
-
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <limits.h>
 #include <string.h>
 
+// MythTV headers
+#include "mythconfig.h"
+#include "compat.h"
+
 #ifdef WIN32
 
 /* pthread_mutex_* wrapper for win32 */

libs/libmythdvdnav/libmythdvdnav.pro

@@ -6 +6 @@
 CONFIG += thread staticlib warn_off
 target.path = $${LIBDIR}
 
-INCLUDEPATH += ../ ../../
+INCLUDEPATH += ../ ../../ ../libmyth
 
 #build position independent code since the library is linked into a shared library
 QMAKE_CFLAGS += -fPIC -DPIC
@@ -36 +36 @@
     # Globals in static libraries need special treatment on OS X
     QMAKE_CFLAGS += -fno-common
 }
+
+mingw:DEFINES += STDC_HEADERS

libs/libmythdvdnav/dvd_input.c

@@ -48 +48 @@
 #else
 
 /* dlopening libdvdcss */
+#include "compat.h"
+#ifndef USING_MINGW
 #include <dlfcn.h>
+#endif
 
 typedef struct dvdcss_s *dvdcss_handle;
 static dvdcss_handle (*DVDcss_open)  (const char *);
@@ -288 +291 @@
 #ifdef CONFIG_DARWIN
   dvdcss_library = dlopen("libdvdcss.2.dylib", RTLD_LAZY);
 #endif
-#ifdef WIN32
+#ifdef _WIN32
   dvdcss_library = dlopen("libdvdcss.dll", RTLD_LAZY);
 #endif
 

libs/libmythdvdnav/read_cache.c

@@ -29 +29 @@
 
 #include "config.h"
 
+#include "dvdnav_internal.h"
 #include "dvdnav.h"
-#include "dvdnav_internal.h"
 #include "read_cache.h"
+
+#include <time.h>
+#ifndef _WIN32
 #include <sys/time.h>
-#include <time.h>
+#endif
 
 #define READ_CACHE_CHUNKS 10
 

libs/libmythdvdnav/dvdnav.c

@@ -33 +33 @@
 
 #include <stdlib.h>
 #include <stdio.h>
+
+// POSIX headers
+#ifndef _WIN32
 #include <sys/time.h>
+#endif
 
 #include "remap.h"
 

programs/mythuitest/btnlisttest.cpp

@@ -46 +46 @@
     vbuttons = new MythListButton(this, "vlist", r, true, true);
 
     MythFontProperties fontProp;
-    fontProp.SetFace(CreateFont("Arial", 24, QFont::Bold));
+    fontProp.SetFace(CreateQFont("Arial", 24, QFont::Bold));
     fontProp.SetColor(QColor(Qt::white));
     fontProp.SetShadow(true, NormPoint(QPoint(4, 4)), QColor(Qt::black), 64);
 
@@ -71 +71 @@
     hbuttons = new MythHorizListButton(this,"hlist",r,true,true, 3);
 
     MythFontProperties fontProp;
-    fontProp.SetFace(CreateFont("Arial", 24, QFont::Bold));
+    fontProp.SetFace(CreateQFont("Arial", 24, QFont::Bold));
     fontProp.SetColor(QColor(Qt::white));
     fontProp.SetShadow(true, NormPoint(QPoint(4, 4)), QColor(Qt::black), 64);
 

programs/mythuitest/test1.cpp

@@ -15 +15 @@
            : MythScreenType(parent, name)
 {
     MythFontProperties fontProp1;
-    fontProp1.SetFace(CreateFont("Arial", 48, QFont::Bold));
+    fontProp1.SetFace(CreateQFont("Arial", 48, QFont::Bold));
     fontProp1.SetColor(QColor(Qt::white));
     fontProp1.SetShadow(true, NormPoint(QPoint(4, 4)), QColor(Qt::black), 64);
 
@@ -25 +25 @@
     main->SetJustification(Qt::AlignCenter);
 
     MythFontProperties fontProp;
-    fontProp.SetFace(CreateFont("Arial", 14));
+    fontProp.SetFace(CreateQFont("Arial", 14));
     fontProp.SetColor(QColor(Qt::white));
     fontProp.SetShadow(true, NormPoint(QPoint(1, 1)), QColor(Qt::black), 64);
 
@@ -280 +280 @@
     image->SetPosition(NormPoint(QPoint(30, 30)));
     image->Load();
 
-    QFont fontFace = CreateFont("Arial", 28, QFont::Bold);
+    QFont fontFace = CreateQFont("Arial", 28, QFont::Bold);
 
     MythFontProperties fontProp;
     fontProp.SetFace(fontFace);

programs/programs-libs.pro

@@ -16 +16 @@
 LIBS += -lmythupnp-$$LIBVERSION 
 LIBS += -lmythlivemedia-$$LIBVERSION
 LIBS += -lmyth-$$LIBVERSION -lmythui-$$LIBVERSION $$EXTRA_LIBS
+mingw {
+    LIBS += -lpthread
+    CONFIG += console
+}
 
 TARGETDEPS += ../../libs/libmythui/libmythui-$${MYTH_SHLIB_EXT}
 TARGETDEPS += ../../libs/libmyth/libmyth-$${MYTH_SHLIB_EXT}
@@ -24 +28 @@
 TARGETDEPS += ../../libs/libavcodec/libmythavcodec-$${MYTH_SHLIB_EXT}
 TARGETDEPS += ../../libs/libavformat/libmythavformat-$${MYTH_SHLIB_EXT}
 TARGETDEPS += ../../libs/libmythupnp/libmythupnp-$${MYTH_SHLIB_EXT}
-TARGETDEPS += ../../libs/libmythlivemedia/libmythlivemedia-$${MYTH_SHLIB_EXT}
+using_live: TARGETDEPS += ../../libs/libmythlivemedia/libmythlivemedia-$${MYTH_SHLIB_EXT}
 
 DEPENDPATH += ../.. ../../libs ../../libs/libmyth ../../libs/libmythtv
 DEPENDPATH += ../../libs/libavutil ../../libs/libavformat ../../libs/libsavcodec

programs/mythfrontend/channelrecpriority.cpp

@@ -665 +665 @@
                 if (curitem->iconpath == "none" || curitem->iconpath == "")
                     curitem->iconpath = "blankicon.jpg";
                 if (!curitem->iconload)
-                    curitem->LoadIcon(iconwidth, iconheight);
+                    curitem->LoadChannelIcon(iconwidth, iconheight);
                 if (curitem->iconload)
                     itype->SetImage(curitem->icon);
             }

programs/mythfrontend/mediarenderer.cpp

@@ -9 +9 @@
 /////////////////////////////////////////////////////////////////////////////
 
 #include "mediarenderer.h"
+#include "compat.h"
 
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

programs/mythfrontend/globalsettings.cpp

@@ -3 +3 @@
 // Standard UNIX C headers
 #include <unistd.h>
 #include <fcntl.h>
-#include <sys/ioctl.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 
@@ -68 +67 @@
 #ifdef USING_COREAUDIO
     gc->addSelection("CoreAudio:", "CoreAudio:"); 
 #endif
+#ifdef USING_DIRECTX
+        gc->addSelection("DirectX:");
+#endif
+#ifdef USING_MINGW
+        gc->addSelection("Windows:");
+#endif
     gc->addSelection("NULL", "NULL");
 
     return gc;
@@ -79 +84 @@
 
     gc->setLabel(QObject::tr("Passthrough output device"));
     gc->addSelection(QObject::tr("Default"), "Default");
+#ifndef USING_MINGW
     gc->addSelection("ALSA:iec958:{ AES0 0x02 }", "ALSA:iec958:{ AES0 0x02 }");
+#endif
 
     gc->setHelpText(QObject::tr("Audio output device to use for AC3 and "
                     "DTS passthrough. Default is the same as Audio output "
@@ -117 +124 @@
 #ifdef USING_ALSA
     gc->addSelection("ALSA:default", "ALSA:default");
 #endif
+#ifdef USING_DIRECTX
+    gc->addSelection("DirectX:", "DirectX:");
+#endif
+#ifdef USING_WINAUDIO
+    gc->addSelection("Windows:", "Windows:");
+#endif
 
     return gc;
 }
@@ -4637 +4650 @@
 
     theme->addChild(new ThemeSelector("Theme"));
 
-    HorizontalConfigurationGroup *grp1 =
+    HorizontalConfigurationGroup *hgrp1 =
         new HorizontalConfigurationGroup(false, false, false, false);
-    grp1->addChild(RandomTheme());
-    grp1->addChild(ThemeCacheSize());
-    theme->addChild(grp1);
+    hgrp1->addChild(RandomTheme());
+    hgrp1->addChild(ThemeCacheSize());
+    theme->addChild(hgrp1);
 
     theme->addChild(ThemePainter());
     theme->addChild(new StyleSetting());

programs/mythfrontend/networkcontrol.cpp

@@ -14 +14 @@
 #include "programinfo.h"
 #include "remoteutil.h"
 #include "previewgenerator.h"
+#include "compat.h"
 
 #define LOC QString("NetworkControl: ")
 #define LOC_ERR QString("NetworkControl Error: ")

programs/mythtranscode/replex/replex.c

@@ -42 +42 @@
 #include "avcodec.h"
 #include "avformat.h"
 
+#ifdef USING_MINGW
+# define S_IRGRP 0
+# define S_IWGRP 0
+# define S_IROTH 0
+# define S_IWOTH 0
+#endif
+
 #ifndef O_LARGEFILE
 #define O_LARGEFILE 0
 #endif

programs/mythtranscode/replex/ts.c

@@ -28 +28 @@
 #include <stdint.h>
 #include <string.h>
 #include <stdio.h>
+
+#ifdef USING_MINGW
+#include <winsock2.h>
+#else
 #include <netinet/in.h>
+#endif
 
 #include "ts.h"
 #include "element.h"

programs/mythtranscode/replex/pes.c

@@ -26 +26 @@
 
 #include <stdlib.h>
 #include <stdio.h>
-#include <netinet/in.h>
 #include <string.h>
 
+#ifdef USING_MINGW
+#include <winsock2.h>
+#else
+#include <netinet/in.h>
+#endif
+
 #include "pes.h"
 void printpts(int64_t pts)
 {

programs/mythtranscode/mpeg2fix.cpp

@@ -11 +11 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
-#include <netinet/in.h>
 #include <getopt.h>
 #include <stdint.h>
 
+#ifdef USING_MINGW
+#include <winsock2.h>
+#else
+#include <netinet/in.h>
+#endif
+
 #ifndef O_LARGEFILE
 #define O_LARGEFILE 0
 #endif

programs/mythcommflag/BorderDetector.cpp

@@ -4 +4 @@
 #include "avcodec.h"        /* AVPicture */
 }
 #include "mythcontext.h"    /* gContext */
+#include "compat.h"
 
 #include "CommDetector2.h"
 #include "FrameAnalyzer.h"

programs/mythcommflag/CommDetector2.cpp

@@ -4 +4 @@
 #include <unistd.h>
 
 #include "NuppelVideoPlayer.h"
+#include "compat.h"
 
 #include "CommDetector.h"
 #include "CommDetector2.h"

programs/mythtv-setup/main.cpp

@@ -12 +12 @@
 #include <cstdio>
 #include <fcntl.h>
 #include <cstdlib>
-#include <sys/ioctl.h>
 #include <sys/types.h>
 
 #include <iostream>

programs/mythbackend/main.cpp

@@ -1 +1 @@
 // POSIX headers
 #include <sys/time.h>     // for setpriority
-#include <sys/resource.h> // for setpriority
 
 #include <qapplication.h>
 #include <qsqldatabase.h>
@@ -36 +35 @@
 #include "libmyth/mythcontext.h"
 #include "libmyth/mythdbcon.h"
 #include "libmyth/exitcodes.h"
+#include "libmyth/compat.h"
 #include "libmythtv/programinfo.h"
 #include "libmythtv/dbcheck.h"
 #include "libmythtv/jobqueue.h"
@@ -368 +368 @@
 
 int main(int argc, char **argv)
 {
-    for(int i = 3; i < sysconf(_SC_OPEN_MAX) - 1; ++i)
+#ifdef USING_MINGW
+#warning TODO FIXME plugins leave open file descriptors on MS Windows
+#else
+    for (int i = 3; i < sysconf(_SC_OPEN_MAX) - 1; ++i)
         close(i);
+#endif
 
     QApplication a(argc, argv, false);
 

programs/mythbackend/mainserver.cpp

@@ -19 +19 @@
 #elif HAVE_SOUNDCARD_H
     #include <soundcard.h>
 #endif
+#ifndef USING_MINGW
 #include <sys/ioctl.h>
+#endif
 
 #include <list>
 #include <iostream>
 using namespace std;
 
 #include <sys/stat.h>
-#ifdef linux
-#include <sys/vfs.h>
-#else
-#include <sys/param.h>
-#include <sys/mount.h>
-#endif
+#ifdef __linux__
+#  include <sys/vfs.h>
+#else // if !__linux__
+#  include <sys/param.h>
+#  ifndef USING_MINGW
+#    include <sys/mount.h>
+#  endif // USING_MINGW
+#endif // !__linux__
 
 #include "libmyth/exitcodes.h"
 #include "libmyth/mythcontext.h"
@@ -46 +50 @@
 #include "autoexpire.h"
 #include "previewgenerator.h"
 #include "storagegroup.h"
+#include "compat.h"
 
 /** Milliseconds to wait for an existing thread from
  *  process request thread pool.

programs/mythbackend/scheduler.cpp

@@ -9 +9 @@
 #include <algorithm>
 using namespace std;
 
-#ifdef linux
-#include <sys/vfs.h>
-#else
-#include <sys/param.h>
-#include <sys/mount.h>
-#include <sys/resource.h>
-#endif
+#ifdef __linux__
+#  include <sys/vfs.h>
+#else // if !__linux__
+#  include <sys/param.h>
+#  ifndef USING_MINGW
+#    include <sys/mount.h>
+#  endif // USING_MINGW
+#endif // !__linux__
 
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
-#include <sys/wait.h>
 
 #include "scheduler.h"
 #include "encoderlink.h"
@@ -31 +31 @@
 #include "libmyth/exitcodes.h"
 #include "libmyth/mythcontext.h"
 #include "libmyth/mythdbcon.h"
+#include "libmyth/compat.h"
 #include "libmythtv/programinfo.h"
 #include "libmythtv/scheduledrecording.h"
 #include "libmythtv/storagegroup.h"

programs/mythbackend/housekeeper.cpp

@@ -1 +1 @@
 #include <unistd.h>
 #include <sys/types.h>
-#include <sys/wait.h>
 #include <unistd.h>
 #include <qsqldatabase.h>
 #include <qsqlquery.h>
@@ -19 +18 @@
 #include "libmyth/mythcontext.h"
 #include "libmyth/mythdbcon.h"
 #include "libmyth/util.h"
+#include "libmyth/compat.h"
 
 #include "programinfo.h"
 

programs/mythbackend/httpstatus.cpp

@@ -15 +15 @@
 #include "libmyth/mythcontext.h"
 #include "libmyth/util.h"
 #include "libmyth/mythdbcon.h"
+#include "libmyth/compat.h"
 
 #include <qtextstream.h>
 #include <qdir.h>

programs/mythbackend/backendutil.cpp

@@ -18 +18 @@
 #include "libmyth/mythcontext.h"
 #include "libmyth/mythdbcon.h"
 #include "libmyth/util.h"
+#include "libmyth/compat.h"
 
 static QMap<int, int> fsID_cache;
 static QMutex cache_lock;

programs/mythbackend/autoexpire.cpp

@@ -15 +15 @@
 using namespace std;
 
 #include <sys/stat.h>
-#ifdef linux
-#include <sys/vfs.h>
-#else
-#include <sys/param.h>
-#include <sys/mount.h>
-#endif
+#ifdef __linux__
+#  include <sys/vfs.h>
+#else // if !__linux__
+#  include <sys/param.h>
+#  ifndef USING_MINGW
+#    include <sys/mount.h>
+#  endif // USING_MINGW
+#endif // !__linux__
 
 #include "autoexpire.h"
 #include "programinfo.h"
@@ -32 +34 @@
 #include "libmythtv/storagegroup.h"
 #include "encoderlink.h"
 #include "backendutil.h"
+#include "compat.h"
 
 #define LOC QString("AutoExpire: ")
 

programs/mythbackend/encoderlink.cpp

@@ -15 +15 @@
 #include "previewgenerator.h"
 #include "storagegroup.h"
 #include "backendutil.h"
+#include "compat.h"
 
 /**
  * \class EncoderLink

programs/mythtv/main.cpp

@@ -13 +13 @@
 #include "libmyth/mythcontext.h"
 #include "libmyth/mythdbcon.h"
 #include "libmyth/mythdialogs.h"
+#include "libmyth/compat.h"
 
 #include <iostream>
 using namespace std;

programs/mythlcdserver/main.cpp

@@ -20 +20 @@
 #include "mythcontext.h"
 #include "mythdbcon.h"
 #include "tv_play.h"
+#include "compat.h"
 
 #include "lcdserver.h"
 

programs/mythlcdserver/lcdprocclient.cpp

@@ -19 +19 @@
 #include "tv.h"
 #include "lcdserver.h"
 #include "lcddevice.h"
+#include "compat.h"
 
-
 #define LCD_START_COL 3
 
 #define LCD_VERSION_4 1

programs/mythwelcome/welcomedialog.cpp

@@ +1 @@
+// ANSI C
+#include <cstdlib>
+
+// POSIX
 #include <unistd.h>
-#include <stdlib.h>
-#include <sys/wait.h>   // For WIFEXITED on Mac OS X
 
 // qt
 #include <qapplication.h>
@@ -13 +15 @@
 #include "programinfo.h"
 #include "uitypes.h"
 #include "remoteutil.h"
+#include "compat.h"
 
 #include "welcomedialog.h"
 #include "welcomesettings.h"

programs/mythtvosd/main.cpp

@@ +1 @@
+// ANSI C headers
 #include <cstdlib>
+
+// POSIX headers
 #include <sys/types.h>
-#include <sys/socket.h>
 
+// C++ headers
 #include <iostream>
-#include <cstdlib>
+using namespace std;
 
+// Qt headers
 #include <qapplication.h>
 #include <qsocketdevice.h>
 #include <qstring.h>
@@ -12 +16 @@
 #include <qfile.h>
 #include <qhostaddress.h>
 
+// MythTV headers
 #include "exitcodes.h"
+#include "compat.h"
 
-using namespace std;
-
 const QString kalert =
 "<mythnotify version=\"1\">\n"
 "  <container name=\"notify_alert_text\">\n"

programs/mythshutdown/main.cpp

@@ -7 +7 @@
 using namespace std;
 #include <unistd.h>
 
-#include <sys/wait.h>   // For WIFEXITED on Mac OS X
-
 #include <exitcodes.h>
 #include <mythcontext.h>
 #include <mythdbcon.h>
 #include "libmythtv/programinfo.h"
 #include "libmythtv/jobqueue.h"
 #include "tv.h"
+#include "compat.h"
 
 void setGlobalSetting(const QString &key, const QString &value)
 {

programs/mythfilldatabase/filldata.cpp

@@ -1 +1 @@
 // POSIX headers
 #include <unistd.h>
 #include <signal.h>
-#include <sys/wait.h>
 
 // Std C headers
 #include <cstdlib>
@@ -22 +21 @@
 #include "exitcodes.h"
 #include "mythcontext.h"
 #include "mythdbcon.h"
+#include "compat.h"
 
 // libmythtv headers
 #include "videosource.h" // for is_grabber..
@@ -299 +299 @@
     if (xmltv_grabber == "schedulesdirect1")
         return grabDDData(source, offset, *qCurrentDate, DD_SCHEDULES_DIRECT);
 
+#ifdef USING_MINGW
+    char tempfilename[MAX_PATH] = "";
+    if (GetTempFileNameA("%TEMP%", "mth", 0, tempfilename) == 0)
+#else
     char tempfilename[] = "/tmp/mythXXXXXX";
     if (mkstemp(tempfilename) == -1)
+#endif
     {
         VERBOSE(VB_IMPORTANT,
                 QString("Error creating temporary file in /tmp, %1")

programs/mythfilldatabase/icondata.cpp

@@ -1 +1 @@
 // POSIX headers
 #include <unistd.h>
 #include <signal.h>
-#include <sys/wait.h>
 
 // Qt headers
 #include <qdom.h>

settings.pro

@@ -7 +7 @@
 LIBVERSION = 0.20
 VERSION = 0.20.0
 
+isEmpty(TARGET_OS) : win32 {
+    CONFIG += mingw
+    DEFINES -= UNICODE
+    QMAKE_EXTENSION_SHLIB = dll
+    VERSION =
+    CONFIG_OPENGL_LIBS =
+}
+
 # if CYGWIN compile, set up flag in CONFIG 
 contains(TARGET_OS, CYGWIN) { 
     CONFIG += cygwin 

filters/postprocess/postprocess.pro

@@ -9 +9 @@
 # Lots of symbols like pp_free_context, pp_free_mode, pp_get_context, pp_help
 # are used but not defined, which sometimes prevents linking on OS X.
 macx:LIBS += -undefined define_a_way
+
+mingw {
+  SOURCES += ../../libs/libpostproc/postprocess.c
+  TARGET = postprocess
+}

filters/greedyhdeint/greedyh.asm

@@ -17 +17 @@
 /////////////////////////////////////////////////////////////////////////////
 
 #include "x86-64_macros.inc"
-#include <mangle.h>
+#include "mangle.h"
 
 #if !defined(MASKS_DEFINED)
 #define MASKS_DEFINED