libmpeg3/video/getpicture.c

   1 #include "mpeg3private.h"
   2 #include "mpeg3protos.h"
   3 #include "vlc.h"
   4
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8
   9 int mpeg3video_get_cbp(mpeg3_slice_t *slice)
  10 {
  11         int code;
  12         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
  13
  14         if((code = mpeg3slice_showbits9(slice_buffer)) >= 128)
  15         {
  16         code >>= 4;
  17         mpeg3slice_flushbits(slice_buffer, mpeg3_CBPtab0[code].len);
  18         return mpeg3_CBPtab0[code].val;
  19         }
  20
  21         if(code >= 8)
  22         {
  23         code >>= 1;
  24         mpeg3slice_flushbits(slice_buffer, mpeg3_CBPtab1[code].len);
  25         return mpeg3_CBPtab1[code].val;
  26         }
  27
  28         if(code < 1)
  29         {
  30 /*      fprintf(stderr,"mpeg3video_get_cbp: invalid coded_block_pattern code\n"); */
  31         slice->fault = 1;
  32         return 0;
  33         }
  34
  35         mpeg3slice_flushbits(slice_buffer, mpeg3_CBPtab2[code].len);
  36         return mpeg3_CBPtab2[code].val;
  37 }
  38
  39
  40 /* set block to zero */
  41 int mpeg3video_clearblock(mpeg3_slice_t *slice, int comp, int size)
  42 {
  43         slice->sparse[comp] = 1;
  44
  45 /* Compiler error with 2.95 required hard coding the size to 6 */
  46
  47         bzero(slice->block[comp], sizeof(short) * 64 * size);
  48 //      memset(slice->block[comp], 0, sizeof(short) * 64 * size);
  49         return 0;
  50 }
  51
  52 static inline int mpeg3video_getdclum(mpeg3_slice_buffer_t *slice_buffer)
  53 {
  54         int code, size, val;
  55 /* decode length */
  56         code = mpeg3slice_showbits5(slice_buffer);
  57
  58         if(code < 31)
  59         {
  60         size = mpeg3_DClumtab0[code].val;
  61         mpeg3slice_flushbits(slice_buffer, mpeg3_DClumtab0[code].len);
  62         }
  63         else
  64         {
  65         code = mpeg3slice_showbits9(slice_buffer) - 0x1f0;
  66         size = mpeg3_DClumtab1[code].val;
  67         mpeg3slice_flushbits(slice_buffer, mpeg3_DClumtab1[code].len);
  68         }
  69
  70         if(size == 0) val = 0;
  71         else
  72         {
  73         val = mpeg3slice_getbits(slice_buffer, size);
  74         if((val & (1 << (size - 1))) == 0)  val -= (1 << size) - 1;
  75         }
  76
  77         return val;
  78 }
  79
  80
  81 int mpeg3video_getdcchrom(mpeg3_slice_buffer_t *slice_buffer)
  82 {
  83         int code, size, val;
  84
  85 /* decode length */
  86         code = mpeg3slice_showbits5(slice_buffer);
  87
  88         if(code < 31)
  89         {
  90         size = mpeg3_DCchromtab0[code].val;
  91         mpeg3slice_flushbits(slice_buffer, mpeg3_DCchromtab0[code].len);
  92         }
  93         else
  94         {
  95         code = mpeg3slice_showbits(slice_buffer, 10) - 0x3e0;
  96         size = mpeg3_DCchromtab1[code].val;
  97         mpeg3slice_flushbits(slice_buffer, mpeg3_DCchromtab1[code].len);
  98         }
  99
 100         if(size == 0) val = 0;
 101         else
 102         {
 103       val = mpeg3slice_getbits(slice_buffer, size);
 104       if((val & (1 << (size - 1))) == 0) val -= (1 << size) - 1;
 105         }
 106
 107         return val;
 108 }
 109
 110
 111 /* decode one intra coded MPEG-1 block */
 112
 113 int mpeg3video_getintrablock(mpeg3_slice_t *slice,
 114                 mpeg3video_t *video,
 115                 int comp,
 116                 int dc_dct_pred[])
 117 {
 118         int val, i, j = 8, sign;
 119         unsigned int code;
 120         mpeg3_DCTtab_t *tab = 0;
 121         short *bp = slice->block[comp];
 122         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
 123
 124 /* decode DC coefficients */
 125         if(comp < 4)
 126                 bp[0] = (dc_dct_pred[0] += mpeg3video_getdclum(slice_buffer)) << 3;
 127         else
 128         if(comp == 4)
 129                 bp[0] = (dc_dct_pred[1] += mpeg3video_getdcchrom(slice_buffer)) << 3;
 130         else
 131                 bp[0] = (dc_dct_pred[2] += mpeg3video_getdcchrom(slice_buffer)) << 3;
 132
 133         if(slice->fault) return 1;
 134
 135 /* decode AC coefficients */
 136         for(i = 1; ; i++)
 137         {
 138         code = mpeg3slice_showbits16(slice_buffer);
 139         if(code >= 16384)
 140                         tab = &mpeg3_DCTtabnext[(code >> 12) - 4];
 141         else
 142                 if(code >= 1024) tab = &mpeg3_DCTtab0[(code >> 8) - 4];
 143         else
 144                 if(code >= 512) tab = &mpeg3_DCTtab1[(code >> 6) - 8];
 145         else
 146                 if(code >= 256) tab = &mpeg3_DCTtab2[(code >> 4) - 16];
 147         else
 148                 if(code >= 128) tab = &mpeg3_DCTtab3[(code >> 3) - 16];
 149         else
 150                 if(code >= 64) tab = &mpeg3_DCTtab4[(code >> 2) - 16];
 151         else
 152                 if(code >= 32) tab = &mpeg3_DCTtab5[(code >> 1) - 16];
 153         else
 154                 if(code >= 16) tab = &mpeg3_DCTtab6[code - 16];
 155         else
 156                 {
 157 /*              fprintf(stderr, "mpeg3video_getintrablock: invalid Huffman code\n"); */
 158                 slice->fault = 1;
 159                 return 0;
 160         }
 161
 162         mpeg3slice_flushbits(slice_buffer, tab->len);
 163
 164         if(tab->run == 64) break;  /* end_of_block */
 165
 166         if(tab->run == 65)
 167                 {
 168 /* escape */
 169                 i += mpeg3slice_getbits(slice_buffer, 6);
 170
 171                 if((val = mpeg3slice_getbits(slice_buffer, 8)) == 0)
 172                                 val = mpeg3slice_getbits(slice_buffer, 8);
 173                 else
 174                         if(val == 128)
 175                                 val = mpeg3slice_getbits(slice_buffer, 8) - 256;
 176                 else
 177                         if(val > 128)
 178                                 val -= 256;
 179
 180                 if((sign = (val < 0)) != 0) val= -val;
 181         }
 182         else
 183                 {
 184                 i += tab->run;
 185                 val = tab->level;
 186                 sign = mpeg3slice_getbit(slice_buffer);
 187         }
 188
 189                 if(i < 64)
 190                 j = video->mpeg3_zigzag_scan_table[i];
 191                 else
 192                 {
 193                 slice->fault = 1;
 194                 return 0;
 195                 }
 196
 197
 198         val = (val * slice->quant_scale * video->intra_quantizer_matrix[j]) >> 3;
 199         val = (val - 1) | 1;
 200
 201         bp[j] = sign ? -val : val;
 202         }
 203
 204         if(j != 0)
 205         {
 206 /* not a sparse matrix ! */
 207        slice->sparse[comp] = 0;
 208         }
 209         return 0;
 210 }
 211
 212
 213 /* decode one non-intra coded MPEG-1 block */
 214
 215 int mpeg3video_getinterblock(mpeg3_slice_t *slice,
 216                 mpeg3video_t *video,
 217                 int comp)
 218 {
 219         int val, i, j, sign;
 220         unsigned int code;
 221         mpeg3_DCTtab_t *tab;
 222         short *bp = slice->block[comp];
 223         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
 224
 225 /* decode AC coefficients */
 226         for(i = 0; ; i++)
 227         {
 228         code = mpeg3slice_showbits16(slice_buffer);
 229         if(code >= 16384)
 230                 {
 231             if(i == 0)
 232                                 tab = &mpeg3_DCTtabfirst[(code >> 12) - 4];
 233             else
 234                                 tab = &mpeg3_DCTtabnext[(code >> 12) - 4];
 235         }
 236         else
 237                 if(code >= 1024) tab = &mpeg3_DCTtab0[(code >> 8) - 4];
 238         else
 239                 if(code >= 512)  tab = &mpeg3_DCTtab1[(code >> 6) - 8];
 240         else
 241                 if(code >= 256)  tab = &mpeg3_DCTtab2[(code >> 4) - 16];
 242         else
 243                 if(code >= 128)  tab = &mpeg3_DCTtab3[(code >> 3) - 16];
 244         else
 245                 if(code >= 64)   tab = &mpeg3_DCTtab4[(code >> 2) - 16];
 246         else
 247                 if(code >= 32)   tab = &mpeg3_DCTtab5[(code >> 1) - 16];
 248         else
 249                 if(code >= 16)   tab = &mpeg3_DCTtab6[code - 16];
 250         else
 251                 {
 252 // invalid Huffman code
 253                 slice->fault = 1;
 254                 return 1;
 255         }
 256
 257         mpeg3slice_flushbits(slice_buffer, tab->len);
 258
 259 /* end of block */
 260         if(tab->run == 64)
 261            break;
 262
 263         if(tab->run == 65)
 264                 {
 265 /* escape  */
 266                 i += mpeg3slice_getbits(slice_buffer, 6);
 267                 if((val = mpeg3slice_getbits(slice_buffer, 8)) == 0)
 268                                 val = mpeg3slice_getbits(slice_buffer, 8);
 269                 else
 270                         if(val == 128)
 271                                 val = mpeg3slice_getbits(slice_buffer, 8) - 256;
 272                 else
 273                         if(val > 128)
 274                                 val -= 256;
 275
 276                 if((sign = (val < 0)) != 0) val = -val;
 277         }
 278         else
 279                 {
 280                 i += tab->run;
 281                 val = tab->level;
 282                 sign = mpeg3slice_getbit(slice_buffer);
 283         }
 284
 285         j = video->mpeg3_zigzag_scan_table[i];
 286
 287                 val = (((val << 1)+1) * slice->quant_scale * video->non_intra_quantizer_matrix[j]) >> 4;
 288                 val = (val - 1) | 1;
 289
 290         bp[j] = sign ? -val : val;
 291         }
 292
 293         if(j != 0)
 294         {
 295 /* not a sparse matrix ! */
 296        slice->sparse[comp] = 0;
 297         }
 298         return 0;
 299 }
 300
 301
 302 /* decode one intra coded MPEG-2 block */
 303 int mpeg3video_getmpg2intrablock(mpeg3_slice_t *slice,
 304                 mpeg3video_t *video,
 305                 int comp,
 306                 int dc_dct_pred[])
 307 {
 308         int val, i, j, sign, nc;
 309         unsigned int code;
 310         mpeg3_DCTtab_t *tab;
 311         short *bp;
 312         int *qmat;
 313         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
 314
 315 /* with data partitioning, data always goes to base layer */
 316         bp = slice->block[comp];
 317
 318         qmat = (comp < 4 || video->chroma_format == CHROMA420)
 319          ? video->intra_quantizer_matrix
 320          : video->chroma_intra_quantizer_matrix;
 321
 322 /* decode DC coefficients */
 323         if(comp < 4)
 324                 val = (dc_dct_pred[0] += mpeg3video_getdclum(slice_buffer));
 325         else
 326         if((comp & 1) == 0)
 327                 val = (dc_dct_pred[1] += mpeg3video_getdcchrom(slice_buffer));
 328         else
 329                 val = (dc_dct_pred[2] += mpeg3video_getdcchrom(slice_buffer));
 330
 331         if(slice->fault) return 0;
 332         bp[0] = val << (3 - video->dc_prec);
 333
 334         nc = 0;
 335
 336 /* decode AC coefficients */
 337         for(i = 1; ; i++)
 338         {
 339         code = mpeg3slice_showbits16(slice_buffer);
 340
 341         if(code >= 16384 && !video->intravlc)
 342                         tab = &mpeg3_DCTtabnext[(code >> 12) - 4];
 343         else
 344                 if(code >= 1024)
 345                 {
 346                 if(video->intravlc)
 347                                 tab = &mpeg3_DCTtab0a[(code >> 8) - 4];
 348                 else
 349                                 tab = &mpeg3_DCTtab0[(code >> 8) - 4];
 350         }
 351         else
 352                 if(code >= 512)
 353                 {
 354                 if(video->intravlc)
 355                                 tab = &mpeg3_DCTtab1a[(code >> 6) - 8];
 356                 else
 357                                 tab = &mpeg3_DCTtab1[(code >> 6) - 8];
 358         }
 359         else
 360                 if(code >= 256) tab = &mpeg3_DCTtab2[(code >> 4) - 16];
 361         else
 362                 if(code >= 128) tab = &mpeg3_DCTtab3[(code >> 3) - 16];
 363         else
 364                 if(code >= 64)  tab = &mpeg3_DCTtab4[(code >> 2) - 16];
 365         else
 366                 if(code >= 32)  tab = &mpeg3_DCTtab5[(code >> 1) - 16];
 367         else
 368                 if(code >= 16)  tab = &mpeg3_DCTtab6[code - 16];
 369         else
 370                 {
 371 /*              fprintf(stderr,"mpeg3video_getmpg2intrablock: invalid Huffman code\n"); */
 372                 slice->fault = 1;
 373                 return 1;
 374         }
 375
 376         mpeg3slice_flushbits(slice_buffer, tab->len);
 377
 378 /* end_of_block */
 379         if(tab->run == 64)
 380                 break;
 381
 382         if(tab->run == 65)
 383                 {
 384 /* escape */
 385                 i += mpeg3slice_getbits(slice_buffer, 6);
 386
 387                 val = mpeg3slice_getbits(slice_buffer, 12);
 388                 if((val & 2047) == 0)
 389                         {
 390 // invalid signed_level (escape)
 391                         slice->fault = 1;
 392                         return 0;
 393                 }
 394                 if((sign = (val >= 2048)) != 0) val = 4096 - val;
 395         }
 396         else
 397                 {
 398                 i += tab->run;
 399                 val = tab->level;
 400                 sign = mpeg3slice_getbit(slice_buffer);
 401         }
 402
 403         j = (video->altscan ? video->mpeg3_alternate_scan_table : video->mpeg3_zigzag_scan_table)[i];
 404
 405                 val = (val * slice->quant_scale * qmat[j]) >> 4;
 406
 407         bp[j] = sign ? -val : val;
 408         nc++;
 409         }
 410
 411         if(j != 0)
 412         {
 413 /* not a sparse matrix ! */
 414          slice->sparse[comp] = 0;
 415         }
 416         return 1;
 417 }
 418
 419
 420 /* decode one non-intra coded MPEG-2 block */
 421
 422 int mpeg3video_getmpg2interblock(mpeg3_slice_t *slice,
 423                 mpeg3video_t *video,
 424                 int comp)
 425 {
 426         int val, i, j, sign, nc;
 427         unsigned int code;
 428         mpeg3_DCTtab_t *tab;
 429         short *bp;
 430         int *qmat;
 431         mpeg3_slice_buffer_t *slice_buffer = slice->slice_buffer;
 432
 433 /* with data partitioning, data always goes to base layer */
 434         bp = slice->block[comp];
 435
 436         qmat = (comp < 4 || video->chroma_format == CHROMA420)
 437          ? video->non_intra_quantizer_matrix
 438          : video->chroma_non_intra_quantizer_matrix;
 439
 440         nc = 0;
 441
 442 /* decode AC coefficients */
 443         for(i = 0; ; i++)
 444         {
 445         code = mpeg3slice_showbits16(slice_buffer);
 446         if(code >= 16384)
 447                 {
 448           if(i == 0) tab = &mpeg3_DCTtabfirst[(code >> 12) - 4];
 449           else      tab = &mpeg3_DCTtabnext[(code >> 12) - 4];
 450         }
 451         else
 452                 if(code >= 1024) tab = &mpeg3_DCTtab0[(code >> 8) - 4];
 453         else
 454                 if(code >= 512)  tab = &mpeg3_DCTtab1[(code >> 6) - 8];
 455         else
 456                 if(code >= 256)  tab = &mpeg3_DCTtab2[(code >> 4) - 16];
 457         else
 458                 if(code >= 128)  tab = &mpeg3_DCTtab3[(code >> 3) - 16];
 459         else
 460                 if(code >= 64)   tab = &mpeg3_DCTtab4[(code >> 2) - 16];
 461         else
 462                 if(code >= 32)   tab = &mpeg3_DCTtab5[(code >> 1) - 16];
 463         else
 464                 if(code >= 16)   tab = &mpeg3_DCTtab6[code - 16];
 465         else
 466                 {
 467 // invalid Huffman code
 468                 slice->fault = 1;
 469                 return 0;
 470         }
 471
 472         mpeg3slice_flushbits(slice_buffer, tab->len);
 473
 474 /* end_of_block */
 475         if(tab->run == 64)
 476                 break;
 477
 478         if(tab->run == 65)
 479                 {
 480 /* escape */
 481                 i += mpeg3slice_getbits(slice_buffer, 6);
 482                 val = mpeg3slice_getbits(slice_buffer, 12);
 483                 if((val & 2047) == 0)
 484                         {
 485 /*                      fprintf(stderr, "mpeg3video_getmpg2interblock: invalid signed_level (escape)\n"); */
 486                         slice->fault = 1;
 487                         return 1;
 488                 }
 489                 if((sign = (val >= 2048)) != 0) val = 4096 - val;
 490         }
 491         else
 492                 {
 493                 i += tab->run;
 494                 val = tab->level;
 495                 sign = mpeg3slice_getbit(slice_buffer);
 496         }
 497
 498         j = (video->altscan ? video->mpeg3_alternate_scan_table : video->mpeg3_zigzag_scan_table)[i];
 499
 500                 val = (((val << 1)+1) * slice->quant_scale * qmat[j]) >> 5;
 501
 502         bp[j] = sign ? (-val) : val ;
 503         nc++;
 504         }
 505
 506         if(j != 0)
 507         {
 508         slice->sparse[comp] = 0;
 509         }
 510         return 0;
 511 }
 512
 513
 514 /* decode all macroblocks of the current picture */
 515 int mpeg3video_get_macroblocks(mpeg3video_t *video, int framenum)
 516 {
 517         unsigned int code;
 518         mpeg3_slice_buffer_t *slice_buffer; /* Buffer being loaded */
 519         int i;
 520         int current_buffer;
 521         mpeg3_bits_t *vstream = video->vstream;
 522
 523 /* Load every slice into a buffer array */
 524         video->total_slice_buffers = 0;
 525         current_buffer = 0;
 526
 527         while(!mpeg3bits_eof(vstream) &&
 528                 mpeg3bits_showbits32_noptr(vstream) >= MPEG3_SLICE_MIN_START &&
 529                 mpeg3bits_showbits32_noptr(vstream) <= MPEG3_SLICE_MAX_START &&
 530                 video->total_slice_buffers < MPEG3_MAX_CPUS)
 531         {
 532 /* Initialize the buffer */
 533                 if(current_buffer >= video->slice_buffers_initialized)
 534                         mpeg3_new_slice_buffer(&(video->slice_buffers[video->slice_buffers_initialized++]));
 535                 slice_buffer = &(video->slice_buffers[current_buffer]);
 536                 slice_buffer->buffer_size = 0;
 537                 slice_buffer->current_position = 0;
 538                 slice_buffer->bits_size = 0;
 539                 slice_buffer->done = 0;
 540
 541 /* Read the slice into the buffer including the slice start code */
 542                 do
 543                 {
 544 /* Expand buffer */
 545                         if(slice_buffer->buffer_allocation <= slice_buffer->buffer_size)
 546                                 mpeg3_expand_slice_buffer(slice_buffer);
 547
 548 /* Load 1 char into buffer */
 549                         slice_buffer->data[slice_buffer->buffer_size++] = mpeg3bits_getbyte_noptr(vstream);
 550                 }while(!mpeg3bits_eof(vstream) &&
 551                         mpeg3bits_showbits24_noptr(vstream) != MPEG3_PACKET_START_CODE_PREFIX);
 552
 553 /* Pad the buffer to get the last macroblock */
 554                 if(slice_buffer->buffer_allocation <= slice_buffer->buffer_size + 4)
 555                         mpeg3_expand_slice_buffer(slice_buffer);
 556
 557                 slice_buffer->data[slice_buffer->buffer_size++] = 0;
 558                 slice_buffer->data[slice_buffer->buffer_size++] = 0;
 559                 slice_buffer->data[slice_buffer->buffer_size++] = 1;
 560                 slice_buffer->data[slice_buffer->buffer_size++] = 0;
 561                 slice_buffer->bits_size = 0;
 562
 563                 pthread_mutex_lock(&(slice_buffer->completion_lock));
 564                 current_buffer++;
 565                 video->total_slice_buffers++;
 566         }
 567
 568
 569
 570 /* Run the slice decoders */
 571         if(video->total_slice_buffers > 0)
 572         {
 573                 for(i = 0; i < video->total_slice_decoders; i++)
 574                 {
 575                         if(i == 0 && video->total_slice_decoders > 1)
 576                         {
 577                                 video->slice_decoders[i].current_buffer = 0;
 578                                 video->slice_decoders[i].buffer_step = 1;
 579                                 video->slice_decoders[i].last_buffer = (video->total_slice_buffers - 1);
 580                         }
 581                         else
 582                         if(i == 1)
 583                         {
 584                                 video->slice_decoders[i].current_buffer = video->total_slice_buffers - 1;
 585                                 video->slice_decoders[i].buffer_step = -1;
 586                                 video->slice_decoders[i].last_buffer = 0;
 587                         }
 588                         else
 589                         {
 590                                 video->slice_decoders[i].current_buffer = i;
 591                                 video->slice_decoders[i].buffer_step = 1;
 592                                 video->slice_decoders[i].last_buffer = video->total_slice_buffers - 1;
 593                         }
 594                         pthread_mutex_unlock(&(video->slice_decoders[i].input_lock));
 595                 }
 596         }
 597
 598 /* Wait for the slice buffers to finish */
 599         if(video->total_slice_buffers > 0)
 600         {
 601                 for(i = 0; i < video->total_slice_buffers; i++)
 602                 {
 603                         pthread_mutex_lock(&(video->slice_buffers[i].completion_lock));
 604                         pthread_mutex_unlock(&(video->slice_buffers[i].completion_lock));
 605                 }
 606
 607 /* Wait for decoders to finish so packages aren't overwritten */
 608                 for(i = 0; i < video->total_slice_decoders; i++)
 609                 {
 610                         pthread_mutex_lock(&(video->slice_decoders[i].completion_lock));
 611                 }
 612         }
 613         return 0;
 614 }
 615
 616 int mpeg3video_allocate_decoders(mpeg3video_t *video, int decoder_count)
 617 {
 618         int i;
 619         mpeg3_t *file = video->file;
 620 /* Get the slice decoders */
 621         if(video->total_slice_decoders != file->cpus)
 622         {
 623                 for(i = 0; i < video->total_slice_decoders; i++)
 624                 {
 625                         mpeg3_delete_slice_decoder(&(video->slice_decoders[i]));
 626                 }
 627
 628                 for(i = 0; i < file->cpus && i < MPEG3_MAX_CPUS; i++)
 629                 {
 630                         mpeg3_new_slice_decoder(video, &(video->slice_decoders[i]));
 631                         video->slice_decoders[i].thread_number = i;
 632                 }
 633
 634                 video->total_slice_decoders = file->cpus;
 635         }
 636         return 0;
 637 }
 638
 639 /* decode one frame or field picture */
 640
 641 int mpeg3video_getpicture(mpeg3video_t *video, int framenum)
 642 {
 643         int i, result = 0;
 644         mpeg3_t *file = video->file;
 645
 646         if(video->pict_struct == FRAME_PICTURE && video->secondfield)
 647         {
 648 /* recover from illegal number of field pictures */
 649         video->secondfield = 0;
 650         }
 651
 652         if(!video->mpeg2)
 653         {
 654                 video->current_repeat = video->repeat_count = 0;
 655         }
 656
 657         mpeg3video_allocate_decoders(video, file->cpus);
 658
 659         for(i = 0; i < 3; i++)
 660         {
 661         if(video->pict_type == B_TYPE)
 662                 {
 663                         video->newframe[i] = video->auxframe[i];
 664                 }
 665         else
 666                 {
 667                 if(!video->secondfield && !video->current_repeat)
 668                         {
 669 /* Swap refframes for I frames */
 670                         unsigned char* tmp = video->oldrefframe[i];
 671                         video->oldrefframe[i] = video->refframe[i];
 672                         video->refframe[i] = tmp;
 673                 }
 674
 675                 video->newframe[i] = video->refframe[i];
 676         }
 677
 678         if(video->pict_struct == BOTTOM_FIELD)
 679                 {
 680 /* Only used if fields are in different pictures */
 681             video->newframe[i] += (i == 0) ?
 682                                 video->coded_picture_width :
 683                                 video->chrom_width;
 684                 }
 685         }
 686
 687
 688 /* The problem is when a B frame lands on the first repeat and is skipped, */
 689 /* the second repeat goes for the same bitmap as the skipped repeat, */
 690 /* so it picks up a frame from 3 frames back. */
 691 /* The first repeat must consititutively read a B frame if its B frame is going to be */
 692 /* used in a later repeat. */
 693         if(!video->current_repeat)
 694                 if(!(video->skip_bframes && video->pict_type == B_TYPE) ||
 695                         (video->repeat_count >= 100 + 100 * video->skip_bframes))
 696                         result = mpeg3video_get_macroblocks(video, framenum);
 697
 698 /* Set the frame to display */
 699         video->output_src[0] = 0;
 700         video->output_src[1] = 0;
 701         video->output_src[2] = 0;
 702         if(framenum > -1 && !result)
 703         {
 704         if(video->pict_struct == FRAME_PICTURE || video->secondfield)
 705                 {
 706                 if(video->pict_type == B_TYPE)
 707                         {
 708                                 video->output_src[0] = video->auxframe[0];
 709                                 video->output_src[1] = video->auxframe[1];
 710                                 video->output_src[2] = video->auxframe[2];
 711                         }
 712                 else
 713                         {
 714                                 video->output_src[0] = video->oldrefframe[0];
 715                                 video->output_src[1] = video->oldrefframe[1];
 716                                 video->output_src[2] = video->oldrefframe[2];
 717                         }
 718         }
 719         else
 720                 {
 721                         mpeg3video_display_second_field(video);
 722                 }
 723         }
 724
 725         if(video->mpeg2)
 726         {
 727                 video->current_repeat += 100;
 728         }
 729
 730         if(video->pict_struct != FRAME_PICTURE)
 731                 video->secondfield = !video->secondfield;
 732         return result;
 733 }