workbench/classes/datatypes/mpegvideo/mpegutil.c

   1
   2 /*
   3 **
   4 **  $VER: mpegutil.c 1.11 (1.11.97)
   5 **  mpegvideo.datatype 1.11
   6 **
   7 **  mpeg utility functions
   8 **
   9 **  Written 1996/1997 by Roland 'Gizzy' Mainz
  10 **
  11 */
  12
  13 #ifndef DEBUG
  14 #   define DEBUG 0
  15 #endif
  16 #include <aros/debug.h>
  17
  18 /* ansi includes */
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <limits.h>
  22
  23 /* project includes */
  24 #include "mpegvideo.h"
  25 #include "mpegproto.h"
  26 #include "mpegutil.h"
  27
  28 /* Bit masks used by bit i/o operations. */
  29 const
  30 ULONG nBitMask[] =
  31 {
  32     0x00000000, 0x80000000, 0xc0000000, 0xe0000000,
  33     0xf0000000, 0xf8000000, 0xfc000000, 0xfe000000,
  34     0xff000000, 0xff800000, 0xffc00000, 0xffe00000,
  35     0xfff00000, 0xfff80000, 0xfffc0000, 0xfffe0000,
  36     0xffff0000, 0xffff8000, 0xffffc000, 0xffffe000,
  37     0xfffff000, 0xfffff800, 0xfffffc00, 0xfffffe00,
  38     0xffffff00, 0xffffff80, 0xffffffc0, 0xffffffe0,
  39     0xfffffff0, 0xfffffff8, 0xfffffffc, 0xfffffffe,
  40     0xffffffff
  41 };
  42
  43
  44 const
  45 ULONG bitMask[] =
  46 {
  47     0xffffffff, 0x7fffffff, 0x3fffffff, 0x1fffffff,
  48     0x0fffffff, 0x07ffffff, 0x03ffffff, 0x01ffffff,
  49     0x00ffffff, 0x007fffff, 0x003fffff, 0x001fffff,
  50     0x000fffff, 0x0007ffff, 0x0003ffff, 0x0001ffff,
  51     0x0000ffff, 0x00007fff, 0x00003fff, 0x00001fff,
  52     0x00000fff, 0x000007ff, 0x000003ff, 0x000001ff,
  53     0x000000ff, 0x0000007f, 0x0000003f, 0x0000001f,
  54     0x0000000f, 0x00000007, 0x00000003, 0x00000001,
  55     0x00000000
  56 };
  57
  58
  59 const
  60 ULONG rBitMask[] =
  61 {
  62     0xffffffff, 0xfffffffe, 0xfffffffc, 0xfffffff8,
  63     0xfffffff0, 0xffffffe0, 0xffffffc0, 0xffffff80,
  64     0xffffff00, 0xfffffe00, 0xfffffc00, 0xfffff800,
  65     0xfffff000, 0xffffe000, 0xffffc000, 0xffff8000,
  66     0xffff0000, 0xfffe0000, 0xfffc0000, 0xfff80000,
  67     0xfff00000, 0xffe00000, 0xffc00000, 0xff800000,
  68     0xff000000, 0xfe000000, 0xfc000000, 0xf8000000,
  69     0xf0000000, 0xe0000000, 0xc0000000, 0x80000000,
  70     0x00000000
  71 };
  72
  73
  74 const
  75 ULONG bitTest[] =
  76 {
  77     0x80000000, 0x40000000, 0x20000000, 0x10000000,
  78     0x08000000, 0x04000000, 0x02000000, 0x01000000,
  79     0x00800000, 0x00400000, 0x00200000, 0x00100000,
  80     0x00080000, 0x00040000, 0x00020000, 0x00010000,
  81     0x00008000, 0x00004000, 0x00002000, 0x00001000,
  82     0x00000800, 0x00000400, 0x00000200, 0x00000100,
  83     0x00000080, 0x00000040, 0x00000020, 0x00000010,
  84     0x00000008, 0x00000004, 0x00000002, 0x00000001,
  85     0x00000000
  86 };
  87
  88
  89 /*
  90  *--------------------------------------------------------------
  91  *
  92  * correct_underflow --
  93  *
  94  *    Called when buffer does not have sufficient data to
  95  *      satisfy request for bits.
  96  *      Calls get_more_data, an application specific routine
  97  *      required to fill the buffer with more data.
  98  *
  99  * Results:
 100  *      None really.
 101  *
 102  * Side effects:
 103  *    buf_length and buffer fields in curVidStream structure
 104  *      may be changed.
 105  *
 106  *--------------------------------------------------------------
 107  */
 108
 109
 110 void correct_underflow( struct MPEGVideoInstData *mvid )
 111 {
 112     int status;
 113
 114     D(bug("[mpegvideo.datatype] %s()\n", __PRETTY_FUNCTION__));
 115
 116     status = get_more_data( mvid, (curVidStream -> buf_start), (curVidStream -> max_buf_length), (int *)(&bufLength), (unsigned int **)(&bitBuffer) );
 117
 118     if( status < 0 )
 119     {
 120       error_printf( mvid, "Unexpected read error (status = %x).\n", status);
 121
 122       myexit( mvid, RETURN_ERROR, ERROR_SEEK_ERROR );
 123     }
 124     else
 125     {
 126       if( (status == 0) && (bufLength < 1) )
 127       {
 128         error_printf( mvid, "\nImproper or missing sequence end code. Done ! (status=%x, bufLength = %d)\n", status, bufLength );
 129
 130         myexit( mvid, RETURN_WARN, ERROR_SEEK_ERROR );
 131       }
 132     }
 133
 134     curBits = *bitBuffer << bitOffset;
 135 }
 136
 137
 138 /*
 139  *--------------------------------------------------------------
 140  *
 141  * next_bits --
 142  *
 143  *    Compares next num bits to low order position in mask.
 144  *      Buffer pointer is NOT advanced.
 145  *
 146  * Results:
 147  *    TRUE, FALSE, or error code.
 148  *
 149  * Side effects:
 150  *    None.
 151  *
 152  *--------------------------------------------------------------
 153  */
 154
 155
 156 int next_bits( struct MPEGVideoInstData *mvid, int num, unsigned int mask )
 157 {
 158     unsigned int stream;
 159
 160     /* Get next num bits, no buffer pointer advance. */
 161     show_bitsn( num, stream );
 162
 163     /* Compare bit stream and mask. Set return value to TRUE if equal, FALSE if differs. */
 164     return( (int)(mask == stream) );
 165 }
 166
 167
 168 /*
 169  *--------------------------------------------------------------
 170  *
 171  * get_ext_data --
 172  *
 173  *    Assumes that bit stream is at begining of extension
 174  *      data. Parses off extension data into dynamically
 175  *      allocated space until start code is hit.
 176  *
 177  * Results:
 178  *    Pointer to dynamically allocated memory containing
 179  *      extension data.
 180  *
 181  * Side effects:
 182  *    Bit stream irreversibly parsed.
 183  *
 184  *--------------------------------------------------------------
 185  */
 186
 187
 188 char *get_ext_data( struct MPEGVideoInstData *mvid )
 189 {
 190     int           size,
 191                   marker;
 192     char         *dataPtr;
 193     unsigned int  data;
 194
 195     D(bug("[mpegvideo.datatype] %s()\n", __PRETTY_FUNCTION__));
 196
 197     /* Set initial ext data buffer size. */
 198     size = EXT_BUF_SIZE;
 199
 200     /* Allocate ext data buffer. */
 201     dataPtr = (char *)mymalloc( mvid, size );
 202
 203     /* Initialize marker to keep place in ext data buffer. */
 204     marker = 0;
 205
 206     /* While next data is not start code... */
 207     while( !next_bits( mvid, 24, 0x000001 ) )
 208     {
 209       /* Get next byte of ext data. */
 210       get_bits8( data );
 211
 212       /* Put ext data into ext data buffer. Advance marker. */
 213       dataPtr[ marker ] = (char)data;
 214       marker++;
 215
 216       /* If end of ext data buffer reached, resize data buffer. */
 217       if( marker == size )
 218       {
 219         size += EXT_BUF_SIZE;
 220         dataPtr = (char *)myrealloc( mvid, dataPtr, size );
 221       }
 222     }
 223
 224     /* Realloc data buffer to free any extra space. */
 225     dataPtr = (char *)myrealloc( mvid, dataPtr, marker );
 226
 227     /* Return pointer to ext data buffer. */
 228     return( dataPtr );
 229 }
 230
 231
 232 /*
 233  *--------------------------------------------------------------
 234  *
 235  * next_start_code --
 236  *
 237  *    Parses off bitstream until start code reached. When done
 238  *      next 4 bytes of bitstream will be start code. Bit offset
 239  *      reset to 0.
 240  *
 241  * Results:
 242  *    Status code.
 243  *
 244  * Side effects:
 245  *    Bit stream irreversibly parsed.
 246  *
 247  *--------------------------------------------------------------
 248  */
 249
 250
 251 int next_start_code( struct MPEGVideoInstData *mvid )
 252 {
 253   int          byteoff;
 254   unsigned int data;
 255   UWORD        state;
 256
 257     D(bug("[mpegvideo.datatype] %s()\n", __PRETTY_FUNCTION__));
 258
 259   /* If insufficient buffer length, correct underflow. */
 260   if( bufLength < SSP )
 261   {
 262     correct_underflow( mvid );
 263   }
 264
 265   /* If bit offset not zero, reset and advance buffer pointer. */
 266   byteoff = bitOffset % CHAR_BIT;
 267
 268   if( byteoff != 0 )
 269   {
 270     /* Align to byte boundary */
 271     flush_bits( (CHAR_BIT - byteoff) );
 272   }
 273
 274   /* Set state = 0U. */
 275   state = 0U;
 276
 277   /* While buffer has data ... */
 278   while( bufLength > 0 )
 279   {
 280     /* If insufficient data exists, correct underflow. */
 281     if( bufLength < SSP )
 282     {
 283       correct_underflow( mvid );
 284     }
 285
 286     /* If next byte is zero... */
 287     get_bits8( data );
 288
 289     if( data == 0 )
 290     {
 291       /* If state < 2U, advance state. */
 292       if( state < 2U )
 293       {
 294         state++;
 295       }
 296     }
 297     /* If next byte is one... */
 298     else
 299     {
 300       if( data == 1 )
 301       {
 302         /* If (state == 2U), advance state (state = 3U) (i.e. start code found),
 303          * otherwise, reset state to zero.
 304          */
 305         state = (state == 2U)?(3U):(0U);
 306       }
 307       else
 308       {
 309         /* Otherwise byte is neither 1 or 0, reset state to 0U. */
 310         state = 0U;
 311       }
 312     }
 313
 314     /* If state == 3U (i.e. start code found)... */
 315     if( state == 3U )
 316     {
 317       /* Set buffer pointer back and reset length & bit offsets so next bytes will be beginning of start code. */
 318       bitOffset = bitOffset - 24;
 319
 320       if( bitOffset < 0 )
 321       {
 322         bitOffset = 32 + bitOffset;
 323         bufLength++;
 324         bitBuffer--;
 325       }
 326
 327       curBits = *bitBuffer << bitOffset;
 328
 329       D(bug("[mpegvideo.datatype] %s: ok\n", __PRETTY_FUNCTION__));
 330       /* Return success. */
 331       return( OK );
 332     }
 333   }
 334
 335   D(bug("[mpegvideo.datatype] %s: underflow\n", __PRETTY_FUNCTION__));
 336   /* Return underflow error. */
 337   return( UNDERFLOW );
 338 }
 339
 340
 341 /*
 342  *--------------------------------------------------------------
 343  *
 344  * get_extra_bit_info --
 345  *
 346  *    Parses off extra bit info stream into dynamically
 347  *      allocated memory. Extra bit info is indicated by
 348  *      a flag bit set to 1, followed by 8 bits of data.
 349  *      This continues until the flag bit is zero. Assumes
 350  *      that bit stream set to first flag bit in extra
 351  *      bit info stream.
 352  *
 353  * Results:
 354  *    Pointer to dynamically allocated memory with extra
 355  *      bit info in it. Flag bits are NOT included.
 356  *
 357  * Side effects:
 358  *    Bit stream irreversibly parsed.
 359  *
 360  *--------------------------------------------------------------
 361  */
 362
 363
 364 char *get_extra_bit_info( struct MPEGVideoInstData *mvid )
 365 {
 366     int           size,
 367                   marker;
 368     char         *dataPtr;
 369     unsigned int  data;
 370
 371     D(bug("[mpegvideo.datatype] %s()\n", __PRETTY_FUNCTION__));
 372
 373     /* Get first flag bit. */
 374     get_bits1( data );
 375
 376     /* If flag is false, return NULL pointer (i.e. no extra bit info). */
 377     if( !data )
 378     {
 379       return( NULL );
 380     }
 381
 382     /* Initialize size of extra bit info buffer and allocate. */
 383     size    = EXT_BUF_SIZE;
 384     dataPtr = (char *)mymalloc( mvid, size );
 385
 386     /* Reset marker to hold place in buffer. */
 387     marker = 0;
 388
 389     /* While flag bit is true. */
 390     while( data )
 391     {
 392       /* Get next 8 bits of data. */
 393       get_bits8( data );
 394
 395       /* Place in extra bit info buffer. */
 396       dataPtr[ marker ] = (char)data;
 397       marker++;
 398
 399       /* If buffer is full, reallocate. */
 400       if( marker == size )
 401       {
 402         size += EXT_BUF_SIZE;
 403         dataPtr = (char *)myrealloc( mvid, dataPtr, size );
 404       }
 405
 406       /* Get next flag bit. */
 407       get_bits1( data );
 408     }
 409
 410     /* Reallocate buffer to free extra space. */
 411     dataPtr = (char *)myrealloc( mvid, dataPtr, marker );
 412
 413     /* Return pointer to extra bit info buffer. */
 414     return( dataPtr );
 415 }
 416
 417
 418 long stream_pos( struct MPEGVideoInstData *mvid )
 419 {
 420     return( (long)(((mvid -> mvid_ReadMarkPos) + ((UBYTE *)bitBuffer - (mvid -> mvid_ReadMark))) + (bitOffset / CHAR_BIT)) );
 421 }
 422