Subversion Repositories shark

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
1085 pj 1
/* getpic.c, picture decoding                                               */
2
 
3
/* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
4
 
5
/*
6
 * Disclaimer of Warranty
7
 *
8
 * These software programs are available to the user without any license fee or
9
 * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
10
 * any and all warranties, whether express, implied, or statuary, including any
11
 * implied warranties or merchantability or of fitness for a particular
12
 * purpose.  In no event shall the copyright-holder be liable for any
13
 * incidental, punitive, or consequential damages of any kind whatsoever
14
 * arising from the use of these programs.
15
 *
16
 * This disclaimer of warranty extends to the user of these programs and user's
17
 * customers, employees, agents, transferees, successors, and assigns.
18
 *
19
 * The MPEG Software Simulation Group does not represent or warrant that the
20
 * programs furnished hereunder are free of infringement of any third-party
21
 * patents.
22
 *
23
 * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
24
 * are subject to royalty fees to patent holders.  Many of these patents are
25
 * general enough such that they are unavoidable regardless of implementation
26
 * design.
27
 *
28
 */
29
 
30
#include <stdio.h>
31
 
32
#include "config.h"
33
#include "global.h"
34
 
35
/* private prototypes*/
36
static void picture_data _ANSI_ARGS_((int framenum));
37
static void macroblock_modes _ANSI_ARGS_((int *pmacroblock_type, int *pstwtype,
38
  int *pstwclass, int *pmotion_type, int *pmotion_vector_count, int *pmv_format, int *pdmv,
39
  int *pmvscale, int *pdct_type));
40
static void Clear_Block _ANSI_ARGS_((int comp));
41
static void Sum_Block _ANSI_ARGS_((int comp));
42
static void Saturate _ANSI_ARGS_((short *bp));
43
static void Add_Block _ANSI_ARGS_((int comp, int bx, int by,
44
  int dct_type, int addflag));
45
static void Update_Picture_Buffers _ANSI_ARGS_((void));
46
static void frame_reorder _ANSI_ARGS_((int bitstream_framenum,
47
  int sequence_framenum));
48
static void Decode_SNR_Macroblock _ANSI_ARGS_((int *SNRMBA, int *SNRMBAinc,
49
  int MBA, int MBAmax, int *dct_type));
50
 
51
static void motion_compensation _ANSI_ARGS_((int MBA, int macroblock_type,
52
 int motion_type, int PMV[2][2][2], int motion_vertical_field_select[2][2],
53
 int dmvector[2], int stwtype, int dct_type));
54
 
55
static void skipped_macroblock _ANSI_ARGS_((int dc_dct_pred[3],
56
  int PMV[2][2][2], int *motion_type, int motion_vertical_field_select[2][2],
57
  int *stwtype, int *macroblock_type));
58
 
59
static int slice _ANSI_ARGS_((int framenum, int MBAmax));
60
 
61
static int start_of_slice _ANSI_ARGS_ ((int MBAmax, int *MBA,
62
  int *MBAinc, int dc_dct_pred[3], int PMV[2][2][2]));
63
 
64
static int decode_macroblock _ANSI_ARGS_((int *macroblock_type,
65
  int *stwtype, int *stwclass, int *motion_type, int *dct_type,
66
  int PMV[2][2][2], int dc_dct_pred[3],
67
  int motion_vertical_field_select[2][2], int dmvector[2]));
68
 
69
 
70
/* decode one frame or field picture */
71
void Decode_Picture(bitstream_framenum, sequence_framenum)
72
int bitstream_framenum, sequence_framenum;
73
{
74
 
75
  if (picture_structure==FRAME_PICTURE && Second_Field)
76
  {
77
    /* recover from illegal number of field pictures */
78
    printf("odd number of field pictures\n");
79
    Second_Field = 0;
80
  }
81
 
82
  /* IMPLEMENTATION: update picture buffer pointers */
83
  Update_Picture_Buffers();
84
 
85
#ifdef VERIFY 
86
  Check_Headers(bitstream_framenum, sequence_framenum);
87
#endif /* VERIFY */
88
 
89
  /* ISO/IEC 13818-4 section 2.4.5.4 "frame buffer intercept method" */
90
  /* (section number based on November 1995 (Dallas) draft of the
91
      conformance document) */
92
  if(Ersatz_Flag)
93
    Substitute_Frame_Buffer(bitstream_framenum, sequence_framenum);
94
 
95
  /* form spatial scalable picture */
96
 
97
  /* form spatial scalable picture */
98
  /* ISO/IEC 13818-2 section 7.7: Spatial scalability */
99
  if (base.pict_scal && !Second_Field)
100
  {
101
    Spatial_Prediction();
102
  }
103
 
104
  /* decode picture data ISO/IEC 13818-2 section 6.2.3.7 */
105
  picture_data(bitstream_framenum);
106
 
107
  /* write or display current or previously decoded reference frame */
108
  /* ISO/IEC 13818-2 section 6.1.1.11: Frame reordering */
109
  frame_reorder(bitstream_framenum, sequence_framenum);
110
 
111
  if (picture_structure!=FRAME_PICTURE)
112
    Second_Field = !Second_Field;
113
}
114
 
115
 
116
/* decode all macroblocks of the current picture */
117
/* stages described in ISO/IEC 13818-2 section 7 */
118
static void picture_data(framenum)
119
int framenum;
120
{
121
  int MBAmax;
122
  int ret;
123
 
124
  /* number of macroblocks per picture */
125
  MBAmax = mb_width*mb_height;
126
 
127
  if (picture_structure!=FRAME_PICTURE)
128
    MBAmax>>=1; /* field picture has half as mnay macroblocks as frame */
129
 
130
  for(;;)
131
  {
132
    if((ret=slice(framenum, MBAmax))<0)
133
      return;
134
  }
135
 
136
}
137
 
138
 
139
 
