filter.c

H.263的压缩算法

/************************************************************************
 *
 *  filter.c, filter routines of tmn (TMN encoder)
 *
 *  Copyright (C) 1997  University of BC, Canada
 *
 *  Contacts: 
 *  Michael Gallant                   <[e-mail]>
 *  Guy Cote                          <[e-mail]>
 *  Berna Erol                        <[e-mail]>
 *
 *  UBC Image Processing Laboratory   http://www.ee.ubc.ca/image
 *  2356 Main Mall                    tel.: [phone]
 *  Vancouver BC Canada V6T1Z4        fax.: [phone]
 *
 ************************************************************************/

/* Disclaimer of Warranty
 * 
 * These software programs are available to the user without any license fee
 * or royalty on an "as is" basis. The University of British Columbia
 * 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 University of British Columbia does not represent or warrant that the
 * programs furnished hereunder are free of infringement of any
 * third-party patents.
 * 
 * Commercial implementations of H.263, 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"sim.h"
static int STRENGTH[] = {1,1,2,2,3,3,4,4,4,5,5,6,6,7,7,7,8,8,8,9,9,9,10,10,10,11,11,11,12,12,12};
static int MQ_chroma_QP_table[32] = {0,1,2,3,4,5,6,6,7,8,9,9,10,10,11,11,12,12,12,13,13,13,14,14,14,14,14,15,15,15,15,15};


/**********************************************************************
 *
 *	Name:		EdgeFilter
 *	Description:    performs in the loop edge-filtering on
 *                      reconstructed frames (Deblocking Filter)
 *
 *	Input:	        pointers to reconstructed frame and difference
 *                      image
 *	Returns:
 *	Side effects:
 *
 *      Date: 970820    Author: [e-mail]
 *                              modified to implement annex J of H.263+
 *
 ***********************************************************************/


void EdgeFilter (PictImage * recon, Pict * pic)
{

  /* Luma */
  HorizEdgeFilter (recon->lum, pels, lines, pic, 0);
  VertEdgeFilter (recon->lum, pels, lines, pic, 0);

  /* Chroma */
  HorizEdgeFilter (recon->Cb, pels / 2, lines / 2, pic, 1);
  VertEdgeFilter (recon->Cb, pels / 2, lines / 2, pic, 1);
  HorizEdgeFilter (recon->Cr, pels / 2, lines / 2, pic, 1);
  VertEdgeFilter (recon->Cr, pels / 2, lines / 2, pic, 1);

  /* that's it */
  return;
}


/***********************************************************************/


void HorizEdgeFilter (unsigned char *rec, int width, int height, Pict * pic, int chr)
{
  int i, j;
  int delta, d1, d2;
  int mbc, mbr, do_filter;
  int QP;
  int bquant[] = {5, 6, 7, 8};
  int mbr_above;

  /* horizontal edges */
  for (j = 8; j < height; j += 8)
  {
    for (i = 0; i < width; i++)
    {
      if (!chr)
      {
        mbr = j >> 4;
        mbc = i >> 4;
        mbr_above = (j - 8) >> 4;
      } else
      {
        mbr = j >> 3;
        mbc = i >> 3;
        mbr_above = mbr - 1;
      }

      do_filter = coded_map[mbr + 1][mbc + 1] || coded_map[mbr_above + 1][mbc + 1];

      if (do_filter)
      {
        if (pic->PB)
        {
          QP = coded_map[mbr + 1][mbc + 1] ?
            mmin (31, bquant[pic->BQUANT] * quant_map[mbr + 1][mbc + 1] / 4) :
            mmin (31, bquant[pic->BQUANT] * quant_map[mbr_above + 1][mbc + 1] / 4);
        } else
          QP = coded_map[mbr + 1][mbc + 1] ? quant_map[mbr + 1][mbc + 1] : quant_map[mbr_above + 1][mbc + 1];

        if (modified_quantization && chr) 
        {
          QP=MQ_chroma_QP_table[QP];                   
        }
        delta = (int) (((int) (*(rec + i + (j - 2) * width)) +
                        (int) (*(rec + i + (j - 1) * width) * (-4)) +
                        (int) (*(rec + i + (j) * width) * (4)) +
                     (int) (*(rec + i + (j + 1) * width) * (-1))) / 8.0);

        d1 = sign (delta) * mmax (0, abs (delta) - mmax (0, 2 * (abs (delta) - STRENGTH[QP - 1])));

        d2 = mmin (abs (d1 / 2), mmax (-abs (d1 / 2), (int) (((*(rec + i + (j - 2) * width) -
                                   *(rec + i + (j + 1) * width))) / 4)));

        *(rec + i + (j + 1) * width) = (int) (*(rec + i + (j + 1) * width)) + d2;
        *(rec + i + (j) * width) =
          mmin (255, mmax (0, (int) (*(rec + i + (j) * width)) - d1));
        *(rec + i + (j - 1) * width) =
          mmin (255, mmax (0, (int) (*(rec + i + (j - 1) * width)) + d1));
        *(rec + i + (j - 2) * width) = (int) (*(rec + i + (j - 2) * width)) - d2;
      }
    }
  }
  return;
}

