src/gdcmmpeg2/src/mpeg2enc/transfrm.c

   1 /* transfrm.c,  forward / inverse transformation                            */
   2
   3 /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
   4
   5 /*
   6  * Disclaimer of Warranty
   7  *
   8  * These software programs are available to the user without any license fee or
   9  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  10  * any and all warranties, whether express, implied, or statuary, including any
  11  * implied warranties or merchantability or of fitness for a particular
  12  * purpose.  In no event shall the copyright-holder be liable for any
  13  * incidental, punitive, or consequential damages of any kind whatsoever
  14  * arising from the use of these programs.
  15  *
  16  * This disclaimer of warranty extends to the user of these programs and user's
  17  * customers, employees, agents, transferees, successors, and assigns.
  18  *
  19  * The MPEG Software Simulation Group does not represent or warrant that the
  20  * programs furnished hereunder are free of infringement of any third-party
  21  * patents.
  22  *
  23  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  24  * are subject to royalty fees to patent holders.  Many of these patents are
  25  * general enough such that they are unavoidable regardless of implementation
  26  * design.
  27  *
  28  */
  29
  30 #include <stdio.h>
  31 #include <math.h>
  32 #include "config.h"
  33 #include "global.h"
  34
  35 /* private prototypes*/
  36 static void add_pred _ANSI_ARGS_((unsigned char *pred, unsigned char *cur,
  37   int lx, short *blk));
  38 static void sub_pred _ANSI_ARGS_((unsigned char *pred, unsigned char *cur,
  39   int lx, short *blk));
  40
  41 /* subtract prediction and transform prediction error */
  42 void transform(pred,cur,mbi,blocks)
  43 unsigned char *pred[], *cur[];
  44 struct mbinfo *mbi;
  45 short blocks[][64];
  46 {
  47   int i, j, i1, j1, k, n, cc, offs, lx;
  48
  49   k = 0;
  50
  51   for (j=0; j<height2; j+=16)
  52     for (i=0; i<width; i+=16)
  53     {
  54       for (n=0; n<block_count; n++)
  55       {
  56         cc = (n<4) ? 0 : (n&1)+1; /* color component index */
  57         if (cc==0)
  58         {
  59           /* luminance */
  60           if ((pict_struct==FRAME_PICTURE) && mbi[k].dct_type)
  61           {
  62             /* field DCT */
  63             offs = i + ((n&1)<<3) + width*(j+((n&2)>>1));
  64             lx = width<<1;
  65           }
  66           else
  67           {
  68             /* frame DCT */
  69             offs = i + ((n&1)<<3) + width2*(j+((n&2)<<2));
  70             lx = width2;
  71           }
  72
  73           if (pict_struct==BOTTOM_FIELD)
  74             offs += width;
  75         }
  76         else
  77         {
  78           /* chrominance */
  79
  80           /* scale coordinates */
  81           i1 = (chroma_format==CHROMA444) ? i : i>>1;
  82           j1 = (chroma_format!=CHROMA420) ? j : j>>1;
  83
  84           if ((pict_struct==FRAME_PICTURE) && mbi[k].dct_type
  85               && (chroma_format!=CHROMA420))
  86           {
  87             /* field DCT */
  88             offs = i1 + (n&8) + chrom_width*(j1+((n&2)>>1));
  89             lx = chrom_width<<1;
  90           }
  91           else
  92           {
  93             /* frame DCT */
  94             offs = i1 + (n&8) + chrom_width2*(j1+((n&2)<<2));
  95             lx = chrom_width2;
  96           }
  97
  98           if (pict_struct==BOTTOM_FIELD)
  99             offs += chrom_width;
 100         }
 101
 102         sub_pred(pred[cc]+offs,cur[cc]+offs,lx,blocks[k*block_count+n]);
 103         fdct(blocks[k*block_count+n]);
 104       }
 105
 106       k++;
 107     }
 108 }
 109
 110 /* inverse transform prediction error and add prediction */
 111 void itransform(pred,cur,mbi,blocks)
 112 unsigned char *pred[],*cur[];
 113 struct mbinfo *mbi;
 114 short blocks[][64];
 115 {
 116   int i, j, i1, j1, k, n, cc, offs, lx;
 117
 118   k = 0;
 119
 120   for (j=0; j<height2; j+=16)
 121     for (i=0; i<width; i+=16)
 122     {
 123       for (n=0; n<block_count; n++)
 124       {
 125         cc = (n<4) ? 0 : (n&1)+1; /* color component index */
 126
 127         if (cc==0)
 128         {
 129           /* luminance */
 130           if ((pict_struct==FRAME_PICTURE) && mbi[k].dct_type)
 131           {
 132             /* field DCT */
 133             offs = i + ((n&1)<<3) + width*(j+((n&2)>>1));
 134             lx = width<<1;
 135           }
 136           else
 137           {
 138             /* frame DCT */
 139             offs = i + ((n&1)<<3) + width2*(j+((n&2)<<2));
 140             lx = width2;
 141           }
 142
 143           if (pict_struct==BOTTOM_FIELD)
 144             offs += width;
 145         }
 146         else
 147         {
 148           /* chrominance */
 149
 150           /* scale coordinates */
 151           i1 = (chroma_format==CHROMA444) ? i : i>>1;
 152           j1 = (chroma_format!=CHROMA420) ? j : j>>1;
 153
 154           if ((pict_struct==FRAME_PICTURE) && mbi[k].dct_type
 155               && (chroma_format!=CHROMA420))
 156           {
 157             /* field DCT */
 158             offs = i1 + (n&8) + chrom_width*(j1+((n&2)>>1));
 159             lx = chrom_width<<1;
 160           }
 161           else
 162           {
 163             /* frame DCT */
 164             offs = i1 + (n&8) + chrom_width2*(j1+((n&2)<<2));
 165             lx = chrom_width2;
 166           }
 167
 168           if (pict_struct==BOTTOM_FIELD)
 169             offs += chrom_width;
 170         }
 171
 172         idct(blocks[k*block_count+n]);
 173         add_pred(pred[cc]+offs,cur[cc]+offs,lx,blocks[k*block_count+n]);
 174       }
 175
 176       k++;
 177     }
 178 }
 179
 180 /* add prediction and prediction error, saturate to 0...255 */
 181 static void add_pred(pred,cur,lx,blk)
 182 unsigned char *pred, *cur;
 183 int lx;
 184 short *blk;
 185 {
 186   int i, j;
 187
 188   for (j=0; j<8; j++)
 189   {
 190     for (i=0; i<8; i++)
 191       cur[i] = clp[blk[i] + pred[i]];
 192     blk+= 8;
 193     cur+= lx;
 194     pred+= lx;
 195   }
 196 }
 197
 198 /* subtract prediction from block data */
 199 static void sub_pred(pred,cur,lx,blk)
 200 unsigned char *pred, *cur;
 201 int lx;
 202 short *blk;
 203 {
 204   int i, j;
 205
 206   for (j=0; j<8; j++)
 207   {
 208     for (i=0; i<8; i++)
 209       blk[i] = cur[i] - pred[i];
 210     blk+= 8;
 211     cur+= lx;
 212     pred+= lx;
 213   }
 214 }
 215
 216 /*
 217  * select between frame and field DCT
 218  *
 219  * preliminary version: based on inter-field correlation
 220  */
 221 void dct_type_estimation(pred,cur,mbi)
 222 unsigned char *pred,*cur;
 223 struct mbinfo *mbi;
 224 {
 225   short blk0[128], blk1[128];
 226   int i, j, i0, j0, k, offs, s0, s1, sq0, sq1, s01;
 227   double d, r;
 228
 229   k = 0;
 230
 231   for (j0=0; j0<height2; j0+=16)
 232     for (i0=0; i0<width; i0+=16)
 233     {
 234       if (frame_pred_dct || pict_struct!=FRAME_PICTURE)
 235         mbi[k].dct_type = 0;
 236       else
 237       {
 238         /* interlaced frame picture */
 239         /*
 240          * calculate prediction error (cur-pred) for top (blk0)
 241          * and bottom field (blk1)
 242          */
 243         for (j=0; j<8; j++)
 244         {
 245           offs = width*((j<<1)+j0) + i0;
 246           for (i=0; i<16; i++)
 247           {
 248             blk0[16*j+i] = cur[offs] - pred[offs];
 249             blk1[16*j+i] = cur[offs+width] - pred[offs+width];
 250             offs++;
 251           }
 252         }
 253         /* correlate fields */
 254         s0=s1=sq0=sq1=s01=0;
 255
 256         for (i=0; i<128; i++)
 257         {
 258           s0+= blk0[i];
 259           sq0+= blk0[i]*blk0[i];
 260           s1+= blk1[i];
 261           sq1+= blk1[i]*blk1[i];
 262           s01+= blk0[i]*blk1[i];
 263         }
 264
 265         d = (sq0-(s0*s0)/128.0)*(sq1-(s1*s1)/128.0);
 266
 267         if (d>0.0)
 268         {
 269           r = (s01-(s0*s1)/128.0)/sqrt(d);
 270           if (r>0.5)
 271             mbi[k].dct_type = 0; /* frame DCT */
 272           else
 273             mbi[k].dct_type = 1; /* field DCT */
 274         }
 275         else
 276           mbi[k].dct_type = 1; /* field DCT */
 277       }
 278       k++;
 279     }
 280 }