140
/* decode all macroblocks of the current picture */
141
/* ISO/IEC 13818-2 section 6.3.16 */
142
static int slice(framenum, MBAmax)
143
int framenum, MBAmax;
144
{
145
  int MBA;
146
  int MBAinc, macroblock_type, motion_type, dct_type;
147
  int dc_dct_pred[3];
148
  int PMV[2][2][2], motion_vertical_field_select[2][2];
149
  int dmvector[2];
150
  int stwtype, stwclass;
151
  int SNRMBA, SNRMBAinc;
152
  int ret;
153
 
154
  MBA = 0; /* macroblock address */
155
  MBAinc = 0;
156
 
157
  if((ret=start_of_slice(MBAmax, &MBA, &MBAinc, dc_dct_pred, PMV))!=1)
158
    return(ret);
159
 
160
  if (Two_Streams && enhan.scalable_mode==SC_SNR)
161
  {
162
    SNRMBA=0;
163
    SNRMBAinc=0;
164
  }
165
 
166
  Fault_Flag=0;
167
 
168
  for (;;)
169
  {
170
 
171
    /* this is how we properly exit out of picture */
172
    if (MBA>=MBAmax)
173
      return(-1); /* all macroblocks decoded */
174
 
175
#ifdef TRACE
176
    if (Trace_Flag)
177
      printf("frame %d, MB %d\n",framenum,MBA);
178
#endif /* TRACE */
179
 
180
#ifdef DISPLAY
181
    if (!progressive_frame && picture_structure==FRAME_PICTURE
182
      && MBA==(MBAmax>>1) && framenum!=0 && Output_Type==T_X11
183
       && !Display_Progressive_Flag)
184
    {
185
      Display_Second_Field();
186
    }
187
#endif
188
 
189
    ld = &base;
190
 
191
    if (MBAinc==0)
192
    {
193
      if (base.scalable_mode==SC_DP && base.priority_breakpoint==1)
194
          ld = &enhan;
195
 
196
      if (!Show_Bits(23) || Fault_Flag) /* next_start_code or fault */
197
      {
198
resync: /* if Fault_Flag: resynchronize to next next_start_code */
199
        Fault_Flag = 0;
200
        return(0);     /* trigger: go to next slice */
201
      }
202
      else /* neither next_start_code nor Fault_Flag */
203
      {
204
        if (base.scalable_mode==SC_DP && base.priority_breakpoint==1)
205
          ld = &enhan;
206
 
207
        /* decode macroblock address increment */
208
        MBAinc = Get_macroblock_address_increment();
209
 
210
        if (Fault_Flag) goto resync;
211
      }
212
    }
213
 
214
    if (MBA>=MBAmax)
215
    {
216
      /* MBAinc points beyond picture dimensions */
217
      if (!Quiet_Flag)
218
        printf("Too many macroblocks in picture\n");
219
      return(-1);
220
    }
221
 
222
    if (MBAinc==1) /* not skipped */
223
    {
224
      ret = decode_macroblock(&macroblock_type, &stwtype, &stwclass,
225
              &motion_type, &dct_type, PMV, dc_dct_pred,
226
              motion_vertical_field_select, dmvector);
227
 
228
      if(ret==-1)
229
        return(-1);
230
 
231
      if(ret==0)
232
        goto resync;
233
 
234
    }
235
    else /* MBAinc!=1: skipped macroblock */
236
    {      
237
      /* ISO/IEC 13818-2 section 7.6.6 */
238
      skipped_macroblock(dc_dct_pred, PMV, &motion_type,
239
        motion_vertical_field_select, &stwtype, &macroblock_type);
240
    }
241
 
242
    /* SCALABILITY: SNR */
243
    /* ISO/IEC 13818-2 section 7.8 */
244
    /* NOTE: we currently ignore faults encountered in this routine */
245
    if (Two_Streams && enhan.scalable_mode==SC_SNR)
246
      Decode_SNR_Macroblock(&SNRMBA, &SNRMBAinc, MBA, MBAmax, &dct_type);
247
 
248
    /* ISO/IEC 13818-2 section 7.6 */
249
    motion_compensation(MBA, macroblock_type, motion_type, PMV,
250
      motion_vertical_field_select, dmvector, stwtype, dct_type);
251
 
252
 
253
    /* advance to next macroblock */
254
    MBA++;
255
    MBAinc--;
256
 
257
    /* SCALABILITY: SNR */
258
    if (Two_Streams && enhan.scalable_mode==SC_SNR)
259
    {
260
      SNRMBA++;
261
      SNRMBAinc--;
262
    }
263
 
264
    if (MBA>=MBAmax)
265
      return(-1); /* all macroblocks decoded */
266
  }
267
}
268
 
269
 
270
/* ISO/IEC 13818-2 section 6.3.17.1: Macroblock modes */
271
static void macroblock_modes(pmacroblock_type,pstwtype,pstwclass,
272
  pmotion_type,pmotion_vector_count,pmv_format,pdmv,pmvscale,pdct_type)
273
  int *pmacroblock_type, *pstwtype, *pstwclass;
274
  int *pmotion_type, *pmotion_vector_count, *pmv_format, *pdmv, *pmvscale;
275
  int *pdct_type;