void VertEdgeFilter (unsigned char *rec, int width, int height, Pict * pic, int chr)
{
  int i, j;
  int delta, d1, d2;
  int mbc, mbr;
  int do_filter;
  int bquant[] = {5, 6, 7, 8};
  int QP;
  int mbc_left;

  /* vertical edges */
  for (i = 8; i < width; i += 8)
  {
    for (j = 0; j < height; j++)
    {
      if (!chr)
      {
        mbr = j >> 4;
        mbc = i >> 4;
        mbc_left = (i - 8) >> 4;
      } else
      {
        mbr = j >> 3;
        mbc = i >> 3;
        mbc_left = mbc - 1;
      }
      do_filter = coded_map[mbr + 1][mbc + 1] || coded_map[mbr + 1][mbc_left + 1];

      if (do_filter)
      {
        if (pic->PB)
        {
          QP = coded_map[mbr + 1][mbc + 1] ?
            mmin (31, bquant[pic->BQUANT] * quant_map[mbr + 1][mbc + 1] / 4) :
            mmin (31, bquant[pic->BQUANT] * quant_map[mbr + 1][mbc_left + 1] / 4);
        } else
          QP = coded_map[mbr + 1][mbc + 1] ? quant_map[mbr + 1][mbc + 1] : quant_map[mbr + 1][mbc_left + 1];

        if (modified_quantization && chr) 
        {
          QP=MQ_chroma_QP_table[QP];                   
        }
        delta = (int) (((int) (*(rec + i - 2 + j * width)) +
                        (int) (*(rec + i - 1 + j * width) * (-4)) +
                        (int) (*(rec + i + j * width) * (4)) +
                        (int) (*(rec + i + 1 + j * width) * (-1))) / 8.0);

        d1 = sign (delta) * mmax (0, abs (delta) - mmax (0, 2 * (abs (delta) - STRENGTH[QP - 1])));
        d2 = mmin (abs (d1 / 2), mmax (-abs (d1 / 2), (int) ((*(rec + i - 2 + j * width) -
                                      *(rec + i + 1 + j * width)) / 4)));

        *(rec + i + 1 + j * width) = (int) (*(rec + i + 1 + j * width)) + d2;
        *(rec + i + j * width) =
          mmin (255, mmax (0, (int) (*(rec + i + j * width)) - d1));
        *(rec + i - 1 + j * width) =
          mmin (255, mmax (0, (int) (*(rec + i - 1 + j * width)) + d1));
        *(rec + i - 2 + j * width) = (int) (*(rec + i - 2 + j * width)) - d2;
      }
    }
  }
  return;
}