quicktime/encore50/mom_access.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_access.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 memory access for the Image, Vop and VolConfig 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_access.h"
  42
  43 /***********************************************************CommentBegin******
  44  *
  45  * -- GetImage{xxx} -- Access components of intermediate formats
  46  *
  47  *      Char *GetImageData(Image *image)
  48  *      UInt GetImageSize(Image *image)
  49  *      UInt GetImageSizeX(Image *image)
  50  *      UInt GetImageSizeY(Image *image)
  51  *      Int GetImageVersion(Image *image)
  52  *      ImageType GetImageType(Image *image)
  53  *
  54  * Purpose :
  55  *      These are common functions to access specific components
  56  *      of the common data structures which are used for the
  57  *      intermediate formats.
  58  *
  59  ***********************************************************CommentEnd********/
  60
  61 Char *
  62 GetImageData(Image *image)
  63 {
  64         switch(GetImageType(image))
  65         {
  66                 case SHORT_TYPE:
  67                         return((Char *)image->data->s);
  68                         break;
  69                 case FLOAT_TYPE:
  70                         return((Char *)image->data->f);
  71                         break;
  72                 case UCHAR_TYPE:
  73                         return((Char *)image->data->u);
  74                         break;
  75                 default:
  76                         printf("Image type >>%d<< not supported\n",image->type);
  77                         return(NULL);
  78         }
  79 }
  80
  81
  82 UInt
  83 GetImageSize(Image *image)
  84 {
  85         return(image->x * image->y);
  86 }
  87
  88
  89 UInt
  90 GetImageSizeX(Image *image)
  91 {
  92         return(image->x);
  93 }
  94
  95
  96 UInt
  97 GetImageSizeY(Image *image)
  98 {
  99         return(image->y);
 100 }
 101
 102
 103 Int
 104 GetImageVersion(Image *image)
 105 {
 106         return(image->version);
 107 }
 108
 109
 110 ImageType
 111 GetImageType(Image *image)
 112 {
 113         return(image->type);
 114 }
 115
 116
 117
 118 /***********************************************************CommentBegin******
 119  *
 120  * -- GetVop{xxx} -- Functions to access components of the Vop structure
 121  *
 122  * Purpose :
 123  *      These are common functions to access specific components
 124  *      of the Vop data structure.
 125  *
 126  ***********************************************************CommentEnd********/
 127
 128
 129 Int GetVopNot8Bit(Vop *vop)
 130 {
 131         return (vop->bits_per_pixel != 8);
 132 }
 133
 134
 135 Int GetVopQuantPrecision(Vop *vop)
 136 {
 137         return (vop->quant_precision);
 138 }
 139
 140
 141 Int GetVopBitsPerPixel(Vop *vop)
 142 {
 143         return (vop->bits_per_pixel);
 144 }
 145
 146
 147 Int GetVopMidGrey(Vop *vop)
 148 {
 149         return (1 << (vop->bits_per_pixel - 1));
 150 }
 151
 152
 153 Int GetVopBrightWhite(Vop *vop)
 154 {
 155         return ((1 << vop->bits_per_pixel) - 1);
 156 }
 157
 158
 159 Int GetVopTimeIncrementResolution(Vop *vop)
 160 {
 161         return (vop->time_increment_resolution);
 162 }
 163
 164
 165 Int
 166 GetVopModTimeBase(Vop *vop)
 167 {
 168         return(vop->mod_time_base);
 169 }
 170
 171
 172 Int
 173 GetVopTimeInc(Vop *vop)
 174 {
 175         return((int)vop->time_inc);
 176 }
 177
 178
 179 Int
 180 GetVopPredictionType(Vop *vop)
 181 {
 182         return(vop->prediction_type);
 183 }
 184
 185
 186 Int GetVopIntraDCVlcThr(Vop *vop)
 187 {
 188         return (vop->intra_dc_vlc_thr);
 189 }
 190
 191
 192 Int
 193 GetVopRoundingType(Vop *vop)
 194 {
 195         return(vop->rounding_type);
 196 }
 197
 198
 199 Int
 200 GetVopWidth(Vop *vop)
 201 {
 202         return(vop->width);
 203 }
 204
 205
 206 Int
 207 GetVopHeight(Vop *vop)
 208 {
 209         return(vop->height);
 210 }
 211
 212
 213 Int
 214 GetVopHorSpatRef(Vop *vop)
 215 {
 216         return(vop->hor_spat_ref);
 217 }
 218
 219
 220 Int
 221 GetVopVerSpatRef(Vop *vop)
 222 {
 223         return(vop->ver_spat_ref);
 224 }
 225
 226
 227 Int
 228 GetVopQuantizer(Vop *vop)
 229 {
 230         return(vop->quantizer);
 231 }
 232
 233
 234 Int
 235 GetVopIntraQuantizer(Vop *vop)
 236 {
 237         return(vop->intra_quantizer);
 238 }
 239
 240
 241 Int
 242 GetVopIntraACDCPredDisable(Vop *vop)
 243 {
 244         return(vop->intra_acdc_pred_disable);
 245 }
 246
 247
 248 Int
 249 GetVopFCodeFor(Vop *vop)
 250 {
 251         return(vop->fcode_for);
 252 }
 253
 254
 255 Int
 256 GetVopSearchRangeFor(Vop *vop)
 257 {
 258         return(vop->sr_for);
 259 }
 260
 261
 262 Image *
 263 GetVopY(Vop *vop)
 264 {
 265         return(vop->y_chan);
 266 }
 267
 268
 269 Image *
 270 GetVopU(Vop *vop)
 271 {
 272         return(vop->u_chan);
 273 }
 274
 275
 276 Image *
 277 GetVopV(Vop *vop)
 278 {
 279         return(vop->v_chan);
 280 }
 281
 282
 283 /***********************************************************CommentBegin******
 284  *
 285  * -- PutVop{xxx} -- Functions to write to components of the Vop structure
 286  *
 287  *      These are common functions to write to specific components
 288  *      of the Vop structure.
 289  *
 290  ***********************************************************CommentEnd********/
 291
 292
 293 Void PutVopQuantPrecision(Int quant_precision,Vop *vop)
 294 {
 295         vop->quant_precision = quant_precision;
 296 }
 297
 298
 299 Void PutVopBitsPerPixel(Int bits_per_pixel,Vop *vop)
 300 {
 301         vop->bits_per_pixel = bits_per_pixel;
 302 }
 303
 304
 305 Void PutVopTimeIncrementResolution(Int time_incre_res, Vop *vop)
 306 {
 307         vop->time_increment_resolution=time_incre_res;
 308 }
 309
 310
 311 Void
 312 PutVopModTimeBase(Int mod_time_base, Vop *vop)
 313 {
 314         vop->mod_time_base = mod_time_base;
 315 }
 316
 317
 318 Void
 319 PutVopTimeInc(Int time_inc, Vop *vop)
 320 {
 321         vop->time_inc = (float)time_inc;
 322 }
 323
 324
 325 Void
 326 PutVopPredictionType(Int prediction_type, Vop *vop)
 327 {
 328         vop->prediction_type = prediction_type;
 329 }
 330
 331
 332 Void PutVopIntraDCVlcThr(Int intra_dc_vlc_thr,Vop *vop)
 333 {
 334         vop->intra_dc_vlc_thr=intra_dc_vlc_thr;
 335 }
 336
 337
 338 Void
 339 PutVopRoundingType(Int rounding_type, Vop *vop)
 340 {
 341         vop->rounding_type = rounding_type;
 342 }
 343
 344
 345 Void
 346 PutVopWidth(Int width, Vop *vop)
 347 {
 348         vop->width = width;
 349 }
 350
 351
 352 Void
 353 PutVopHeight(Int height, Vop *vop)
 354 {
 355         vop->height = height;
 356 }
 357
 358
 359 Void
 360 PutVopHorSpatRef(Int hor_spat_ref, Vop *vop)
 361 {
 362         vop->hor_spat_ref = hor_spat_ref;
 363 }
 364
 365
 366 Void
 367 PutVopVerSpatRef(Int ver_spat_ref, Vop *vop)
 368 {
 369         vop->ver_spat_ref = ver_spat_ref;
 370 }
 371
 372
 373 Void
 374 PutVopQuantizer(Int quantizer, Vop *vop)
 375 {
 376         vop->quantizer = quantizer;
 377 }
 378
 379
 380 Void
 381 PutVopIntraACDCPredDisable(Int intra_acdc_pred_disable, Vop *vop)
 382 {
 383         vop->intra_acdc_pred_disable = intra_acdc_pred_disable;
 384 }
 385
 386
 387 Void
 388 PutVopFCodeFor(Int fcode_for, Vop *vop)
 389 {
 390         vop->fcode_for = fcode_for;
 391 }
 392
 393
 394 Void
 395 PutVopSearchRangeFor(Int sr_for, Vop *vop)
 396 {
 397         vop->sr_for = sr_for;
 398 }
 399
 400
 401 Void
 402 PutVopY(Image *y_chan, Vop *vop)
 403 {
 404         FreeImage(vop->y_chan);
 405         vop->y_chan = y_chan;
 406 }
 407
 408
 409 Void
 410 PutVopU(Image *u_chan, Vop *vop)
 411 {
 412         FreeImage(vop->u_chan);
 413         vop->u_chan = u_chan;
 414 }
 415
 416
 417 Void
 418 PutVopV(Image *v_chan, Vop *vop)
 419 {
 420         FreeImage(vop->v_chan);
 421         vop->v_chan = v_chan;
 422 }
 423
 424
 425 Void
 426 PutVopIntraQuantizer(Int Q,Vop *vop)
 427 {
 428         vop->intra_quantizer = Q;
 429 }
 430
 431
 432 /***********************************************************CommentBegin******
 433  *
 434  * -- PutVolConfigXXXX -- Access functions for VolConfig
 435  *
 436  * Purpose :
 437  *      To set particular fields in a VolConfig strcuture
 438  *
 439  ***********************************************************CommentEnd********/
 440
 441
 442 Void
 443 PutVolConfigFrameRate(Float fr, VolConfig *cfg)
 444 {
 445         cfg->frame_rate = fr;
 446 }
 447
 448
 449 Void
 450 PutVolConfigM(Int M, VolConfig *cfg)
 451 {
 452         cfg->M = M;
 453 }
 454
 455
 456 Void
 457 PutVolConfigStartFrame(Int frame, VolConfig *cfg)
 458 {
 459         cfg->start_frame = frame;
 460 }
 461
 462
 463 Void
 464 PutVolConfigEndFrame(Int frame, VolConfig *cfg)
 465 {
 466         cfg->end_frame = frame;
 467 }
 468
 469
 470 Void
 471 PutVolConfigBitrate(Int bit_rate,VolConfig *cfg)
 472 {
 473         cfg->bit_rate = bit_rate;
 474 }
 475
 476
 477 Void
 478 PutVolConfigIntraPeriod(Int ir,VolConfig *cfg)
 479 {
 480         cfg->intra_period = ir;
 481 }
 482
 483
 484 Void
 485 PutVolConfigQuantizer(Int Q,VolConfig *cfg)
 486 {
 487         cfg->quantizer = Q;
 488 }
 489
 490
 491 Void
 492 PutVolConfigIntraQuantizer(Int Q,VolConfig *cfg)
 493 {
 494         cfg->intra_quantizer = Q;
 495 }
 496
 497
 498 Void
 499 PutVolConfigFrameSkip(Int frame_skip,VolConfig *cfg)
 500 {
 501         cfg->frame_skip = frame_skip;
 502 }
 503
 504
 505 Void
 506 PutVolConfigModTimeBase(Int time,VolConfig *cfg)
 507 {
 508         cfg->modulo_time_base[0] = cfg->modulo_time_base[1];
 509         cfg->modulo_time_base[1] = time;
 510 }
 511
 512
 513 /***********************************************************CommentBegin******
 514  *
 515  * -- GetVolConfigXXXX -- Access functions for VolConfig
 516  *
 517  * Purpose :
 518  *      To obtain the value of particular fields in a VolConfig structure
 519  *
 520  ***********************************************************CommentEnd********/
 521
 522
 523 Float
 524 GetVolConfigFrameRate(VolConfig *cfg)
 525 {
 526         return(cfg->frame_rate);
 527 }
 528
 529
 530 Int
 531 GetVolConfigM(VolConfig *cfg)
 532 {
 533         return(cfg->M);
 534 }
 535
 536
 537 Int
 538 GetVolConfigStartFrame(VolConfig *cfg)
 539 {
 540         return(cfg->start_frame);
 541 }
 542
 543
 544 Int
 545 GetVolConfigEndFrame(VolConfig *cfg)
 546 {
 547         return(cfg->end_frame);
 548 }
 549
 550
 551 Int
 552 GetVolConfigBitrate(VolConfig *cfg)
 553 {
 554         return(cfg->bit_rate);
 555 }
 556
 557
 558 Int
 559 GetVolConfigIntraPeriod(VolConfig *cfg)
 560 {
 561         return(cfg->intra_period);
 562 }
 563
 564
 565 Int
 566 GetVolConfigQuantizer(VolConfig *cfg)
 567 {
 568         return(cfg->quantizer);
 569 }
 570
 571
 572 Int
 573 GetVolConfigIntraQuantizer(VolConfig *cfg)
 574 {
 575         return(cfg->intra_quantizer);
 576 }
 577
 578
 579 Int
 580 GetVolConfigFrameSkip(VolConfig *cfg)
 581 {
 582         return(cfg->frame_skip);
 583 }
 584
 585
 586 Int
 587 GetVolConfigModTimeBase(VolConfig *cfg,Int i)
 588 {
 589         return(cfg->modulo_time_base[i]);
 590 }
 591