276
{
277
  int macroblock_type;
278
  int stwtype, stwcode, stwclass;
279
  int motion_type = 0;
280
  int motion_vector_count, mv_format, dmv, mvscale;
281
  int dct_type;
282
  static unsigned char stwc_table[3][4]
283
    = { {6,3,7,4}, {2,1,5,4}, {2,5,7,4} };
284
  static unsigned char stwclass_table[9]
285
    = {0, 1, 2, 1, 1, 2, 3, 3, 4};
286
 
287
  /* get macroblock_type */
288
  macroblock_type = Get_macroblock_type();
289
 
290
  if (Fault_Flag) return;
291
 
292
  /* get spatial_temporal_weight_code */
293
  if (macroblock_type & MB_WEIGHT)
294
  {
295
    if (spatial_temporal_weight_code_table_index==0)
296
      stwtype = 4;
297
    else
298
    {
299
      stwcode = Get_Bits(2);
300
#ifdef TRACE
301
      if (Trace_Flag)
302
      {
303
        printf("spatial_temporal_weight_code (");
304
        Print_Bits(stwcode,2,2);
305
        printf("): %d\n",stwcode);
306
      }
307
#endif /* TRACE */
308
      stwtype = stwc_table[spatial_temporal_weight_code_table_index-1][stwcode];
309
    }
310
  }
311
  else
312
    stwtype = (macroblock_type & MB_CLASS4) ? 8 : 0;
313
 
314
  /* SCALABILITY: derive spatial_temporal_weight_class (Table 7-18) */
315
  stwclass = stwclass_table[stwtype];
316
 
317
  /* get frame/field motion type */
318
  if (macroblock_type & (MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD))
319
  {
320
    if (picture_structure==FRAME_PICTURE) /* frame_motion_type */
321
    {
322
      motion_type = frame_pred_frame_dct ? MC_FRAME : Get_Bits(2);
323
#ifdef TRACE
324
      if (!frame_pred_frame_dct && Trace_Flag)
325
      {
326
        printf("frame_motion_type (");
327
        Print_Bits(motion_type,2,2);
328
        printf("): %s\n",motion_type==MC_FIELD?"Field":
329
                         motion_type==MC_FRAME?"Frame":
330
                         motion_type==MC_DMV?"Dual_Prime":"Invalid");
331
      }
332
#endif /* TRACE */
333
    }
334
    else /* field_motion_type */
335
    {
336
      motion_type = Get_Bits(2);
337
#ifdef TRACE
338
      if (Trace_Flag)
339
      {
340
        printf("field_motion_type (");
341
        Print_Bits(motion_type,2,2);
342
        printf("): %s\n",motion_type==MC_FIELD?"Field":
343
                         motion_type==MC_16X8?"16x8 MC":
344
                         motion_type==MC_DMV?"Dual_Prime":"Invalid");
345
      }
346
#endif /* TRACE */
347
    }
348
  }
349
  else if ((macroblock_type & MACROBLOCK_INTRA) && concealment_motion_vectors)
350
  {
351
    /* concealment motion vectors */
352
    motion_type = (picture_structure==FRAME_PICTURE) ? MC_FRAME : MC_FIELD;
353
  }
354
#if 0
355
  else
356
  {
357
    printf("maroblock_modes(): unknown macroblock type\n");
358
    motion_type = -1;
359
  }
360
#endif
361
 
362
  /* derive motion_vector_count, mv_format and dmv, (table 6-17, 6-18) */
363
  if (picture_structure==FRAME_PICTURE)
364
  {
365
    motion_vector_count = (motion_type==MC_FIELD && stwclass<2) ? 2 : 1;
366
    mv_format = (motion_type==MC_FRAME) ? MV_FRAME : MV_FIELD;
367
  }
368
  else
369
  {
370
    motion_vector_count = (motion_type==MC_16X8) ? 2 : 1;
371
    mv_format = MV_FIELD;
372
  }
373
 
374
  dmv = (motion_type==MC_DMV); /* dual prime */
375
 
376
  /* field mv predictions in frame pictures have to be scaled
377
   * ISO/IEC 13818-2 section 7.6.3.1 Decoding the motion vectors
378
   * IMPLEMENTATION: mvscale is derived for later use in motion_vectors()
379
   * it displaces the stage:
380
   *
381
   *    if((mv_format=="field")&&(t==1)&&(picture_structure=="Frame picture"))
382
   *      prediction = PMV[r][s][t] DIV 2;
383
   */
384
 
385
  mvscale = ((mv_format==MV_FIELD) && (picture_structure==FRAME_PICTURE));
386
 
387
  /* get dct_type (frame DCT / field DCT) */
388
  dct_type = (picture_structure==FRAME_PICTURE)
389
             && (!frame_pred_frame_dct)
390
             && (macroblock_type & (MACROBLOCK_PATTERN|MACROBLOCK_INTRA))
391
             ? Get_Bits(1)
392
             : 0;
393
 
394
#ifdef TRACE
395
  if (Trace_Flag  && (picture_structure==FRAME_PICTURE)
396
             && (!frame_pred_frame_dct)
397
             && (macroblock_type & (MACROBLOCK_PATTERN|MACROBLOCK_INTRA)))
398
    printf("dct_type (%d): %s\n",dct_type,dct_type?"Field":"Frame");
399
#endif /* TRACE */
400
 
401
  /* return values */
402
  *pmacroblock_type = macroblock_type;
403
  *pstwtype = stwtype;
404
  *pstwclass = stwclass;
405
  *pmotion_type = motion_type;
406
  *pmotion_vector_count = motion_vector_count;
407
  *pmv_format = mv_format;
408
  *pdmv = dmv;
409
  *pmvscale = mvscale;
410
  *pdct_type = dct_type;
411
}
412
 
413
 
