quicktime/encore50/mom_util.c

   1
   2 /**************************************************************************
   3  *                                                                        *
   4  * This code is developed by Adam Li.  This software is an                *
   5  * implementation of a part of one or more MPEG-4 Video tools as          *
   6  * specified in ISO/IEC 14496-2 standard.  Those intending to use this    *
   7  * software module in hardware or software products are advised that its  *
   8  * use may infringe existing patents or copyrights, and any such use      *
   9  * would be at such party's own risk.  The original developer of this     *
  10  * software module and his/her company, and subsequent editors and their  *
  11  * companies (including Project Mayo), will have no liability for use of  *
  12  * this software or modifications or derivatives thereof.                 *
  13  *                                                                        *
  14  * Project Mayo gives users of the Codec a license to this software       *
  15  * module or modifications thereof for use in hardware or software        *
  16  * products claiming conformance to the MPEG-4 Video Standard as          *
  17  * described in the Open DivX license.                                    *
  18  *                                                                        *
  19  * The complete Open DivX license can be found at                         *
  20  * http://www.projectmayo.com/opendivx/license.php .                      *
  21  *                                                                        *
  22  **************************************************************************/
  23
  24 /**************************************************************************
  25  *
  26  *  mom_util.c
  27  *
  28  *  Copyright (C) 2001  Project Mayo
  29  *
  30  *  Adam Li
  31  *
  32  *  DivX Advance Research Center <darc@projectmayo.com>
  33  *
  34  **************************************************************************/
  35
  36 /* This file contains some utility functions to manipulate Image data     */
  37 /* structures.                                                            */
  38 /* Some codes of this project come from MoMuSys MPEG-4 implementation.    */
  39 /* Please see seperate acknowledgement file for a list of contributors.   */
  40
  41 #include "mom_util.h"
  42
  43 /* private prototypes */
  44 Char *emalloc(Int n);
  45 Char *ecalloc(Int n, Int s);
  46 Char *erealloc(Char *p, Int n);
  47 Void CopyImageI(ImageI *image_in, ImageI *image_out);
  48 Void CopyImageF(ImageF *image_in, ImageF *image_out);
  49 Void SetConstantImageI(ImageI *image, SInt val);
  50 Void SetConstantImageF(ImageF *image, Float val);
  51 Void SubImageI(ImageI *image_in1, ImageI *image_in2, ImageI *image_out);
  52 Void SubImageF(ImageF *image_in1, ImageF *image_in2, ImageF *image_out);
  53
  54
  55 /* The following is the Image maintance functions. */
  56
  57 /***********************************************************CommentBegin******
  58  *
  59  * -- AllocImage -- Allocates memory for an Image structure
  60  *
  61  * Purpose :
  62  *      Allocates memory for an Image structure, including memory
  63  *      for the actual image pixels. The image pixels can be of type
  64  *      UChar, SInt or Float depending on the parameter type.
  65  *
  66  * Return values :
  67  *      A pointer to the allocated Image structure.
  68  *
  69  * Description :
  70  *      Allocates memory for the Image if possible, otherwise a
  71  *      memory allocation error is signalled and the program will
  72  *      exit.
  73  *
  74  ***********************************************************CommentEnd********/
  75
  76 Image *
  77 AllocImage(UInt size_x, UInt size_y, ImageType type)
  78 {
  79   Image *image;
  80
  81   image = (Image *) emalloc(sizeof(Image));
  82
  83   image->version = VERSION;
  84   image->x = size_x;
  85   image->y = size_y;
  86   image->upperodd = 0;
  87   image->grid = 's';
  88   image->type = type;
  89   image->data = (ImageData *) emalloc(sizeof(ImageData));
  90
  91   switch(type)
  92     {
  93     case SHORT_TYPE:
  94       image->data->s = (SInt *) ecalloc(size_x*size_y,sizeof(SInt));
  95       break;
  96
  97     case FLOAT_TYPE:
  98       image->data->f = (Float *) ecalloc(size_x*size_y,sizeof(Float));
  99       break;
 100
 101     case UCHAR_TYPE:
 102       image->data->u = (UChar *) ecalloc(size_x*size_y,sizeof(UChar));
 103       break;
 104     }
 105
 106   image->f = image->data->s;    /* For compatibility with KHOROS */
 107
 108   return(image);
 109 }
 110
 111
 112 /***********************************************************CommentBegin******
 113  *
 114  * -- FreeImage -- Frees up all the memory associated with an Image structure
 115  *
 116  * Purpose :
 117  *      Frees up all the memory associated with an Image structure
 118  *
 119  ***********************************************************CommentEnd********/
 120
 121 Void
 122 FreeImage(Image *image)
 123 {
 124   SInt  *ps;
 125   Float *pf;
 126   UChar         *pu;
 127
 128   if (image == NULL) return;
 129
 130   switch(image->type)
 131     {
 132     case SHORT_TYPE:
 133       ps = (SInt *)GetImageData(image);
 134       if(ps != NULL) free((Char *)ps);
 135       free((Char *) image->data);
 136       free((Char *)image);
 137       break;
 138
 139     case FLOAT_TYPE:
 140       pf = (Float *)GetImageData(image);
 141       if(pf != NULL) free((Char *)pf);
 142       free((Char *) image->data);
 143       free((Char *)image);
 144       break;
 145
 146     case UCHAR_TYPE:
 147       pu = (UChar *)GetImageData(image);
 148       if(pu != NULL) free((Char *)pu);
 149       free((Char *) image->data);
 150       free((Char *)image);
 151       break;
 152     }
 153 }
 154
 155
 156 /***********************************************************CommentBegin******
 157  *
 158  * -- CopyImage -- Copies the pixel values of one image to another image
 159  *
 160  * Purpose :
 161  *      Copies the pixel values of one image to another image.
 162  *
 163  * Description :
 164  *      Currently, the function exits with an error if
 165  *      the source and destination images are not of the same allocated
 166  *      size and type.
 167  *
 168  *      Also, the images of type UChar are not yet supported.
 169  *
 170  ***********************************************************CommentEnd********/
 171
 172 Void
 173 CopyImage(Image *image_in, Image *image_out)
 174 {
 175   switch(image_out->type)
 176     {
 177     case SHORT_TYPE:
 178       CopyImageI(image_in,image_out);
 179       break;
 180
 181     case FLOAT_TYPE:
 182       CopyImageF(image_in,image_out);
 183       break;
 184
 185     }
 186 }
 187
 188
 189 /***********************************************************CommentBegin******
 190  *
 191  * -- CopyImageI --
 192  *
 193  ***********************************************************CommentEnd********/
 194
 195 Void
 196 CopyImageI(ImageI *image_in, ImageI *image_out)
 197 {
 198   SInt  *p_in  = image_in->data->s,
 199                 *p_out = image_out->data->s,
 200                 *p_end;
 201
 202   UInt  sx_in  = image_in->x,
 203                 sx_out = image_out->x,
 204                 sy_in  = image_in->y,
 205                 sy_out = image_out->y,
 206                 sxy_in = sx_in * sy_in;
 207
 208   p_end = p_in + sxy_in;
 209
 210   while (p_in != p_end)
 211     {
 212       *p_out = *p_in;
 213       p_in++;
 214       p_out++;
 215     }
 216
 217 }
 218
 219
 220 /***********************************************************CommentBegin******
 221  *
 222  * -- CopyImageF -- Copies image_in to image_out
 223  *
 224  ***********************************************************CommentEnd********/
 225
 226 Void
 227 CopyImageF(ImageF *image_in, ImageF *image_out)
 228 {
 229   Float *p_in  = image_in->data->f,
 230                 *p_out = image_out->data->f,
 231                 *p_end;
 232
 233   UInt  sx_in = image_in->x,
 234                 sx_out = image_out->x,
 235                 sy_in = image_in->y,
 236                 sy_out = image_out->y,
 237                 sxy_in = sx_in * sy_in;
 238
 239   p_end = p_in + sxy_in;
 240
 241   while (p_in != p_end)
 242     {
 243       *p_out = *p_in;
 244       p_in++;
 245       p_out++;
 246     }
 247
 248 }
 249
 250
 251 /***********************************************************CommentBegin******
 252  *
 253  * -- SetConstantImage -- Sets each pixel in the Image to val
 254  *
 255  * Purpose :
 256  *      Sets each pixel in the Image to val.
 257  *
 258  * Side effects :
 259  *      Note val is a Float. If image is not a Float image then
 260  *      val is cast to the appropriate type i.e. SInt, unsigned
 261  *      Char.
 262  *
 263  * Description :
 264  *      Images of type UChar are not yet supported.
 265  *
 266  ***********************************************************CommentEnd********/
 267
 268 Void
 269 SetConstantImage(Image *image, Float val)
 270 {
 271   switch(image->type)
 272     {
 273     case SHORT_TYPE:
 274       SetConstantImageI(image,(SInt)val);
 275       break;
 276
 277     case FLOAT_TYPE:
 278       SetConstantImageF(image,val);
 279       break;
 280     }
 281 }
 282
 283
 284
 285 /***********************************************************CommentBegin******
 286  *
 287  * -- SetConstantImageI --
 288  *
 289  ***********************************************************CommentEnd********/
 290
 291 Void
 292 SetConstantImageI(ImageI *image, SInt val)
 293 {
 294   SInt  *p  = image->data->s,
 295         *p_end;
 296
 297   UInt  sxy = image->x * image->y;
 298
 299   if (val == 0)
 300           memset (p, 0, sxy * 2);
 301   else
 302   {
 303         p_end = p + sxy;
 304
 305         while (p != p_end)
 306         {
 307                 *p = val;
 308                 p++;
 309     }
 310   }
 311
 312 }
 313
 314 /***********************************************************CommentBegin******
 315  *
 316  * -- SetConstantImageF --
 317  *
 318  ***********************************************************CommentEnd********/
 319
 320 Void
 321 SetConstantImageF(ImageF *image, Float val)
 322 {
 323   Float         *p  = image->data->f,
 324             *p_end;
 325
 326   UInt  sxy = image->x * image->y;
 327
 328   p_end = p + sxy;
 329
 330   while (p != p_end)
 331     {
 332       *p = val;
 333       p++;
 334     }
 335
 336 }
 337
 338
 339 /***********************************************************CommentBegin******
 340  *
 341  * -- SubImage -- Subtracts two images
 342  *
 343  * Purpose :
 344  *      Subtracts two images and stores the result in the third
 345  *      i.e. image_out = image_in1 - image_in2
 346  *
 347  * Description :
 348  *      Currently, the function exits with an error if
 349  *      the source and destination images are not of the same allocated
 350  *      size and type.
 351  *
 352  *      Also, the images of type UChar are not yet supported.
 353  *
 354  ***********************************************************CommentEnd********/
 355
 356 Void
 357 SubImage(Image *image_in1, Image *image_in2, Image *image_out)
 358 {
 359   switch(image_in1->type)
 360     {
 361     case SHORT_TYPE:
 362       SubImageI(image_in1,image_in2,image_out);
 363       break;
 364
 365     case FLOAT_TYPE:
 366       SubImageF(image_in1,image_in2,image_out);
 367       break;
 368     }
 369 }
 370
 371 /***********************************************************CommentBegin******
 372  *
 373  * -- SubImageI --
 374  *
 375  ***********************************************************CommentEnd********/
 376
 377 Void
 378 SubImageI(ImageI *image_in1, ImageI *image_in2, ImageI *image_out)
 379 {
 380   SInt  *p  = image_out->data->s,
 381                 *p1 = image_in1->data->s,
 382                 *p2 = image_in2->data->s,
 383                 *p_end;
 384
 385   UInt  sx_in1 = image_in1->x,
 386                 sx_in2 = image_in2->x,
 387                 sx_out = image_out->x,
 388                 sy_in1 = image_in1->y,
 389                 sy_in2 = image_in2->y,
 390                 sy_out = image_out->y,
 391                 sxy    = sx_out * sy_out;
 392
 393   p_end = p + sxy;
 394
 395   while (p != p_end)
 396     {
 397       *p = *p1 - *p2;
 398       p++;
 399       p1++;
 400       p2++;
 401     }
 402
 403 }
 404
 405 /***********************************************************CommentBegin******
 406  *
 407  * -- SubImageF --
 408  *
 409  ***********************************************************CommentEnd********/
 410
 411 Void
 412 SubImageF(ImageF *image_in1, ImageF *image_in2, ImageF *image_out)
 413 {
 414   Float *p  = image_out->data->f,
 415                 *p1 = image_in1->data->f,
 416                 *p2 = image_in2->data->f,
 417                 *p_end;
 418
 419   UInt  sx_in1 = image_in1->x,
 420                 sx_in2 = image_in2->x,
 421                 sx_out = image_out->x,
 422                 sy_in1 = image_in1->y,
 423                 sy_in2 = image_in2->y,
 424                 sy_out = image_out->y,
 425                 sxy    = sx_out * sy_out;
 426
 427   p_end = p + sxy;
 428
 429   while (p != p_end)
 430     {
 431       *p = *p1 - *p2;
 432       p++;
 433       p1++;
 434       p2++;
 435     }
 436
 437 }
 438
 439 /* The following is Vop maintance functions. */
 440
 441 Vop *
 442 SallocVop()
 443 {
 444         Vop   *vop;
 445
 446         vop = (Vop *)ecalloc(1,sizeof(Vop));
 447
 448         return(vop);
 449 }
 450
 451
 452 Vop *
 453 AllocVop(UInt x, UInt y)
 454 {
 455   Vop           *vop;
 456
 457   Image *y_chan,
 458                 *u_chan,
 459                 *v_chan;
 460
 461   /* first allocate memory for the data structure */
 462   vop = SallocVop();
 463
 464   vop->width = x;
 465   vop->height = y;
 466
 467   /* Allocate image fields */
 468   y_chan = AllocImage(x,y,SHORT_TYPE);
 469   u_chan = AllocImage(x/2,y/2,SHORT_TYPE);
 470   v_chan = AllocImage(x/2,y/2,SHORT_TYPE);
 471
 472   /* Include image fields in structure */
 473   FreeImage(vop->y_chan);
 474   vop->y_chan = y_chan;
 475
 476   FreeImage(vop->u_chan);
 477   vop->u_chan = u_chan;
 478
 479   FreeImage(vop->v_chan);
 480   vop->v_chan = v_chan;
 481
 482   return(vop);
 483 }
 484
 485
 486 Void
 487 SfreeVop (Vop *vop)
 488 {
 489         free ((Char*)vop);
 490         /* vop = NULL; */
 491         return;
 492 }
 493
 494
 495 Void
 496 FreeVop(Vop *vop)
 497 {
 498   Image         *data=NULL; /*SpSc: added the initialization */
 499
 500   if(vop != NULL) {
 501
 502     /* Deallocate memory for image fields */
 503
 504     data = vop->y_chan;
 505     FreeImage(data);
 506
 507     data = vop->u_chan;
 508     FreeImage(data);
 509
 510     data = vop->v_chan;
 511     FreeImage(data);
 512
 513     SfreeVop(vop);
 514   }
 515
 516   return;
 517 }
 518
 519
 520 Void
 521 CopyVopNonImageField(Vop *in,Vop *out)
 522 {
 523 /*      out->quant_precision = in->quant_precision;
 524         out->bits_per_pixel = in->bits_per_pixel;
 525 */
 526 //      out->mod_time_base = in->mod_time_base;
 527 //      out->time_inc = in->time_inc;
 528         out->prediction_type = in->prediction_type;
 529 /*      out->rounding_type = in->rounding_type;
 530         out->width = in->width;
 531         out->height = in->height;
 532         out->hor_spat_ref = in->hor_spat_ref;
 533         out->ver_spat_ref = in->ver_spat_ref;
 534         out->quantizer = in->quantizer;
 535         out->intra_quantizer = in->intra_quantizer;
 536         out->time_increment_resolution = in->time_increment_resolution;
 537
 538         out->intra_acdc_pred_disable = in->intra_acdc_pred_disable;
 539         out->fcode_for = in->fcode_for;
 540         out->sr_for = in->sr_for;
 541
 542         out->intra_dc_vlc_thr = in->intra_dc_vlc_thr;
 543 */
 544 }
 545
 546
 547 /* The following is Memory allocation functions. */
 548
 549 /***********************************************************CommentBegin******
 550  *
 551  * -- emalloc -- Memory allocation with error handling
 552  *
 553  * Purpose :
 554  *      Memory allocation with error handling.
 555  *
 556  * Description :
 557  *      WARNING: There is a problem when you want to allocate more memory
 558  *      than size can handle.  Malloc gets as argument an unsigned.  It poses
 559  *      a problem when sizeof(unsigned) < sizeof(Char *)...
 560  *
 561  ***********************************************************CommentEnd********/
 562
 563 Char *
 564 emalloc(Int n)
 565 {
 566   Char  *p;
 567
 568   p = (Char *) malloc((UInt)n);
 569   return p;
 570 }
 571
 572 /***********************************************************CommentBegin******
 573  *
 574  * -- ecalloc -- Memory allocation with error handling
 575  *
 576  * Purpose :
 577  *      Memory allocation with error handling.
 578  *
 579  * Description :
 580  *      WARNING: There is a problem when you want to allocate more memory
 581  *      than size can handle.  Malloc gets as argument an unsigned.  It poses
 582  *      a problem when sizeof(unsigned) < sizeof(Char *)...
 583  *
 584  ***********************************************************CommentEnd********/
 585
 586 Char *
 587 ecalloc(Int n, Int s)
 588 {
 589   Char  *p;
 590
 591   p = (Char *) calloc((UInt)n,(UInt)s);
 592
 593   return p;
 594 }
 595
 596 /***********************************************************CommentBegin******
 597  *
 598  * -- erealloc -- Memory re-allocation with error handling.
 599  *
 600  * Purpose :
 601  *      Memory re-allocation with error handling
 602  *
 603  * Description :
 604  *      WARNING: There is a problem when you want to allocate more memory
 605  *      than size can handle.  Malloc gets as argument an unsigned.  It poses
 606  *      a problem when sizeof(unsigned) < sizeof(Char *)...
 607  *
 608  ***********************************************************CommentEnd********/
 609
 610 Char *
 611 erealloc(Char *p, Int n)
 612 {
 613   p = (Char *) realloc(p,(UInt)n);
 614   return p;
 615 }
 616
 617