Logo Search packages:      
Sourcecode: tela version File versions  Download package

transfrm.C

/* transfrm.c,  forward / inverse transformation                            */

/* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */

/*
 * Disclaimer of Warranty
 *
 * These software programs are available to the user without any license fee or
 * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
 * any and all warranties, whether express, implied, or statuary, including any
 * implied warranties or merchantability or of fitness for a particular
 * purpose.  In no event shall the copyright-holder be liable for any
 * incidental, punitive, or consequential damages of any kind whatsoever
 * arising from the use of these programs.
 *
 * This disclaimer of warranty extends to the user of these programs and user's
 * customers, employees, agents, transferees, successors, and assigns.
 *
 * The MPEG Software Simulation Group does not represent or warrant that the
 * programs furnished hereunder are free of infringement of any third-party
 * patents.
 *
 * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
 * are subject to royalty fees to patent holders.  Many of these patents are
 * general enough such that they are unavoidable regardless of implementation
 * design.
 *
 */

#include <stdio.h>
#include <math.h>
#include "mpegintf.H"
#include "global.h"

/* private prototypes*/
static void sub_pred(unsigned char *pred, unsigned char *cur,
  int lx, short *blk);

/* subtract prediction and transform prediction error */
void MPEG::transform(unsigned char *pred[], unsigned char *cur[],
                               Tmbinfo *mbi, short blocks[][64])
{
      int i, j, i1, j1, k, n, cc, offs, lx;

      k = 0;

      for (j=0; j<height2; j+=16)
            for (i=0; i<width; i+=16)
            {
                  for (n=0; n<block_count; n++)
                  {
                        cc = (n<4) ? 0 : (n&1)+1; /* color component index */
                        if (cc==0)
                        {
                              /* luminance */
                              if ((pict_struct==FRAME_PICTURE) && mbi[k].dct_type)
                              {
                                    /* field DCT */
                                    offs = i + ((n&1)<<3) + width*(j+((n&2)>>1));
                                    lx = width<<1;
                              }
                              else
                              {
                                    /* frame DCT */
                                    offs = i + ((n&1)<<3) + width2*(j+((n&2)<<2));
                                    lx = width2;
                              }

                              if (pict_struct==BOTTOM_FIELD)
                                    offs += width;
                        }
                        else
                        {
                              /* chrominance */

                              /* scale coordinates */
                              i1 = (chroma_format==CHROMA444) ? i : i>>1;
                              j1 = (chroma_format!=CHROMA420) ? j : j>>1;

                              if ((pict_struct==FRAME_PICTURE) && mbi[k].dct_type
                                    && (chroma_format!=CHROMA420))
                              {
                                    /* field DCT */
                                    offs = i1 + (n&8) + chrom_width*(j1+((n&2)>>1));
                                    lx = chrom_width<<1;
                              }
                              else
                              {
                                    /* frame DCT */
                                    offs = i1 + (n&8) + chrom_width2*(j1+((n&2)<<2));
                                    lx = chrom_width2;
                              }

                              if (pict_struct==BOTTOM_FIELD)
                                    offs += chrom_width;
                        }

                        sub_pred(pred[cc]+offs,cur[cc]+offs,lx,blocks[k*block_count+n]);
                        fdct(blocks[k*block_count+n]);
                  }

                  k++;
            }
}