414
/* move/add 8x8-Block from block[comp] to backward_reference_frame */
415
/* copy reconstructed 8x8 block from block[comp] to current_frame[]
416
 * ISO/IEC 13818-2 section 7.6.8: Adding prediction and coefficient data
417
 * This stage also embodies some of the operations implied by:
418
 *   - ISO/IEC 13818-2 section 7.6.7: Combining predictions
419
 *   - ISO/IEC 13818-2 section 6.1.3: Macroblock
420
*/
421
static void Add_Block(comp,bx,by,dct_type,addflag)
422
int comp,bx,by,dct_type,addflag;
423
{
424
  int cc,i, j, iincr;
425
  unsigned char *rfp;
426
  short *bp;
427
 
428
 
429
  /* derive color component index */
430
  /* equivalent to ISO/IEC 13818-2 Table 7-1 */
431
  cc = (comp<4) ? 0 : (comp&1)+1; /* color component index */
432
 
433
  if (cc==0)
434
  {
435
    /* luminance */
436
 
437
    if (picture_structure==FRAME_PICTURE)
438
      if (dct_type)
439
      {
440
        /* field DCT coding */
441
        rfp = current_frame[0]
442
              + Coded_Picture_Width*(by+((comp&2)>>1)) + bx + ((comp&1)<<3);
443
        iincr = (Coded_Picture_Width<<1) - 8;
444
      }
445
      else
446
      {
447
        /* frame DCT coding */
448
        rfp = current_frame[0]
449
              + Coded_Picture_Width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
450
        iincr = Coded_Picture_Width - 8;
451
      }
452
    else
453
    {
454
      /* field picture */
455
      rfp = current_frame[0]
456
            + (Coded_Picture_Width<<1)*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
457
      iincr = (Coded_Picture_Width<<1) - 8;
458
    }
459
  }
460
  else
461
  {
462
    /* chrominance */
463
 
464
    /* scale coordinates */
465
    if (chroma_format!=CHROMA444)
466
      bx >>= 1;
467
    if (chroma_format==CHROMA420)
468
      by >>= 1;
469
    if (picture_structure==FRAME_PICTURE)
470
    {
471
      if (dct_type && (chroma_format!=CHROMA420))
472
      {
473
        /* field DCT coding */
474
        rfp = current_frame[cc]
475
              + Chroma_Width*(by+((comp&2)>>1)) + bx + (comp&8);
476
        iincr = (Chroma_Width<<1) - 8;
477
      }
478
      else
479
      {
480
        /* frame DCT coding */
481
        rfp = current_frame[cc]
482
              + Chroma_Width*(by+((comp&2)<<2)) + bx + (comp&8);
483
        iincr = Chroma_Width - 8;
484
      }
485
    }
486
    else
487
    {
488
      /* field picture */
489
      rfp = current_frame[cc]
490
            + (Chroma_Width<<1)*(by+((comp&2)<<2)) + bx + (comp&8);
491
      iincr = (Chroma_Width<<1) - 8;
492
    }
493
  }
494
 
495
  bp = ld->block[comp];
496
 
497
  if (addflag)
498
  {
499
    for (i=0; i<8; i++)
500
    {
501
      for (j=0; j<8; j++)
502
      {
503
        *rfp = Clip[*bp++ + *rfp];
504
        rfp++;
505
      }
506
 
507
      rfp+= iincr;
508
    }
509
  }
510
  else
511
  {
512
    for (i=0; i<8; i++)
513
    {
514
      for (j=0; j<8; j++)
515
        *rfp++ = Clip[*bp++ + 128];
516
 
517
      rfp+= iincr;
518
    }
519
  }
520
}
521
 
522
 
523
/* ISO/IEC 13818-2 section 7.8 */
524
static void Decode_SNR_Macroblock(SNRMBA, SNRMBAinc, MBA, MBAmax, dct_type)
525
  int *SNRMBA, *SNRMBAinc;
526
  int MBA, MBAmax;
527
  int *dct_type;
528
{
529
  int SNRmacroblock_type, SNRcoded_block_pattern, SNRdct_type, dummy;
530
  int slice_vert_pos_ext, quantizer_scale_code, comp, code;
531
 
532
  ld = &enhan;
533
 
534
  if (*SNRMBAinc==0)
535
  {
536
    if (!Show_Bits(23)) /* next_start_code */
537
    {
538
      next_start_code();
539
      code = Show_Bits(32);
540
 
541
      if (code<SLICE_START_CODE_MIN || code>SLICE_START_CODE_MAX)
542
      {
543
        /* only slice headers are allowed in picture_data */
544
        if (!Quiet_Flag)
545
          printf("SNR: Premature end of picture\n");
546
        return;
547
      }
548
 
549
      Flush_Buffer32();
550
 
551
      /* decode slice header (may change quantizer_scale) */
552
      slice_vert_pos_ext = slice_header();
553
 
554
      /* decode macroblock address increment */
555
      *SNRMBAinc = Get_macroblock_address_increment();
556
 
557
      /* set current location */
558
      *SNRMBA =
559
        ((slice_vert_pos_ext<<7) + (code&255) - 1)*mb_width + *SNRMBAinc - 1;
560
 
561
      *SNRMBAinc = 1; /* first macroblock in slice: not skipped */
562
    }
563
    else /* not next_start_code */
564
    {
565
      if (*SNRMBA>=MBAmax)
566
      {
567
        if (!Quiet_Flag)
568
          printf("Too many macroblocks in picture\n");
569
        return;
570
      }
571
 
572
      /* decode macroblock address increment */
573
      *SNRMBAinc = Get_macroblock_address_increment();
574
    }
575
  }
576
 
577
  if (*SNRMBA!=MBA)
578
  {
579
    /* streams out of sync */
580
    if (!Quiet_Flag)
581
      printf("Cant't synchronize streams\n");
582
    return;
583
  }
584
 
585
  if (*SNRMBAinc==1) /* not skipped */
586
  {
587
    macroblock_modes(&SNRmacroblock_type, &dummy, &dummy,
588
      &dummy, &dummy, &dummy, &dummy, &dummy,
589
      &SNRdct_type);
590
 
591
    if (SNRmacroblock_type & MACROBLOCK_PATTERN)
592
      *dct_type = SNRdct_type;
593
 
594
    if (SNRmacroblock_type & MACROBLOCK_QUANT)
595
    {
596
      quantizer_scale_code = Get_Bits(5);
597
      ld->quantizer_scale =
598
        ld->q_scale_type ? Non_Linear_quantizer_scale[quantizer_scale_code] : quantizer_scale_code<<1;
599
    }
600
 
601
    /* macroblock_pattern */
602
    if (SNRmacroblock_type & MACROBLOCK_PATTERN)
603
    {
604
      SNRcoded_block_pattern = Get_coded_block_pattern();
605
 
606
      if (chroma_format==CHROMA422)
607
        SNRcoded_block_pattern = (SNRcoded_block_pattern<<2) | Get_Bits(2); /* coded_block_pattern_1 */
608
      else if (chroma_format==CHROMA444)
609
        SNRcoded_block_pattern = (SNRcoded_block_pattern<<6) | Get_Bits(6); /* coded_block_pattern_2 */
610
    }
611
    else
612
      SNRcoded_block_pattern = 0;
613
 
614
    /* decode blocks */
615
    for (comp=0; comp<block_count; comp++)
616
    {
617
      Clear_Block(comp);
618
 
619
      if (SNRcoded_block_pattern & (1<<(block_count-1-comp)))
620
        Decode_MPEG2_Non_Intra_Block(comp);
621
    }
622
  }
623
  else /* SNRMBAinc!=1: skipped macroblock */
624
  {
625
    for (comp=0; comp<block_count; comp++)
626
      Clear_Block(comp);
627
  }
628
 
629
  ld = &base;
630
}
631
 
