DecodingThread.cpp

// DecodingThread.cpp : implementation file
//

#include "stdafx.h"
#include "TransClient.h"
#include "DecodingThread.h"
#include "GlobalCon.h"
#include "globalvar.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


extern int finished;
extern HWND pPlayer;
unsigned char *bufRGB;
extern char ServerAddress[20];


extern "C" 
{
        #include "./h263/global.h"
}

/* Data for ConvertYUVtoRGB */

long int crv_tab[256];
long int cbu_tab[256];
long int cgu_tab[256];

long int cgv_tab[256];
long int tab_76309[256];

void ConvertYUVtoRGB (unsigned char *src0, unsigned char *src1, unsigned char *src2, 
                                          unsigned char *dst_ori, int width, int height);
void init_dither_tab();

// CDecodingThread

IMPLEMENT_DYNCREATE(CDecodingThread, CWinThread)

CDecodingThread::CDecodingThread()
{
}

CDecodingThread::CDecodingThread(CClient* pClient)
{
        m_pClient = pClient;
}

CDecodingThread::~CDecodingThread()
{
}

BOOL CDecodingThread::InitInstance()
{
        // TODO:  perform and per-thread initialization here
        // Initialize the decoder
//      init_decoder();
        return TRUE;
}

int CDecodingThread::ExitInstance()
{
        // TODO:  perform any per-thread cleanup here
//      fclose(video);
        closesocket(m_ClientSock);
        return CWinThread::ExitInstance();
}

BEGIN_MESSAGE_MAP(CDecodingThread, CWinThread)
        //{{AFX_MSG_MAP(CDecodingThread)
                // NOTE - the ClassWizard will add and remove mapping macros here.
        //}}AFX_MSG_MAP
END_MESSAGE_MAP()

// CDecodingThread message handlers

