libmpeg3/mpeg3protos.h

   1 #ifndef MPEG3PROTOS_H
   2 #define MPEG3PROTOS_H
   3
   4
   5 /* CSS */
   6
   7 mpeg3_css_t* mpeg3_new_css();
   8
   9
  10 /* Workarounds */
  11
  12 int64_t mpeg3io_tell_gcc(mpeg3_fs_t *fs);
  13 double mpeg3_add_double_gcc(double x, double y);
  14 double mpeg3_divide_double_gcc(double x, double y);
  15 int64_t mpeg3_total_bytes_gcc(mpeg3_title_t *title);
  16 int64_t mpeg3io_path_total_bytes(char *path);
  17 int64_t mpeg3io_get_total_bytes(mpeg3_fs_t *fs);
  18
  19
  20
  21
  22 /* TITLE */
  23
  24 mpeg3_title_t* mpeg3_new_title(mpeg3_t *file, char *path);
  25 void mpeg3_new_cell(mpeg3_title_t *title,
  26                 int64_t program_start,
  27                 int64_t program_end,
  28                 int64_t title_start,
  29                 int64_t title_end,
  30                 int program);
  31 /* Called by mpeg3_open for a single file */
  32 int mpeg3demux_create_title(mpeg3_demuxer_t *demuxer,
  33                 FILE *toc);
  34
  35
  36 /* ATRACK */
  37
  38 mpeg3_atrack_t* mpeg3_new_atrack(mpeg3_t *file,
  39         int custom_id,
  40         int is_ac3,
  41         mpeg3_demuxer_t *demuxer,
  42         int number);
  43 int mpeg3_delete_atrack(mpeg3_t *file, mpeg3_atrack_t *atrack);
  44
  45 void mpeg3_append_samples(mpeg3_atrack_t *atrack, int64_t offset);
  46
  47
  48 /* These return 1 on failure and 0 on success */
  49 int mpeg3_next_header();
  50
  51 /* VTRACK */
  52
  53 mpeg3_vtrack_t* mpeg3_new_vtrack(mpeg3_t *file,
  54         int custom_id,
  55         mpeg3_demuxer_t *demuxer,
  56         int number);
  57 int mpeg3_delete_vtrack(mpeg3_t *file, mpeg3_vtrack_t *vtrack);
  58
  59 void mpeg3_append_frame(mpeg3_vtrack_t *vtrack, int64_t offset, int is_keyframe);
  60
  61
  62 /* AUDIO */
  63 mpeg3audio_t* mpeg3audio_new(mpeg3_t *file,
  64         mpeg3_atrack_t *track,
  65         int is_ac3);
  66 int mpeg3audio_delete(mpeg3audio_t *audio);
  67
  68 /* Decode up to requested number of samples. */
  69 /* Return 0 on success and 1 on failure. */
  70 int mpeg3audio_decode_audio(mpeg3audio_t *audio,
  71         float *output_f,
  72         short *output_i,
  73         int channel,
  74         int len);
  75
  76 /* Shift the audio by the number of samples */
  77 /* Used by table of contents routines and decode_audio */
  78 void mpeg3_shift_audio(mpeg3audio_t *audio, int diff);
  79
  80
  81 /* Audio consists of many possible formats, each packetized into frames. */
  82 /* Each format has a constructor, header decoder, frame decoder, and destructor. */
  83 /* The function set is determined by the audio format. */
  84
  85 /* To decode audio, for each frame read the header sized number of bytes. */
  86 /* Call the header decoder for the format. */
  87 /* Call the frame decoder for the format. */
  88
  89 int mpeg3_new_decode_tables(mpeg3_layer_t *audio);
  90 int mpeg3_init_layer3(mpeg3_layer_t *audio);
  91 int mpeg3_init_layer2(mpeg3_layer_t *audio);
  92
  93 /* Create a new layer decoder */
  94 mpeg3_layer_t* mpeg3_new_layer();
  95
  96 /* Create a new ac3 decoder */
  97 mpeg3_ac3_t* mpeg3_new_ac3();
  98
  99 /* Create a new pcm decoder */
 100 mpeg3_pcm_t* mpeg3_new_pcm();
 101
 102
 103 /* Delete a new layer decoder */
 104 void mpeg3_delete_layer(mpeg3_layer_t *audio);
 105
 106 /* Delete a new ac3 decoder */
 107 void mpeg3_delete_ac3(mpeg3_ac3_t *audio);
 108
 109 /* Delete a new pcm decoder */
 110 void mpeg3_delete_pcm(mpeg3_pcm_t *audio);
 111
 112
 113 /* Return 1 if the data isn't a header */
 114 int mpeg3_layer_check(unsigned char *data);
 115 int mpeg3_ac3_check(unsigned char *header);
 116 int mpeg3_pcm_check(unsigned char *header);
 117
 118 /* These return the size of the next frame including the header */
 119 /* or 0 if it wasn't a header. */
 120 /* Decode a layer header */
 121 int mpeg3_layer_header(mpeg3_layer_t *audio, unsigned char *data);
 122
 123
 124 /* Decode an AC3 header */
 125 int mpeg3_ac3_header(mpeg3_ac3_t *audio, unsigned char *header);
 126
 127 /* Decode an PCM header */
 128 int mpeg3_pcm_header(mpeg3_pcm_t *audio, unsigned char *header);
 129
 130
 131 /* Reset after a seek */
 132 void mpeg3_layer_reset(mpeg3_layer_t *audio);
 133
 134 /* Decode a frame of layer 3 audio. */
 135 /* The output is linear, one buffer for every channel. */
 136 /* The user should get the channel count from one of the header commands */
 137 /* The output must be big enough to hold the largest frame of audio */
 138 /* These functions return the number of samples rendered */
 139 int mpeg3audio_dolayer3(mpeg3_layer_t *audio,
 140         char *frame,
 141         int frame_size,
 142         float **output,
 143         int render);
 144
 145 /* Decode a frame of layer 2 audio */
 146 int mpeg3audio_dolayer2(mpeg3_layer_t *audio,
 147         char *frame,
 148         int frame_size,
 149         float **output,
 150         int render);
 151
 152 /* Decode a frame of ac3 audio */
 153 int mpeg3audio_doac3(mpeg3_ac3_t *audio,
 154         char *frame,
 155         int frame_size,
 156         float **output,
 157         int render);
 158
 159
 160 /* Decode a frame of ac3 audio */
 161 int mpeg3audio_dopcm(mpeg3_pcm_t *audio,
 162         char *frame,
 163         int frame_size,
 164         float **output,
 165         int render);
 166
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176
 177
 178 /* VIDEO */
 179 mpeg3video_t* mpeg3video_new(mpeg3_t *file,
 180         mpeg3_vtrack_t *track);
 181 int mpeg3video_delete(mpeg3video_t *video);
 182 int mpeg3video_read_frame(mpeg3video_t *video,
 183                 int frame_number,
 184                 unsigned char **output_rows,
 185                 int in_x,
 186                 int in_y,
 187                 int in_w,
 188                 int in_h,
 189                 int out_w,
 190                 int out_h,
 191                 int color_model);
 192 void mpeg3video_dump(mpeg3video_t *video);
 193 int mpeg3video_prev_code(mpeg3_demuxer_t *demuxer, unsigned int code);
 194 int mpeg3video_next_code(mpeg3_bits_t* stream, unsigned int code);
 195 void mpeg3video_toc_error();
 196 int mpeg3_rewind_video(mpeg3video_t *video);
 197
 198
 199
 200 /* FILESYSTEM */
 201
 202 mpeg3_fs_t* mpeg3_new_fs(char *path);
 203 int mpeg3_delete_fs(mpeg3_fs_t *fs);
 204 int mpeg3io_open_file(mpeg3_fs_t *fs);
 205 int mpeg3io_close_file(mpeg3_fs_t *fs);
 206 int mpeg3io_seek(mpeg3_fs_t *fs, int64_t byte);
 207 int mpeg3io_seek_relative(mpeg3_fs_t *fs, int64_t bytes);
 208 int mpeg3io_read_data(unsigned char *buffer, int64_t bytes, mpeg3_fs_t *fs);
 209
 210
 211
 212
 213
 214
 215 /* MAIN */
 216 mpeg3_t* mpeg3_new(char *path);
 217 mpeg3_index_t* mpeg3_new_index();
 218 void mpeg3_delete_index(mpeg3_index_t *index);
 219 int mpeg3_delete(mpeg3_t *file);
 220 int mpeg3_get_file_type(mpeg3_t *file,
 221         mpeg3_t *old_file,
 222         int *toc_atracks,
 223         int *toc_vtracks);
 224
 225 int mpeg3_read_toc(mpeg3_t *file, int *atracks_return, int *vtracks_return);
 226
 227
 228
 229
 230
 231
 232
 233
 234
 235
 236
 237 /* DEMUXER */
 238
 239
 240
 241 mpeg3_demuxer_t* mpeg3_new_demuxer(mpeg3_t *file,
 242         int do_audio,
 243         int do_video,
 244         int custom_id);
 245 int mpeg3_delete_demuxer(mpeg3_demuxer_t *demuxer);
 246 mpeg3_demuxer_t* mpeg3_get_demuxer(mpeg3_t *file);
 247 int mpeg3demux_read_data(mpeg3_demuxer_t *demuxer,
 248         unsigned char *output,
 249         int size);
 250
 251 /* Append elementary stream data */
 252 /* Used by streaming mode. */
 253 void mpeg3demux_append_data(mpeg3_demuxer_t *demuxer,
 254         unsigned char *data,
 255 /* Bytes of data */
 256         int bytes);
 257
 258 /* Shift elementary data out */
 259 /* Used by streaming mode */
 260 void mpeg3demux_shift_data(mpeg3_demuxer_t *demuxer,
 261         int bytes);
 262
 263 /* Convert absolute byte position to position in program */
 264 int64_t mpeg3_absolute_to_program(mpeg3_demuxer_t *demuxer,
 265         int64_t absolute_byte);
 266
 267
 268 int mpeg3_read_next_packet(mpeg3_demuxer_t *demuxer);
 269 int mpeg3_read_prev_packet(mpeg3_demuxer_t *demuxer);
 270
 271
 272 unsigned int mpeg3demux_read_int32(mpeg3_demuxer_t *demuxer);
 273 unsigned int mpeg3demux_read_int24(mpeg3_demuxer_t *demuxer);
 274 unsigned int mpeg3demux_read_int16(mpeg3_demuxer_t *demuxer);
 275
 276
 277 /* Give total number of bytes in all titles which belong to the current program. */
 278 int64_t mpeg3demux_movie_size(mpeg3_demuxer_t *demuxer);
 279
 280 /* Give byte offset relative to start of movie */
 281 int64_t mpeg3demux_tell_byte(mpeg3_demuxer_t *demuxer);
 282
 283 /* Give program the current packet belongs to */
 284 int mpeg3demux_tell_program(mpeg3_demuxer_t *demuxer);
 285
 286 double mpeg3demux_get_time(mpeg3_demuxer_t *demuxer);
 287 int mpeg3demux_eof(mpeg3_demuxer_t *demuxer);
 288 int mpeg3demux_bof(mpeg3_demuxer_t *demuxer);
 289 void mpeg3demux_start_reverse(mpeg3_demuxer_t *demuxer);
 290 void mpeg3demux_start_forward(mpeg3_demuxer_t *demuxer);
 291 int mpeg3demux_open_title(mpeg3_demuxer_t *demuxer, int title_number);
 292 /* Go to the absolute byte given */
 293 int mpeg3demux_seek_byte(mpeg3_demuxer_t *demuxer, int64_t byte);
 294
 295 /* Seek to the title and cell containing the absolute byte of the
 296 /* demuxer. */
 297 /* Called at the beginning of every packet. */
 298 int mpeg3_seek_phys(mpeg3_demuxer_t *demuxer);
 299
 300 unsigned char mpeg3demux_read_char_packet(mpeg3_demuxer_t *demuxer);
 301 unsigned char mpeg3demux_read_prev_char_packet(mpeg3_demuxer_t *demuxer);
 302 int mpeg3demux_read_program(mpeg3_demuxer_t *demuxer);
 303
 304 /* Get last pts read */
 305 double mpeg3demux_audio_pts(mpeg3_demuxer_t *demuxer);
 306
 307 double mpeg3demux_video_pts(mpeg3_demuxer_t *demuxer);
 308
 309 /* Set the last pts read to -1 for audio and video */
 310 void mpeg3demux_reset_pts(mpeg3_demuxer_t *demuxer);
 311
 312 /* scan forward for next pts.  Used in byte seeking to synchronize */
 313 double mpeg3demux_scan_pts(mpeg3_demuxer_t *demuxer);
 314
 315 /* seek using sequential search to the pts given.  Used in byte seeking. */
 316 int mpeg3demux_goto_pts(mpeg3_demuxer_t *demuxer, double pts);
 317
 318
 319 unsigned char mpeg3demux_read_char_packet(mpeg3_demuxer_t *demuxer);
 320 unsigned char mpeg3demux_read_prev_char_packet(mpeg3_demuxer_t *demuxer);
 321
 322 #define mpeg3demux_error(demuxer) (((mpeg3_demuxer_t *)(demuxer))->error_flag)
 323
 324 static unsigned char mpeg3demux_read_char(mpeg3_demuxer_t *demuxer)
 325 {
 326 //printf("mpeg3demux_read_char %lx %lx\n", demuxer->data_position, demuxer->data_size);
 327         if(demuxer->data_position < demuxer->data_size)
 328         {
 329                 return demuxer->data_buffer[demuxer->data_position++];
 330         }
 331         else
 332         {
 333                 return mpeg3demux_read_char_packet(demuxer);
 334         }
 335 }
 336
 337
 338
 339 static unsigned char mpeg3demux_read_prev_char(mpeg3_demuxer_t *demuxer)
 340 {
 341         if(demuxer->data_position != 0)
 342         {
 343                 return demuxer->data_buffer[demuxer->data_position--];
 344         }
 345         else
 346         {
 347                 return mpeg3demux_read_prev_char_packet(demuxer);
 348         }
 349 }
 350
 351
 352
 353
 354
 355
 356
 357
 358
 359
 360
 361
 362
 363 // Bitstream
 364
 365 mpeg3_bits_t* mpeg3bits_new_stream(mpeg3_t *file, mpeg3_demuxer_t *demuxer);
 366 int mpeg3bits_delete_stream(mpeg3_bits_t* stream);
 367 int mpeg3bits_seek_byte(mpeg3_bits_t* stream, int64_t position);
 368 int mpeg3bits_open_title(mpeg3_bits_t* stream, int title);
 369 /* Give absolute byte offset in all titles. */
 370 int64_t mpeg3bits_tell(mpeg3_bits_t* stream);
 371 /* Reset bit bucket */
 372 void mpeg3bits_reset(mpeg3_bits_t *stream);
 373
 374
 375
 376
 377
 378
 379 #define mpeg3bits_error(stream) mpeg3demux_error((stream)->demuxer)
 380
 381 #define mpeg3bits_eof(stream) mpeg3demux_eof((stream)->demuxer)
 382
 383 #define mpeg3bits_bof(stream) mpeg3demux_bof((stream)->demuxer)
 384
 385 /* Read bytes backward from the file until the reverse_bits is full. */
 386 static void mpeg3bits_fill_reverse_bits(mpeg3_bits_t* stream, int bits)
 387 {
 388 // Right justify
 389         while(stream->bit_number > 7)
 390         {
 391                 stream->bfr >>= 8;
 392                 stream->bfr_size -= 8;
 393                 stream->bit_number -= 8;
 394         }
 395
 396 // Insert bytes before bfr_size
 397         while(stream->bfr_size - stream->bit_number < bits)
 398         {
 399                 if(stream->input_ptr)
 400                         stream->bfr |= (unsigned int)(*--stream->input_ptr) << stream->bfr_size;
 401                 else
 402                         stream->bfr |= (unsigned int)mpeg3demux_read_prev_char(stream->demuxer) << stream->bfr_size;
 403                 stream->bfr_size += 8;
 404         }
 405 }
 406
 407 /* Read bytes forward from the file until the forward_bits is full. */
 408 static void mpeg3bits_fill_bits(mpeg3_bits_t* stream, int bits)
 409 {
 410         while(stream->bit_number < bits)
 411         {
 412                 stream->bfr <<= 8;
 413                 if(stream->input_ptr)
 414                 {
 415                         stream->bfr |= *stream->input_ptr++;
 416                 }
 417                 else
 418                 {
 419                         stream->bfr |= mpeg3demux_read_char(stream->demuxer);
 420                 }
 421                 stream->bit_number += 8;
 422                 stream->bfr_size += 8;
 423                 if(stream->bfr_size > 32) stream->bfr_size = 32;
 424         }
 425 }
 426
 427 /* Return 8 bits, advancing the file position. */
 428 static unsigned int mpeg3bits_getbyte_noptr(mpeg3_bits_t* stream)
 429 {
 430         if(stream->bit_number < 8)
 431         {
 432                 stream->bfr <<= 8;
 433                 if(stream->input_ptr)
 434                         stream->bfr |= *stream->input_ptr++;
 435                 else
 436                         stream->bfr |= mpeg3demux_read_char(stream->demuxer);
 437
 438                 stream->bfr_size += 8;
 439                 if(stream->bfr_size > 32) stream->bfr_size = 32;
 440
 441                 return (stream->bfr >> stream->bit_number) & 0xff;
 442         }
 443         return (stream->bfr >> (stream->bit_number -= 8)) & 0xff;
 444 }
 445
 446 static unsigned int mpeg3bits_getbit_noptr(mpeg3_bits_t* stream)
 447 {
 448         if(!stream->bit_number)
 449         {
 450                 stream->bfr <<= 8;
 451                 stream->bfr |= mpeg3demux_read_char(stream->demuxer);
 452
 453                 stream->bfr_size += 8;
 454                 if(stream->bfr_size > 32) stream->bfr_size = 32;
 455
 456                 stream->bit_number = 7;
 457
 458                 return (stream->bfr >> 7) & 0x1;
 459         }
 460         return (stream->bfr >> (--stream->bit_number)) & (0x1);
 461 }
 462
 463 /* Return n number of bits, advancing the file position. */
 464 /* Use in place of flushbits */
 465 static unsigned int mpeg3bits_getbits(mpeg3_bits_t* stream, int bits)
 466 {
 467         if(bits <= 0) return 0;
 468         mpeg3bits_fill_bits(stream, bits);
 469         return (stream->bfr >> (stream->bit_number -= bits)) & (0xffffffff >> (32 - bits));
 470 }
 471
 472 static unsigned int mpeg3bits_showbits24_noptr(mpeg3_bits_t* stream)
 473 {
 474         while(stream->bit_number < 24)
 475         {
 476                 stream->bfr <<= 8;
 477                 stream->bfr |= mpeg3demux_read_char(stream->demuxer);
 478                 stream->bit_number += 8;
 479                 stream->bfr_size += 8;
 480                 if(stream->bfr_size > 32) stream->bfr_size = 32;
 481         }
 482         return (stream->bfr >> (stream->bit_number - 24)) & 0xffffff;
 483 }
 484
 485 static unsigned int mpeg3bits_showbits32_noptr(mpeg3_bits_t* stream)
 486 {
 487         while(stream->bit_number < 32)
 488         {
 489                 stream->bfr <<= 8;
 490                 stream->bfr |= mpeg3demux_read_char(stream->demuxer);
 491                 stream->bit_number += 8;
 492                 stream->bfr_size += 8;
 493                 if(stream->bfr_size > 32) stream->bfr_size = 32;
 494         }
 495         return stream->bfr;
 496 }
 497
 498 static unsigned int mpeg3bits_showbits(mpeg3_bits_t* stream, int bits)
 499 {
 500         mpeg3bits_fill_bits(stream, bits);
 501         return (stream->bfr >> (stream->bit_number - bits)) & (0xffffffff >> (32 - bits));
 502 }
 503
 504 static unsigned int mpeg3bits_getbits_reverse(mpeg3_bits_t* stream, int bits)
 505 {
 506         unsigned int result;
 507         mpeg3bits_fill_reverse_bits(stream, bits);
 508         result = (stream->bfr >> stream->bit_number) & (0xffffffff >> (32 - bits));
 509         stream->bit_number += bits;
 510         return result;
 511 }
 512
 513 static unsigned int mpeg3bits_showbits_reverse(mpeg3_bits_t* stream, int bits)
 514 {
 515         unsigned int result;
 516         mpeg3bits_fill_reverse_bits(stream, bits);
 517         result = (stream->bfr >> stream->bit_number) & (0xffffffff >> (32 - bits));
 518         return result;
 519 }
 520
 521
 522
 523
 524
 525
 526
 527
 528
 529 // I/O
 530 // I/O must be character based so the buffer doesn't get overrun
 531
 532
 533
 534
 535
 536
 537
 538 void mpeg3io_read_buffer(mpeg3_fs_t *fs);
 539
 540 #define mpeg3io_tell(fs) (((mpeg3_fs_t *)(fs))->current_byte)
 541
 542 // End of file
 543 #define mpeg3io_eof(fs) (((mpeg3_fs_t *)(fs))->current_byte >= ((mpeg3_fs_t *)(fs))->total_bytes)
 544
 545 // Beginning of file
 546 #define mpeg3io_bof(fs) (((mpeg3_fs_t *)(fs))->current_byte < 0)
 547
 548 #define mpeg3io_get_fd(fs) (fileno(((mpeg3_fs_t *)(fs))->fd))
 549
 550 #define mpeg3io_total_bytes(fs) (((mpeg3_fs_t *)(fs))->total_bytes)
 551
 552 static int mpeg3io_sync_buffer(mpeg3_fs_t *fs)
 553 {
 554 // Reposition buffer offset
 555         if(fs->buffer_position + fs->buffer_offset != fs->current_byte)
 556         {
 557                 fs->buffer_offset = fs->current_byte - fs->buffer_position;
 558         }
 559
 560 // Load new buffer
 561         if(fs->current_byte < fs->buffer_position ||
 562                 fs->current_byte >= fs->buffer_position + fs->buffer_size)
 563         {
 564                 mpeg3io_read_buffer(fs);
 565         }
 566
 567         return !fs->buffer_size;
 568 }
 569
 570 static unsigned int mpeg3io_read_char(mpeg3_fs_t *fs)
 571 {
 572         unsigned int result;
 573         mpeg3io_sync_buffer(fs);
 574         result = fs->buffer[fs->buffer_offset++];
 575         fs->current_byte++;
 576         return result;
 577 }
 578
 579 static unsigned char mpeg3io_next_char(mpeg3_fs_t *fs)
 580 {
 581         unsigned char result;
 582         mpeg3io_sync_buffer(fs);
 583         result = fs->buffer[fs->buffer_offset];
 584         return result;
 585 }
 586
 587 static uint32_t mpeg3io_read_int32(mpeg3_fs_t *fs)
 588 {
 589         int a, b, c, d;
 590         uint32_t result;
 591 /* Do not fread.  This breaks byte ordering. */
 592         a = mpeg3io_read_char(fs);
 593         b = mpeg3io_read_char(fs);
 594         c = mpeg3io_read_char(fs);
 595         d = mpeg3io_read_char(fs);
 596         result = (a << 24) |
 597                                         (b << 16) |
 598                                         (c << 8) |
 599                                         (d);
 600         return result;
 601 }
 602
 603 static uint32_t mpeg3io_read_int24(mpeg3_fs_t *fs)
 604 {
 605         int b, c, d;
 606         uint32_t result;
 607 /* Do not fread.  This breaks byte ordering. */
 608         b = mpeg3io_read_char(fs);
 609         c = mpeg3io_read_char(fs);
 610         d = mpeg3io_read_char(fs);
 611         result = (b << 16) |
 612                                         (c << 8) |
 613                                         (d);
 614         return result;
 615 }
 616
 617 static uint16_t mpeg3io_read_int16(mpeg3_fs_t *fs)
 618 {
 619         int c, d;
 620         uint16_t result;
 621 /* Do not fread.  This breaks byte ordering. */
 622         c = mpeg3io_read_char(fs);
 623         d = mpeg3io_read_char(fs);
 624         result = (c << 8) |
 625                                         (d);
 626         return result;
 627 }
 628
 629
 630
 631
 632
 633
 634
 635
 636
 637 // More bitstream
 638
 639
 640
 641
 642
 643
 644
 645
 646
 647 #define mpeg3slice_fillbits(buffer, nbits) \
 648         while(((mpeg3_slice_buffer_t*)(buffer))->bits_size < (nbits)) \
 649         { \
 650                 if(((mpeg3_slice_buffer_t*)(buffer))->current_position < ((mpeg3_slice_buffer_t*)(buffer))->buffer_size) \
 651                 { \
 652                         ((mpeg3_slice_buffer_t*)(buffer))->bits <<= 8; \
 653                         ((mpeg3_slice_buffer_t*)(buffer))->bits |= ((mpeg3_slice_buffer_t*)(buffer))->data[((mpeg3_slice_buffer_t*)(buffer))->current_position++]; \
 654                 } \
 655                 ((mpeg3_slice_buffer_t*)(buffer))->bits_size += 8; \
 656         }
 657
 658 #define mpeg3slice_flushbits(buffer, nbits) \
 659         { \
 660                 mpeg3slice_fillbits((buffer), (nbits)); \
 661                 ((mpeg3_slice_buffer_t*)(buffer))->bits_size -= (nbits); \
 662         }
 663
 664 #define mpeg3slice_flushbit(buffer) \
 665 { \
 666         if(((mpeg3_slice_buffer_t*)(buffer))->bits_size) \
 667                 ((mpeg3_slice_buffer_t*)(buffer))->bits_size--; \
 668         else \
 669         if(((mpeg3_slice_buffer_t*)(buffer))->current_position < ((mpeg3_slice_buffer_t*)(buffer))->buffer_size) \
 670         { \
 671                 ((mpeg3_slice_buffer_t*)(buffer))->bits = \
 672                         ((mpeg3_slice_buffer_t*)(buffer))->data[((mpeg3_slice_buffer_t*)(buffer))->current_position++]; \
 673                 ((mpeg3_slice_buffer_t*)(buffer))->bits_size = 7; \
 674         } \
 675 }
 676
 677 static unsigned int mpeg3slice_getbit(mpeg3_slice_buffer_t *buffer)
 678 {
 679         if(buffer->bits_size)
 680                 return (buffer->bits >> (--buffer->bits_size)) & 0x1;
 681         else
 682         if(buffer->current_position < buffer->buffer_size)
 683         {
 684                 buffer->bits = buffer->data[buffer->current_position++];
 685                 buffer->bits_size = 7;
 686                 return (buffer->bits >> 7) & 0x1;
 687         }
 688         return 0;
 689 }
 690
 691
 692 static unsigned int mpeg3slice_getbits2(mpeg3_slice_buffer_t *buffer)
 693 {
 694         if(buffer->bits_size >= 2)
 695                 return (buffer->bits >> (buffer->bits_size -= 2)) & 0x3;
 696         else
 697         if(buffer->current_position < buffer->buffer_size)
 698         {
 699                 buffer->bits <<= 8;
 700                 buffer->bits |= buffer->data[buffer->current_position++];
 701                 buffer->bits_size += 6;
 702                 return (buffer->bits >> buffer->bits_size)  & 0x3;
 703         }
 704         return 0;
 705 }
 706
 707 static unsigned int mpeg3slice_getbyte(mpeg3_slice_buffer_t *buffer)
 708 {
 709         if(buffer->bits_size >= 8)
 710                 return (buffer->bits >> (buffer->bits_size -= 8)) & 0xff;
 711         else
 712         if(buffer->current_position < buffer->buffer_size)
 713         {
 714                 buffer->bits <<= 8;
 715                 buffer->bits |= buffer->data[buffer->current_position++];
 716                 return (buffer->bits >> buffer->bits_size) & 0xff;
 717         }
 718         return 0;
 719 }
 720
 721
 722 static unsigned int mpeg3slice_getbits(mpeg3_slice_buffer_t *slice_buffer, int bits)
 723 {
 724         if(bits == 1) return mpeg3slice_getbit(slice_buffer);
 725         mpeg3slice_fillbits(slice_buffer, bits);
 726         return (slice_buffer->bits >> (slice_buffer->bits_size -= bits)) & (0xffffffff >> (32 - bits));
 727 }
 728
 729 static unsigned int mpeg3slice_showbits16(mpeg3_slice_buffer_t *buffer)
 730 {
 731         if(buffer->bits_size >= 16)
 732                 return (buffer->bits >> (buffer->bits_size - 16)) & 0xffff;
 733         else
 734         if(buffer->current_position < buffer->buffer_size)
 735         {
 736                 buffer->bits <<= 16;
 737                 buffer->bits_size += 16;
 738                 buffer->bits |= (unsigned int)buffer->data[buffer->current_position++] << 8;
 739                 buffer->bits |= buffer->data[buffer->current_position++];
 740                 return (buffer->bits >> (buffer->bits_size - 16)) & 0xffff;
 741         }
 742         return 0;
 743 }
 744
 745 static unsigned int mpeg3slice_showbits9(mpeg3_slice_buffer_t *buffer)
 746 {
 747         if(buffer->bits_size >= 9)
 748                 return (buffer->bits >> (buffer->bits_size - 9)) & 0x1ff;
 749         else
 750         if(buffer->current_position < buffer->buffer_size)
 751         {
 752                 buffer->bits <<= 16;
 753                 buffer->bits_size += 16;
 754                 buffer->bits |= (unsigned int)buffer->data[buffer->current_position++] << 8;
 755                 buffer->bits |= buffer->data[buffer->current_position++];
 756                 return (buffer->bits >> (buffer->bits_size - 9)) & 0x1ff;
 757         }
 758         return 0;
 759 }
 760
 761 static unsigned int mpeg3slice_showbits5(mpeg3_slice_buffer_t *buffer)
 762 {
 763         if(buffer->bits_size >= 5)
 764                 return (buffer->bits >> (buffer->bits_size - 5)) & 0x1f;
 765         else
 766         if(buffer->current_position < buffer->buffer_size)
 767         {
 768                 buffer->bits <<= 8;
 769                 buffer->bits_size += 8;
 770                 buffer->bits |= buffer->data[buffer->current_position++];
 771                 return (buffer->bits >> (buffer->bits_size - 5)) & 0x1f;
 772         }
 773         return 0;
 774 }
 775
 776 static unsigned int mpeg3slice_showbits(mpeg3_slice_buffer_t *slice_buffer, int bits)
 777 {
 778         mpeg3slice_fillbits(slice_buffer, bits);
 779         return (slice_buffer->bits >> (slice_buffer->bits_size - bits)) & (0xffffffff >> (32 - bits));
 780 }
 781
 782
 783
 784
 785
 786
 787 #endif