632
 
633
 
634
/* IMPLEMENTATION: set scratch pad macroblock to zero */
635
static void Clear_Block(comp)
636
int comp;
637
{
638
  short *Block_Ptr;
639
  int i;
640
 
641
  Block_Ptr = ld->block[comp];
642
 
643
  for (i=0; i<64; i++)
644
    *Block_Ptr++ = 0;
645
}
646
 
647
 
648
/* SCALABILITY: add SNR enhancement layer block data to base layer */
649
/* ISO/IEC 13818-2 section 7.8.3.4: Addition of coefficients from the two layes */
650
static void Sum_Block(comp)
651
int comp;
652
{
653
  short *Block_Ptr1, *Block_Ptr2;
654
  int i;
655
 
656
  Block_Ptr1 = base.block[comp];
657
  Block_Ptr2 = enhan.block[comp];
658
 
659
  for (i=0; i<64; i++)
660
    *Block_Ptr1++ += *Block_Ptr2++;
661
}
662
 
663
 
664
/* limit coefficients to -2048..2047 */
665
/* ISO/IEC 13818-2 section 7.4.3 and 7.4.4: Saturation and Mismatch control */
666
static void Saturate(Block_Ptr)
667
short *Block_Ptr;
668
{
669
  int i, sum, val;
670
 
671
  sum = 0;
672
 
673
  /* ISO/IEC 13818-2 section 7.4.3: Saturation */
674
  for (i=0; i<64; i++)
675
  {
676
    val = Block_Ptr[i];
677
 
678
    if (val>2047)
679
      val = 2047;
680
    else if (val<-2048)
681
      val = -2048;
682
 
683
    Block_Ptr[i] = val;
684
    sum+= val;
685
  }
686
 
687
  /* ISO/IEC 13818-2 section 7.4.4: Mismatch control */
688
  if ((sum&1)==0)
689
    Block_Ptr[63]^= 1;
690
 
691
}
692
 
693
 
694
/* reuse old picture buffers as soon as they are no longer needed
695
   based on life-time axioms of MPEG */
696
static void Update_Picture_Buffers()
697
{                          
698
  int cc;              /* color component index */
699
  unsigned char *tmp;  /* temporary swap pointer */
700
 
701
  for (cc=0; cc<3; cc++)
702
  {
703
    /* B pictures do not need to be save for future reference */
704
    if (picture_coding_type==B_TYPE)
705
    {
706
      current_frame[cc] = auxframe[cc];
707
    }
708
    else
709
    {
710
      /* only update at the beginning of the coded frame */
711
      if (!Second_Field)
712
      {
713
        tmp = forward_reference_frame[cc];
714
 
715
        /* the previously decoded reference frame is stored
716
           coincident with the location where the backward
717
           reference frame is stored (backwards prediction is not
718
           needed in P pictures) */
719
        forward_reference_frame[cc] = backward_reference_frame[cc];
720
 
721
        /* update pointer for potential future B pictures */
722
        backward_reference_frame[cc] = tmp;
723
      }
724
 
725
      /* can erase over old backward reference frame since it is not used
726
         in a P picture, and since any subsequent B pictures will use the
727
         previously decoded I or P frame as the backward_reference_frame */
728
      current_frame[cc] = backward_reference_frame[cc];
729
    }
730
 
731
    /* IMPLEMENTATION:
732
       one-time folding of a line offset into the pointer which stores the
733
       memory address of the current frame saves offsets and conditional
734
       branches throughout the remainder of the picture processing loop */
735
    if (picture_structure==BOTTOM_FIELD)
736
      current_frame[cc]+= (cc==0) ? Coded_Picture_Width : Chroma_Width;
737
  }
738
}
739
 
740
 
741
/* store last frame */
742
 
743
void Output_Last_Frame_of_Sequence(Framenum)
744
int Framenum;
745
{
746
  if (Second_Field)
747
    printf("last frame incomplete, not stored\n");
748
  else
749
    Write_Frame(backward_reference_frame,Framenum-1);
750
}
751
 
752
 
753
 
754
static void frame_reorder(Bitstream_Framenum, Sequence_Framenum)
755
int Bitstream_Framenum, Sequence_Framenum;
756
{
757
  /* tracking variables to insure proper output in spatial scalability */
758
  static int Oldref_progressive_frame, Newref_progressive_frame;
759
 
760
  if (Sequence_Framenum!=0)
761
  {
762
    if (picture_structure==FRAME_PICTURE || Second_Field)
763
    {
764
      if (picture_coding_type==B_TYPE)
765
        Write_Frame(auxframe,Bitstream_Framenum-1);
766
      else
767
      {
768
        Newref_progressive_frame = progressive_frame;
769
        progressive_frame = Oldref_progressive_frame;
770
 
771
        Write_Frame(forward_reference_frame,Bitstream_Framenum-1);
772
 
773
        Oldref_progressive_frame = progressive_frame = Newref_progressive_frame;
774
      }
775
    }
776
#ifdef DISPLAY
777
    else if (Output_Type==T_X11)
778
    {
779
      if(!Display_Progressive_Flag)
780
        Display_Second_Field();
781
    }
782
#endif
783
  }
784
  else
785
    Oldref_progressive_frame = progressive_frame;
786
 
787
}
788
 
789
 
790
/* ISO/IEC 13818-2 section 7.6 */
791
static void motion_compensation(MBA, macroblock_type, motion_type, PMV,
792
  motion_vertical_field_select, dmvector, stwtype, dct_type)