int CDecodingThread::Run() 
{
        // TODO: Add your specialized code here and/or call the base class
        recv_buf_size = 2*1024;
        bits_recv_buf = 0;
        int leng;
        int gob;
        int cc;

        if((recv_buf = (unsigned char*)malloc(recv_buf_size))==NULL)
        {
                MessageBox(NULL, TEXT("cann't allocate recv_buf!"),TEXT("Client"),MB_ICONERROR | MB_OK);
                return FALSE;
        }

        leng=sizeof(recv_buf_size);

        struct sockaddr_in servaddr;

        if((m_ClientSock = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) 
        {
                MessageBox(NULL, TEXT("cann't create data socket!"),TEXT("Client"),MB_ICONERROR | MB_OK);
                return FALSE;
        }

        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(m_pClient->m_DataPort);
        servaddr.sin_addr.s_addr = inet_addr(ServerAddress);

        if((connect(m_ClientSock, (struct sockaddr *)&servaddr, sizeof(servaddr)))==SOCKET_ERROR)
        {
                MessageBox(NULL, TEXT("cann't connect to server!"),TEXT("Client"),MB_ICONERROR | MB_OK);
                return FALSE;
        }

        setsockopt(m_ClientSock, SOL_SOCKET, SO_RCVBUF, (char *) &recv_buf_size, leng);
        
        m_framenum = 0;
        m_first = 1;
        
        base.pDataSock = m_ClientSock;
        ld=&base;
        initbits();

        while(gob=getheader())
        {       
                if (m_first)
                {
                        init_decoder();
                        init_display();
                        m_first = 0;
                }
                getpicture (&m_framenum, gob);
                ConvertYUVtoRGB (current_frame[0],current_frame[1],current_frame[2],bufRGB,coded_picture_width,coded_picture_height);
                ::SendMessage(pPlayer, USER_MSG_DISPLAY, m_framenum, (long)bufRGB);
                m_framenum ++;
        }
        
        ::SendMessage(pPlayer, USER_MSG_DISPLAY, m_framenum, NULL);

        free(recv_buf);
        closesocket(m_ClientSock);
        free(bufRGB);
        

        for(cc=0; cc<3; cc++)
        {
                free(next_I_P_frame[cc]);
                free(prev_I_P_frame[cc]);
                free(bframe[cc]);
                free(tmp_f[cc]);
                free(tmp_b[cc]);
                free(edgeframeorig[cc]);
                free(nextedgeframeorig[cc]);
        }
        VideoIsRequested = false;
        return true;
        //return CWinThread::Run();

}


void CDecodingThread::init_decoder()
{
  int cc, size;

  /* MPEG-1 = TMN parameters */
  matrix_coefficients = 5;

  if (source_format == SF_CIF) {  // Input stream is CIF
    MBC = 22;
    MBR = 18;
  }
  else if (source_format == SF_QCIF) {   // Input stream is QCIF
    MBC = 11;
    MBR = 9;
  }
  else if (source_format == SF_SQCIF) {  // Input stream is SQCIF
        MBC = 8;
    MBR = 6;
  }
  else
    exit(1);

  horizontal_size = MBC*16;
  vertical_size = MBR*16;

  mb_width = horizontal_size/16;
  mb_height = vertical_size/16;
  coded_picture_width = 16*mb_width;
  coded_picture_height = 16*mb_height;
  chrom_width =  coded_picture_width>>1;
  chrom_height = coded_picture_height>>1;
  blk_cnt = 6;

  for (cc = 0; cc < 3; cc++)
  {
    if (cc == 0)
      size = coded_picture_width * coded_picture_height;
    else
      size = chrom_width * chrom_height;

    /* Used for bidirectional and direct prediction mode for true B
     * pictures, one for forward and one for backward. */
    next_I_P_frame[cc] = (unsigned char *) malloc (size);

    //prev_I_P_frame[cc] = (unsigned char *) malloc (size);
    
    current_frame[cc] = (unsigned char *) malloc (size);

    bframe[cc] = (unsigned char *) malloc (size);
    
    prev_frame[cc] = current_frame[cc];
    
    tmp_f[cc] = (unsigned char *) malloc (size);

    tmp_b[cc] = (unsigned char *) malloc (size);
  }


  for (cc = 0; cc < 3; cc++)
  {
    if (cc == 0)
    {
      size = (coded_picture_width + 64) * (coded_picture_height + 64);

      /* Stores framed version of previous inter-picture, luminance. */
      edgeframeorig[cc] = (unsigned char *) malloc (size);

      edgeframe[cc] = edgeframeorig[cc] + (coded_picture_width + 64) * 32 + 32;

      /* Required for true B frames backward, bidir, and direct
       * prediction. Stores future inter-picture, luminance */
      nextedgeframeorig[cc] = (unsigned char *) malloc (size);

      nextedgeframe[cc] = nextedgeframeorig[cc] + (coded_picture_width + 64) * 32 + 32;
    } 
    else
    {
      size = (chrom_width + 32) * (chrom_height + 32);

      /* Stores framed version of previous inter-picture, chrominance. */
      edgeframeorig[cc] = (unsigned char *) malloc (size);

      edgeframe[cc] = edgeframeorig[cc] + (chrom_width + 32) * 16 + 16;

      /* Required for true B frames backward, bidir, and direct
       * prediction. Stores future inter-picture, chrominance. */
      nextedgeframeorig[cc] = (unsigned char *) malloc (size);

      nextedgeframe[cc] = nextedgeframeorig[cc] + (chrom_width + 32) * 16 + 16;
    }
  }

  /* IDCT */
  if (refidct)
    init_idctref ();
  else
    init_idct ();

  prev_mv_outside_frame = prev_sac = prev_adv_pred = prev_aic = prev_df = 0;
  prev_slice_struct = prev_rps = prev_isd = prev_aivlc = prev_mq = 0;
  prev_4mv = prev_long_vectors = prev_obmc = 0;
}


void CDecodingThread::init_display()
{
        int i;
        if (!(clp = (unsigned char *) malloc (1024))) {
                AfxMessageBox ("malloc for clp failed");
                return;
        }
        clp += 384;
        for (i = -384; i < 640; i++)
                clp[i] = (i < 0) ? 0 : ((i > 255) ? 255 : i);

        init_dither_tab();

        /* now modify the couple that need it */
        /* allocate the memory needed to hold the RGB and visualization
         * information */
        bufRGB = (unsigned char *) malloc (3 * coded_picture_width * coded_picture_height);
}


void init_dither_tab ()
{
  long int crv, cbu, cgu, cgv;
  int i;

  crv = 104597;
  cbu = 132201;                 /* fra matrise i global.h */
  cgu = 25675;
  cgv = 53279;

  for (i = 0; i < 256; i++)
  {
    crv_tab[i] = (i - 128) * crv;
    cbu_tab[i] = (i - 128) * cbu;
    cgu_tab[i] = (i - 128) * cgu;
    cgv_tab[i] = (i - 128) * cgv;
    tab_76309[i] = 76309 * (i - 16);
  }
}




/**********************************************************************
 *
 *      Name:            ConvertYUVtoRGB
 *      Description:     Converts YUV image to RGB (packed mode)
 *
 *      Input:           pointer to source luma, Cr, Cb, destination,
 *                       image width and height
 *      Returns:
 *      Side effects:
 *
 *      Date: 951208    Author: Karl.Lillevold@nta.no
 *
 ***********************************************************************/



void ConvertYUVtoRGB (unsigned char *src0, unsigned char *src1, unsigned char *src2, 
                                          unsigned char *dst_ori, int width, int height)
{
  extern long int crv_tab[];
  extern long int cbu_tab[];
  extern long int cgu_tab[];

  extern long int cgv_tab[];
  extern long int tab_76309[];

  int y11, y21;
  int y12, y22;
  int y13, y23;
  int y14, y24;
  int u, v;
  int i, j;
  int c11, c21, c31, c41;
  int c12, c22, c32, c42;
  unsigned int DW;
  unsigned int *id1, *id2;
  unsigned char *py1, *py2, *pu, *pv;
  unsigned char *d1, *d2;

  d1 = dst_ori;
  d1 += width * height * 3 - width * 3;
  d2 = d1 - width * 3;

  py1 = src0;
  pu = src1;
  pv = src2;
  py2 = py1 + width;

  id1 = (unsigned int *) d1;
  id2 = (unsigned int *) d2;

  for (j = 0; j < height; j += 2)
  {
    /* line j + 0 */
    for (i = 0; i < width; i += 4)
    {
      u = *pu++;
      v = *pv++;
      c11 = crv_tab[v];
      c21 = cgu_tab[u];
      c31 = cgv_tab[v];
      c41 = cbu_tab[u];
      u = *pu++;
      v = *pv++;
      c12 = crv_tab[v];
      c22 = cgu_tab[u];
      c32 = cgv_tab[v];
      c42 = cbu_tab[u];

      y11 = tab_76309[*py1++];  /* (255/219)*65536 */
      y12 = tab_76309[*py1++];
      y13 = tab_76309[*py1++];  /* (255/219)*65536 */
      y14 = tab_76309[*py1++];

      y21 = tab_76309[*py2++];
      y22 = tab_76309[*py2++];
      y23 = tab_76309[*py2++];
      y24 = tab_76309[*py2++];

      /* RGBR */
      DW = ((clp[(y11 + c41) >> 16])) |
        ((clp[(y11 - c21 - c31) >> 16]) << 8) |
        ((clp[(y11 + c11) >> 16]) << 16) |
        ((clp[(y12 + c41) >> 16]) << 24);
      *id1++ = DW;

      /* GBRG */
      DW = ((clp[(y12 - c21 - c31) >> 16])) |
        ((clp[(y12 + c11) >> 16]) << 8) |
        ((clp[(y13 + c42) >> 16]) << 16) |
        ((clp[(y13 - c22 - c32) >> 16]) << 24);
      *id1++ = DW;

      /* BRGB */
      DW = ((clp[(y13 + c12) >> 16])) |
        ((clp[(y14 + c42) >> 16]) << 8) |
        ((clp[(y14 - c22 - c32) >> 16]) << 16) |
        ((clp[(y14 + c12) >> 16]) << 24);
      *id1++ = DW;

      /* RGBR */
      DW = ((clp[(y21 + c41) >> 16])) |
        ((clp[(y21 - c21 - c31) >> 16]) << 8) |
        ((clp[(y21 + c11) >> 16]) << 16) |
        ((clp[(y22 + c41) >> 16]) << 24);
      *id2++ = DW;

      /* GBRG */
      DW = ((clp[(y22 - c21 - c31) >> 16])) |
        ((clp[(y22 + c11) >> 16]) << 8) |
        ((clp[(y23 + c42) >> 16]) << 16) |
        ((clp[(y23 - c22 - c32) >> 16]) << 24);
      *id2++ = DW;

      /* BRGB */
      DW = ((clp[(y23 + c12) >> 16])) |
        ((clp[(y24 + c42) >> 16]) << 8) |
        ((clp[(y24 - c22 - c32) >> 16]) << 16) |
        ((clp[(y24 + c12) >> 16]) << 24);
      *id2++ = DW;
    }
    id1 -= (9 * width) >> 2;
    id2 -= (9 * width) >> 2;
    py1 += width;
    py2 += width;
  }
}

---