/* inverse transform prediction error and add prediction */
void MPEG::itransform(unsigned char *pred[], unsigned char *cur[],
                                Tmbinfo *mbi, short blocks[][64])
{
      int i, j, i1, j1, k, n, cc, offs, lx;

      k = 0;

      for (j=0; j<height2; j+=16)
            for (i=0; i<width; i+=16)
            {
                  for (n=0; n<block_count; n++)
                  {
                        cc = (n<4) ? 0 : (n&1)+1; /* color component index */

                        if (cc==0)
                        {
                              /* luminance */
                              if ((pict_struct==FRAME_PICTURE) && mbi[k].dct_type)
                              {
                                    /* field DCT */
                                    offs = i + ((n&1)<<3) + width*(j+((n&2)>>1));
                                    lx = width<<1;
                              }
                              else
                              {
                                    /* frame DCT */
                                    offs = i + ((n&1)<<3) + width2*(j+((n&2)<<2));
                                    lx = width2;
                              }

                              if (pict_struct==BOTTOM_FIELD)
                                    offs += width;
                        }
                        else
                        {
                              /* chrominance */

                              /* scale coordinates */
                              i1 = (chroma_format==CHROMA444) ? i : i>>1;
                              j1 = (chroma_format!=CHROMA420) ? j : j>>1;

                              if ((pict_struct==FRAME_PICTURE) && mbi[k].dct_type
                                    && (chroma_format!=CHROMA420))
                              {
                                    /* field DCT */
                                    offs = i1 + (n&8) + chrom_width*(j1+((n&2)>>1));
                                    lx = chrom_width<<1;
                              }
                              else
                              {
                                    /* frame DCT */
                                    offs = i1 + (n&8) + chrom_width2*(j1+((n&2)<<2));
                                    lx = chrom_width2;
                              }

                              if (pict_struct==BOTTOM_FIELD)
                                    offs += chrom_width;
                        }

                        idct(blocks[k*block_count+n]);
                        add_pred(pred[cc]+offs,cur[cc]+offs,lx,blocks[k*block_count+n]);
                  }

                  k++;
            }
}

/* add prediction and prediction error, saturate to 0...255 */
void MPEG::add_pred(unsigned char *pred, unsigned char *cur,
                              int lx, short *blk)
{
      int i, j;

      for (j=0; j<8; j++)
      {
            for (i=0; i<8; i++)
                  cur[i] = clp[blk[i] + pred[i]];
            blk+= 8;
            cur+= lx;
            pred+= lx;
      }
}

/* subtract prediction from block data */
static void sub_pred(unsigned char *pred, unsigned char *cur, int lx, short *blk)
{
      int i, j;

      for (j=0; j<8; j++)
      {
            for (i=0; i<8; i++)
                  blk[i] = cur[i] - pred[i];
            blk+= 8;
            cur+= lx;
            pred+= lx;
      }
}

/*
 * select between frame and field DCT
 *
 * preliminary version: based on inter-field correlation
 */
void MPEG::dct_type_estimation(unsigned char *pred, unsigned char *cur, Tmbinfo *mbi)
{
      short blk0[128], blk1[128];
      int i, j, i0, j0, k, offs, s0, s1, sq0, sq1, s01;
      double d, r;

      k = 0;

      for (j0=0; j0<height2; j0+=16)
            for (i0=0; i0<width; i0+=16)
            {
                  if (frame_pred_dct || pict_struct!=FRAME_PICTURE)
                        mbi[k].dct_type = 0;
                  else
                  {
                        /* interlaced frame picture */
                        /*
                         * calculate prediction error (cur-pred) for top (blk0)
                         * and bottom field (blk1)
                         */
                        for (j=0; j<8; j++)
                        {
                              offs = width*((j<<1)+j0) + i0;
                              for (i=0; i<16; i++)
                              {
                                    blk0[16*j+i] = cur[offs] - pred[offs];
                                    blk1[16*j+i] = cur[offs+width] - pred[offs+width];
                                    offs++;
                              }
                        }
                        /* correlate fields */
                        s0=s1=sq0=sq1=s01=0;

                        for (i=0; i<128; i++)
                        {
                              s0+= blk0[i];
                              sq0+= blk0[i]*blk0[i];
                              s1+= blk1[i];
                              sq1+= blk1[i]*blk1[i];
                              s01+= blk0[i]*blk1[i];
                        }

                        d = (sq0-(s0*s0)/128.0)*(sq1-(s1*s1)/128.0);

                        if (d>0.0)
                        {
                              r = (s01-(s0*s1)/128.0)/sqrt(d);
                              if (r>0.5)
                                    mbi[k].dct_type = 0; /* frame DCT */
                              else
                                    mbi[k].dct_type = 1; /* field DCT */
                        }
                        else
                              mbi[k].dct_type = 1; /* field DCT */
                  }
                  k++;
            }
}

Generated by  Doxygen 1.6.0   Back to index