793
int MBA;
794
int macroblock_type;
795
int motion_type;
796
int PMV[2][2][2];
797
int motion_vertical_field_select[2][2];
798
int dmvector[2];
799
int stwtype;
800
int dct_type;
801
{
802
  int bx, by;
803
  int comp;
804
 
805
  /* derive current macroblock position within picture */
806
  /* ISO/IEC 13818-2 section 6.3.1.6 and 6.3.1.7 */
807
  bx = 16*(MBA%mb_width);
808
  by = 16*(MBA/mb_width);
809
 
810
  /* motion compensation */
811
  if (!(macroblock_type & MACROBLOCK_INTRA))
812
    form_predictions(bx,by,macroblock_type,motion_type,PMV,
813
      motion_vertical_field_select,dmvector,stwtype);
814
 
815
  /* SCALABILITY: Data Partitioning */
816
  if (base.scalable_mode==SC_DP)
817
    ld = &base;
818
 
819
  /* copy or add block data into picture */
820
  for (comp=0; comp<block_count; comp++)
821
  {
822
    /* SCALABILITY: SNR */
823
    /* ISO/IEC 13818-2 section 7.8.3.4: Addition of coefficients from
824
       the two a layers */
825
    if (Two_Streams && enhan.scalable_mode==SC_SNR)
826
      Sum_Block(comp); /* add SNR enhancement layer data to base layer */
827
 
828
    /* MPEG-2 saturation and mismatch control */
829
    /* base layer could be MPEG-1 stream, enhancement MPEG-2 SNR */
830
    /* ISO/IEC 13818-2 section 7.4.3 and 7.4.4: Saturation and Mismatch control */
831
    if ((Two_Streams && enhan.scalable_mode==SC_SNR) || ld->MPEG2_Flag)
832
      Saturate(ld->block[comp]);
833
 
834
    /* ISO/IEC 13818-2 section Annex A: inverse DCT */
835
    if (Reference_IDCT_Flag)
836
      Reference_IDCT(ld->block[comp]);
837
    else
838
      Fast_IDCT(ld->block[comp]);
839
 
840
    /* ISO/IEC 13818-2 section 7.6.8: Adding prediction and coefficient data */
841
    Add_Block(comp,bx,by,dct_type,(macroblock_type & MACROBLOCK_INTRA)==0);
842
  }
843
 
844
}
845
 
846
 
847
 
848
/* ISO/IEC 13818-2 section 7.6.6 */
849
static void skipped_macroblock(dc_dct_pred, PMV, motion_type,
850
  motion_vertical_field_select, stwtype, macroblock_type)
851
int dc_dct_pred[3];
852
int PMV[2][2][2];
853
int *motion_type;
854
int motion_vertical_field_select[2][2];
855
int *stwtype;
856
int *macroblock_type;
857
{
858
  int comp;
859
 
860
  /* SCALABILITY: Data Paritioning */
861
  if (base.scalable_mode==SC_DP)
862
    ld = &base;
863
 
864
  for (comp=0; comp<block_count; comp++)
865
    Clear_Block(comp);
866
 
867
  /* reset intra_dc predictors */
868
  /* ISO/IEC 13818-2 section 7.2.1: DC coefficients in intra blocks */
869
  dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
870
 
871
  /* reset motion vector predictors */
872
  /* ISO/IEC 13818-2 section 7.6.3.4: Resetting motion vector predictors */
873
  if (picture_coding_type==P_TYPE)
874
    PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
875
 
876
  /* derive motion_type */
877
  if (picture_structure==FRAME_PICTURE)
878
    *motion_type = MC_FRAME;
879
  else
880
  {
881
    *motion_type = MC_FIELD;
882
 
883
    /* predict from field of same parity */
884
    /* ISO/IEC 13818-2 section 7.6.6.1 and 7.6.6.3: P field picture and B field
885
       picture */
886
    motion_vertical_field_select[0][0]=motion_vertical_field_select[0][1] =
887
      (picture_structure==BOTTOM_FIELD);
888
  }
889
 
890
  /* skipped I are spatial-only predicted, */
891
  /* skipped P and B are temporal-only predicted */
892
  /* ISO/IEC 13818-2 section 7.7.6: Skipped macroblocks */
893
  *stwtype = (picture_coding_type==I_TYPE) ? 8 : 0;
894
 
895
 /* IMPLEMENTATION: clear MACROBLOCK_INTRA */
896
  *macroblock_type&= ~MACROBLOCK_INTRA;
897
 
898
}
899
 
900
 
901
/* return==-1 means go to next picture */
902
/* the expression "start of slice" is used throughout the normative
903
   body of the MPEG specification */
904
static int start_of_slice(MBAmax, MBA, MBAinc,
905
  dc_dct_pred, PMV)
906
int MBAmax;
907
int *MBA;
908
int *MBAinc;
909
int dc_dct_pred[3];
910
int PMV[2][2][2];
911
{
912
  unsigned int code;
913
  int slice_vert_pos_ext;
914
 
915
  ld = &base;
916
 
917
  Fault_Flag = 0;
918
 
919
  next_start_code();
920
  code = Show_Bits(32);
921
 
922
  if (code<SLICE_START_CODE_MIN || code>SLICE_START_CODE_MAX)
923
  {
924
    /* only slice headers are allowed in picture_data */
925
    if (!Quiet_Flag)
926
      printf("start_of_slice(): Premature end of picture\n");
927
 
928
    return(-1);  /* trigger: go to next picture */
929
  }
930
 
931
  Flush_Buffer32();
932
 
933
  /* decode slice header (may change quantizer_scale) */
934
  slice_vert_pos_ext = slice_header();
935
 
936
 
937
  /* SCALABILITY: Data Partitioning */
938
  if (base.scalable_mode==SC_DP)
939
  {
940
    ld = &enhan;
941
    next_start_code();
942
    code = Show_Bits(32);
943
 
944
    if (code<SLICE_START_CODE_MIN || code>SLICE_START_CODE_MAX)
945
    {
946
      /* only slice headers are allowed in picture_data */
947
      if (!Quiet_Flag)
948
        printf("DP: Premature end of picture\n");
949
      return(-1);    /* trigger: go to next picture */
950
    }
951
 
952
    Flush_Buffer32();
953
 
954
    /* decode slice header (may change quantizer_scale) */
955
    slice_vert_pos_ext = slice_header();
956
 
957
    if (base.priority_breakpoint!=1)
958
      ld = &base;
959
  }
960
 
961
  /* decode macroblock address increment */
962
  *MBAinc = Get_macroblock_address_increment();
963
 
964
  if (Fault_Flag)
965
  {
966
    printf("start_of_slice(): MBAinc unsuccessful\n");
967
    return(0);   /* trigger: go to next slice */
968
  }
969
 
970
  /* set current location */
971
  /* NOTE: the arithmetic used to derive macroblock_address below is
972
   *       equivalent to ISO/IEC 13818-2 section 6.3.17: Macroblock
973
   */
974
  *MBA = ((slice_vert_pos_ext<<7) + (code&255) - 1)*mb_width + *MBAinc - 1;
975
  *MBAinc = 1; /* first macroblock in slice: not skipped */
976
 
977
  /* reset all DC coefficient and motion vector predictors */
978
  /* reset all DC coefficient and motion vector predictors */
979
  /* ISO/IEC 13818-2 section 7.2.1: DC coefficients in intra blocks */
980
  dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
981
 
982
  /* ISO/IEC 13818-2 section 7.6.3.4: Resetting motion vector predictors */
983
  PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
984
  PMV[0][1][0]=PMV[0][1][1]=PMV[1][1][0]=PMV[1][1][1]=0;
985
 
986
  /* successfull: trigger decode macroblocks in slice */
987
  return(1);
988
}
989
 
990
 
991
/* ISO/IEC 13818-2 sections 7.2 through 7.5 */
992
static int decode_macroblock(macroblock_type, stwtype, stwclass,
993
  motion_type, dct_type, PMV, dc_dct_pred,
994
  motion_vertical_field_select, dmvector)
995
int *macroblock_type;
996
int *stwtype;
997
int *stwclass;
998
int *motion_type;
999
int *dct_type;
1000
int PMV[2][2][2];
1001
int dc_dct_pred[3];
1002
int motion_vertical_field_select[2][2];
1003
int dmvector[2];
1004
{
1005
  /* locals */
1006
  int quantizer_scale_code;
1007
  int comp;
1008
 
1009
  int motion_vector_count;
1010
  int mv_format;
1011
  int dmv;
1012
  int mvscale;
1013
  int coded_block_pattern;
1014
 
1015
  /* SCALABILITY: Data Patitioning */
1016
  if (base.scalable_mode==SC_DP)
1017
  {
1018
    if (base.priority_breakpoint<=2)
1019
      ld = &enhan;
1020
    else
1021
      ld = &base;
1022
  }
1023
 
1024
  /* ISO/IEC 13818-2 section 6.3.17.1: Macroblock modes */
1025
  macroblock_modes(macroblock_type, stwtype, stwclass,
1026
    motion_type, &motion_vector_count, &mv_format, &dmv, &mvscale,
1027
    dct_type);
1028
 
1029
  if (Fault_Flag) return(0);  /* trigger: go to next slice */
1030
 
1031
  if (*macroblock_type & MACROBLOCK_QUANT)
1032
  {
1033
    quantizer_scale_code = Get_Bits(5);
1034
 
1035
#ifdef TRACE
1036
    if (Trace_Flag)
1037
    {
1038
      printf("quantiser_scale_code (");
1039
      Print_Bits(quantizer_scale_code,5,5);
1040
      printf("): %d\n",quantizer_scale_code);
1041
    }
1042
#endif /* TRACE */
1043
 
1044
    /* ISO/IEC 13818-2 section 7.4.2.2: Quantizer scale factor */
1045
    if (ld->MPEG2_Flag)
1046
      ld->quantizer_scale =
1047
      ld->q_scale_type ? Non_Linear_quantizer_scale[quantizer_scale_code]
1048
       : (quantizer_scale_code << 1);
1049
    else
1050
      ld->quantizer_scale = quantizer_scale_code;
1051
 
1052
    /* SCALABILITY: Data Partitioning */
1053
    if (base.scalable_mode==SC_DP)
1054
      /* make sure base.quantizer_scale is valid */
1055
      base.quantizer_scale = ld->quantizer_scale;
1056
  }
1057
 
1058
  /* motion vectors */
1059
 
1060
 
1061
  /* ISO/IEC 13818-2 section 6.3.17.2: Motion vectors */
1062
 
1063
  /* decode forward motion vectors */
1064
  if ((*macroblock_type & MACROBLOCK_MOTION_FORWARD)
1065
    || ((*macroblock_type & MACROBLOCK_INTRA)
1066
    && concealment_motion_vectors))
1067
  {
1068
    if (ld->MPEG2_Flag)
1069
      motion_vectors(PMV,dmvector,motion_vertical_field_select,
1070
        0,motion_vector_count,mv_format,f_code[0][0]-1,f_code[0][1]-1,
1071
        dmv,mvscale);
1072
    else
1073
      motion_vector(PMV[0][0],dmvector,
1074
      forward_f_code-1,forward_f_code-1,0,0,full_pel_forward_vector);
1075
  }
1076
 
1077
  if (Fault_Flag) return(0);  /* trigger: go to next slice */
1078
 
1079
  /* decode backward motion vectors */
1080
  if (*macroblock_type & MACROBLOCK_MOTION_BACKWARD)
1081
  {
1082
    if (ld->MPEG2_Flag)
1083
      motion_vectors(PMV,dmvector,motion_vertical_field_select,
1084
        1,motion_vector_count,mv_format,f_code[1][0]-1,f_code[1][1]-1,0,
1085
        mvscale);
1086
    else
1087
      motion_vector(PMV[0][1],dmvector,
1088
        backward_f_code-1,backward_f_code-1,0,0,full_pel_backward_vector);
1089
  }
1090
 
1091
  if (Fault_Flag) return(0);  /* trigger: go to next slice */
1092
 
1093
  if ((*macroblock_type & MACROBLOCK_INTRA) && concealment_motion_vectors)
1094
    Flush_Buffer(1); /* remove marker_bit */
1095
 
1096
  if (base.scalable_mode==SC_DP && base.priority_breakpoint==3)
1097
    ld = &enhan;
1098
 
1099
  /* macroblock_pattern */
1100
  /* ISO/IEC 13818-2 section 6.3.17.4: Coded block pattern */
1101
  if (*macroblock_type & MACROBLOCK_PATTERN)
1102
  {
1103
    coded_block_pattern = Get_coded_block_pattern();
1104
 
1105
    if (chroma_format==CHROMA422)
1106
    {
1107
      /* coded_block_pattern_1 */
1108
      coded_block_pattern = (coded_block_pattern<<2) | Get_Bits(2);
1109
 
1110
#ifdef TRACE
1111
       if (Trace_Flag)
1112
       {
1113
         printf("coded_block_pattern_1: ");
1114
         Print_Bits(coded_block_pattern,2,2);
1115
         printf(" (%d)\n",coded_block_pattern&3);
1116
       }
1117
#endif /* TRACE */
1118
     }
1119
     else if (chroma_format==CHROMA444)
1120
     {
1121
      /* coded_block_pattern_2 */
1122
      coded_block_pattern = (coded_block_pattern<<6) | Get_Bits(6);
1123
 
1124
#ifdef TRACE
1125
      if (Trace_Flag)
1126
      {
1127
        printf("coded_block_pattern_2: ");
1128
        Print_Bits(coded_block_pattern,6,6);
1129
        printf(" (%d)\n",coded_block_pattern&63);
1130
      }
1131
#endif /* TRACE */
1132
    }
1133
  }
1134
  else
1135
    coded_block_pattern = (*macroblock_type & MACROBLOCK_INTRA) ?
1136
      (1<<block_count)-1 : 0;
1137
 
1138
  if (Fault_Flag) return(0);  /* trigger: go to next slice */
1139
 
1140
  /* decode blocks */
1141
  for (comp=0; comp<block_count; comp++)
1142
  {
1143
    /* SCALABILITY: Data Partitioning */
1144
    if (base.scalable_mode==SC_DP)
1145
    ld = &base;
1146
 
1147
    Clear_Block(comp);
1148
 
1149
    if (coded_block_pattern & (1<<(block_count-1-comp)))
1150
    {
1151
      if (*macroblock_type & MACROBLOCK_INTRA)
1152
      {
1153
        if (ld->MPEG2_Flag)
1154
          Decode_MPEG2_Intra_Block(comp,dc_dct_pred);
1155
        else
1156
          Decode_MPEG1_Intra_Block(comp,dc_dct_pred);
1157
      }
1158
      else
1159
      {
1160
        if (ld->MPEG2_Flag)
1161
          Decode_MPEG2_Non_Intra_Block(comp);
1162
        else
1163
          Decode_MPEG1_Non_Intra_Block(comp);
1164
      }
1165
 
1166
      if (Fault_Flag) return(0);  /* trigger: go to next slice */
1167
    }
1168
  }
1169
 
1170
  if(picture_coding_type==D_TYPE)
1171
  {
1172
    /* remove end_of_macroblock (always 1, prevents startcode emulation) */
1173
    /* ISO/IEC 11172-2 section 2.4.2.7 and 2.4.3.6 */
1174
    marker_bit("D picture end_of_macroblock bit");
1175
  }
1176
 
1177
  /* reset intra_dc predictors */
1178
  /* ISO/IEC 13818-2 section 7.2.1: DC coefficients in intra blocks */
1179
  if (!(*macroblock_type & MACROBLOCK_INTRA))
1180
    dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
1181
 
1182
  /* reset motion vector predictors */
1183
  if ((*macroblock_type & MACROBLOCK_INTRA) && !concealment_motion_vectors)
1184
  {
1185
    /* intra mb without concealment motion vectors */
1186
    /* ISO/IEC 13818-2 section 7.6.3.4: Resetting motion vector predictors */
1187
    PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
1188
    PMV[0][1][0]=PMV[0][1][1]=PMV[1][1][0]=PMV[1][1][1]=0;
1189
  }
1190
 
1191
  /* special "No_MC" macroblock_type case */
1192
  /* ISO/IEC 13818-2 section 7.6.3.5: Prediction in P pictures */
1193
  if ((picture_coding_type==P_TYPE)
1194
    && !(*macroblock_type & (MACROBLOCK_MOTION_FORWARD|MACROBLOCK_INTRA)))
1195
  {
1196
    /* non-intra mb without forward mv in a P picture */
1197
    /* ISO/IEC 13818-2 section 7.6.3.4: Resetting motion vector predictors */
1198
    PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
1199
 
1200
    /* derive motion_type */
1201
    /* ISO/IEC 13818-2 section 6.3.17.1: Macroblock modes, frame_motion_type */
1202
    if (picture_structure==FRAME_PICTURE)
1203
      *motion_type = MC_FRAME;
1204
    else
1205
    {
1206
      *motion_type = MC_FIELD;
1207
      /* predict from field of same parity */
1208
      motion_vertical_field_select[0][0] = (picture_structure==BOTTOM_FIELD);
1209
    }
1210
  }
1211
 
1212
  if (*stwclass==4)
1213
  {
1214
    /* purely spatially predicted macroblock */
1215
    /* ISO/IEC 13818-2 section 7.7.5.1: Resetting motion vector predictions */
1216
    PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
1217
    PMV[0][1][0]=PMV[0][1][1]=PMV[1][1][0]=PMV[1][1][1]=0;
1218
  }
1219
 
1220
  /* successfully decoded macroblock */
1221
  return(1);
1222
 
1223
} /* decode_macroblock */
1224
 
1225