← Back to branch summary

~ubuntu-branches/ubuntu/trusty/mpeg4ip/trusty

« back to all changes in this revision

Viewing changes to common/video/iso-mpeg4/src/sys_block.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Mario Limonciello
  • Date: 2008-01-12 15:59:56 UTC
  • Revision ID: james.westby@ubuntu.com-20080112155956-1vznw5njidvrh649
Tags: upstream-1.6dfsg
Import upstream version 1.6dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
common/video/iso-mpeg4/src/sys_block.cpp
 
1
/*************************************************************************
 
2
 
 
3
This software module was originally developed by 
 
4
 
 
5
        Ming-Chieh Lee (mingcl@microsoft.com), Microsoft Corporation
 
6
        Wei-ge Chen (wchen@microsoft.com), Microsoft Corporation
 
7
        Bruce Lin (blin@microsoft.com), Microsoft Corporation
 
8
        Chuang Gu (chuanggu@microsoft.com), Microsoft Corporation
 
9
        Simon Winder (swinder@microsoft.com), Microsoft Corporation
 
10
        (date: March, 1996)
 
11
and edited by
 
12
        Wei Wu (weiwu@stallion.risc.rockwell.com), Rockwell Science Center
 
13
 
 
14
in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
 
15
This software module is an implementation of a part of one or more MPEG-4 Video tools 
 
16
as specified by the MPEG-4 Video. 
 
17
ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
 
18
thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
 
19
Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
 
20
The original developer of this software module and his/her company, 
 
21
the subsequent editors and their companies, 
 
22
and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
 
23
Copyright is not released for non MPEG-4 Video conforming products. 
 
24
Microsoft retains full right to use the code for his/her own purpose, 
 
25
assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
 
26
This copyright notice must be included in all copies or derivative works. 
 
27
 
 
28
Copyright (c) 1996, 1997.
 
29
 
 
30
Module Name:
 
31
 
 
32
        block.cpp
 
33
 
 
34
Abstract:
 
35
 
 
36
        Block base class
 
37
 
 
38
Revision History:
 
39
        May. 9   1998:  add boundary by Hyundai Electronics 
 
40
                                  Cheol-Soo Park (cspark@super5.hyundai.co.kr) 
 
41
*************************************************************************/
 
42
 
 
43
#include <stdlib.h>
 
44
#include <math.h>
 
45
#include "typeapi.h"
 
46
#include "codehead.h"
 
47
#include "mode.hpp"
 
48
#ifndef __GLOBAL_VAR_
 
49
#define __GLOBAL_VAR_
 
50
#endif
 
51
#include "global.hpp"
 
52
#include "bitstrm.hpp"
 
53
#include "entropy.hpp"
 
54
#include "huffman.hpp"
 
55
#include "dct.hpp"
 
56
#include "vopses.hpp"
 
57
 
 
58
#ifdef __MFC_
 
59
#ifdef _DEBUG
 
60
#undef THIS_FILE
 
61
static char BASED_CODE THIS_FILE[] = __FILE__;
 
62
#endif
 
63
 
 
64
#define new DEBUG_NEW                              
 
65
#endif // __MFC_
 
66
 
 
67
Int divroundnearest(Int i, Int iDenom)
 
68
{
 
69
        assert(iDenom>0);
 
70
        if(i>=0)
 
71
                return (i+(iDenom>>1))/iDenom;
 
72
        else
 
73
                return (i-(iDenom>>1))/iDenom;
 
74
}
 
75
 
 
76
Void CVideoObject::inverseQuantizeIntraDc (Int* rgiCoefQ, Int iDcScaler)
 
77
{
 
78
#ifdef NO_APPENDIXF
 
79
                m_rgiDCTcoef [0] = (Float) rgiCoefQ [0] * 8;
 
80
#else
 
81
                m_rgiDCTcoef [0] = rgiCoefQ [0] * iDcScaler;
 
82
/*
 
83
                if (iQP <= 4)
 
84
                        m_rgiDCTcoef [0] = rgiCoefQ [0] * 8;
 
85
                else if (iQP >= 5 && iQP <= 8)
 
86
                        m_rgiDCTcoef [0] = rgiCoefQ [0] * 2 * iQP;
 
87
                else if (iQP >= 9 && iQP <= 24)
 
88
                        m_rgiDCTcoef [0] = rgiCoefQ [0] * (iQP + 8);
 
89
                else
 
90
                        m_rgiDCTcoef [0] = rgiCoefQ [0] * (iQP * 2 - 16);
 
91
*/
 
92
#endif
 
93
}
 
94
 
 
95
Void CVideoObject::inverseQuantizeDCTcoefH263 (Int* rgiCoefQ, Int iStart, Int iQP)
 
96
{
 
97
        Int i;
 
98
        for (i = iStart; i < BLOCK_SQUARE_SIZE; i++) {
 
99
                if (rgiCoefQ[i]) {
 
100
                        if (iQP % 2 == 1)                       //?
 
101
                                m_rgiDCTcoef [i] = iQP * (2 * abs (rgiCoefQ[i]) + 1);
 
102
                        else
 
103
                                m_rgiDCTcoef [i] = iQP * (2 * abs (rgiCoefQ[i]) + 1) - 1;
 
104
                        m_rgiDCTcoef [i] = sign (rgiCoefQ[i]) * m_rgiDCTcoef [i] ;
 
105
                }
 
106
                else
 
107
                        m_rgiDCTcoef [i] = 0;
 
108
        }
 
109
}
 
110
 
 
111
Void CVideoObject::inverseQuantizeIntraDCTcoefMPEG (Int* rgiCoefQ, Int iStart, Int iQP,
 
112
                                                                                                        Bool bUseAlphaMatrix, Int iAuxComp)
 
113
{
 
114
        assert (iQP != 0);
 
115
        Int iSum = m_rgiDCTcoef [0];
 
116
        Bool bCoefQAllZero = (m_rgiDCTcoef [0] == 0)? TRUE : FALSE;
 
117
        Int *piQuantizerMatrix;
 
118
        if(bUseAlphaMatrix)
 
119
                piQuantizerMatrix = m_volmd.rgiIntraQuantizerMatrixAlpha[iAuxComp];
 
120
        else
 
121
                piQuantizerMatrix = m_volmd.rgiIntraQuantizerMatrix;
 
122
 
 
123
        Int iMaxVal = 1<<(m_volmd.nBits+3); // NBIT
 
124
        UInt i;
 
125
        for (i = iStart; i < BLOCK_SQUARE_SIZE; i++) {
 
126
                if (rgiCoefQ [i] == 0)
 
127
                        m_rgiDCTcoef [i] = 0;
 
128
                else {
 
129
                        m_rgiDCTcoef [i] = iQP * rgiCoefQ [i] * piQuantizerMatrix [i] / 8;
 
130
/* NBIT: change
 
131
                        m_rgiDCTcoef [i] = checkrange (m_rgiDCTcoef [i], -2048, 2047);
 
132
*/
 
133
                        m_rgiDCTcoef [i] = checkrange (m_rgiDCTcoef [i], -iMaxVal, iMaxVal-1);
 
134
                        bCoefQAllZero = FALSE;
 
135
                }
 
136
                iSum ^= m_rgiDCTcoef [i];
 
137
        }
 
138
        if (!bCoefQAllZero) {
 
139
                if ((iSum & 0x00000001) == 0)
 
140
                        m_rgiDCTcoef [i - 1] ^= 0x00000001;
 
141
        }
 
142
}
 
143
 
 
144
Void CVideoObject::inverseQuantizeInterDCTcoefMPEG (Int* rgiCoefQ, Int iStart, Int iQP,
 
145
                                                                                                        Bool bUseAlphaMatrix, Int iAuxComp)
 
146
{
 
147
        assert (iQP != 0);
 
148
        Int iSum = 0;
 
149
        Bool bCoefQAllZero = TRUE;
 
150
        Int *piQuantizerMatrix;
 
151
        if(bUseAlphaMatrix)
 
152
                piQuantizerMatrix = m_volmd.rgiInterQuantizerMatrixAlpha[iAuxComp];
 
153
        else
 
154
                piQuantizerMatrix = m_volmd.rgiInterQuantizerMatrix;
 
155
 
 
156
        Int iMaxVal = 1<<(m_volmd.nBits+3); // NBIT
 
157
        UInt i;
 
158
        for (i = iStart; i < BLOCK_SQUARE_SIZE; i++)    {
 
159
                if (rgiCoefQ [i] == 0)
 
160
                        m_rgiDCTcoef [i] = 0;
 
161
                else {
 
162
                        m_rgiDCTcoef [i] = (iQP * (rgiCoefQ [i] * 2 + sign(rgiCoefQ [i])) * piQuantizerMatrix [i]) / 16;
 
163
/* NBIT: change
 
164
                        m_rgiDCTcoef [i] = checkrange (m_rgiDCTcoef [i], -2048, 2047);
 
165
*/
 
166
                        m_rgiDCTcoef [i] = checkrange (m_rgiDCTcoef [i], -iMaxVal, iMaxVal-1);
 
167
                        bCoefQAllZero = FALSE;
 
168
                }
 
169
                iSum ^= m_rgiDCTcoef [i];
 
170
        }
 
171
        if (!bCoefQAllZero) {
 
172
                if ((iSum & 0x00000001) == 0)
 
173
                        m_rgiDCTcoef [i - 1] ^= 0x00000001;
 
174
        }
 
175
}
 
176
 
 
177
const BlockMemory CVideoObject::findPredictorBlock (
 
178
        Int iBlkOrig, 
 
179
        IntraPredDirection predDir,
 
180
        const MacroBlockMemory* pmbmLeft, 
 
181
        const MacroBlockMemory* pmbmTop,
 
182
        const MacroBlockMemory* pmbmLeftTop,
 
183
        const MacroBlockMemory* pmbmCurr,
 
184
        const CMBMode* pmbmdLeft, 
 
185
        const CMBMode* pmbmdTop,
 
186
        const CMBMode* pmbmdLeftTop,
 
187
        const CMBMode* pmbmdCurr,
 
188
        Int& iQPpred
 
189
)
 
190
{
 
191
        const BlockMemory blkmRet = NULL;
 
192
// MAC
 
193
  Int iBlk, iAuxComp = 0;
 
194
  if (iBlkOrig<7)
 
195
    iBlk = iBlkOrig;
 
196
  else {
 
197
    iAuxComp = (iBlkOrig-7)/4;
 
198
    iBlk = ((iBlkOrig-7)&3)+7;
 
199
  }
 
200
//~MAC
 
201
  
 
202
        /*BBM// Added for Boundary by Hyundai(1998-5-9)
 
203
        if (m_vopmd.bInterlace && pmbmdCurr->m_bMerged [0])
 
204
                swapTransparentModes ((CMBMode*)pmbmdCurr, BBM);
 
205
        // End of Hyundai(1998-5-9)*/
 
206
        if (predDir == HORIZONTAL)      {
 
207
                switch (iBlk)   {
 
208
                case Y_BLOCK1:
 
209
                        if (pmbmLeft != NULL && 
 
210
                                (pmbmdLeft->m_dctMd == INTRA || pmbmdLeft->m_dctMd == INTRAQ) &&
 
211
                                pmbmdLeft->m_rgTranspStatus [Y_BLOCK2] != ALL)  {
 
212
                                blkmRet = pmbmLeft->rgblkm [Y_BLOCK2 - 1];
 
213
                                iQPpred = pmbmdLeft->m_stepSize;
 
214
                        }
 
215
                        break;
 
216
                case Y_BLOCK2:
 
217
                        if (pmbmdCurr->m_rgTranspStatus [Y_BLOCK1] != ALL)      {
 
218
                                blkmRet = pmbmCurr->rgblkm [Y_BLOCK1 - 1];
 
219
                                iQPpred = pmbmdCurr->m_stepSize;
 
220
                        }
 
221
                        break;
 
222
                case Y_BLOCK3:
 
223
                        if (pmbmLeft != NULL && 
 
224
                                (pmbmdLeft->m_dctMd == INTRA || pmbmdLeft->m_dctMd == INTRAQ) &&
 
225
                                pmbmdLeft->m_rgTranspStatus [Y_BLOCK4] != ALL)  {
 
226
                                blkmRet = pmbmLeft->rgblkm [Y_BLOCK4 - 1];
 
227
                                iQPpred = pmbmdLeft->m_stepSize;
 
228
                        }
 
229
                        break;
 
230
                case Y_BLOCK4:
 
231
                        if (pmbmdCurr->m_rgTranspStatus [Y_BLOCK3] != ALL)      {
 
232
                                blkmRet = pmbmCurr->rgblkm [Y_BLOCK3 - 1];
 
233
                                iQPpred = pmbmdCurr->m_stepSize;        
 
234
                        }
 
235
                        break;
 
236
                case A_BLOCK1:
 
237
                        if (pmbmLeft != NULL && 
 
238
                                (pmbmdLeft->m_dctMd == INTRA || pmbmdLeft->m_dctMd == INTRAQ) &&
 
239
                                pmbmdLeft->m_rgTranspStatus [Y_BLOCK2] != ALL)  {
 
240
                                blkmRet = pmbmLeft->rgblkm [A_BLOCK2 + iAuxComp*4 - 1]; 
 
241
                                iQPpred = pmbmdLeft->m_stepSizeAlpha;   
 
242
                        }
 
243
                        break;
 
244
                case A_BLOCK2:
 
245
                        if (pmbmdCurr->m_rgTranspStatus [Y_BLOCK1] != ALL)      {
 
246
                                blkmRet = pmbmCurr->rgblkm [A_BLOCK1 + iAuxComp*4 - 1]; 
 
247
                                iQPpred = pmbmdCurr->m_stepSizeAlpha;   
 
248
                        }
 
249
                        break;
 
250
                case A_BLOCK3:
 
251
                        if (pmbmLeft != NULL && 
 
252
                                (pmbmdLeft->m_dctMd == INTRA || pmbmdLeft->m_dctMd == INTRAQ) &&
 
253
                                pmbmdLeft->m_rgTranspStatus [Y_BLOCK4] != ALL)  {
 
254
                                blkmRet = pmbmLeft->rgblkm [A_BLOCK4 + iAuxComp*4 - 1];
 
255
                                iQPpred = pmbmdLeft->m_stepSizeAlpha;   
 
256
                        }
 
257
                        break;
 
258
                case A_BLOCK4:
 
259
                        if (pmbmdCurr->m_rgTranspStatus [Y_BLOCK3] != ALL)      {
 
260
                                blkmRet = pmbmCurr->rgblkm [A_BLOCK3 + iAuxComp*4 - 1];        
 
261
                                iQPpred = pmbmdCurr->m_stepSizeAlpha;   
 
262
                        }
 
263
                        break;
 
264
                default:                                                                //U, V block
 
265
                        if (pmbmLeft != NULL && 
 
266
                                (pmbmdLeft->m_dctMd == INTRA || pmbmdLeft->m_dctMd == INTRAQ) &&
 
267
                                pmbmdLeft->m_rgTranspStatus [ALL_Y_BLOCKS] != ALL)      {
 
268
                                blkmRet = pmbmLeft->rgblkm [iBlk - 1];
 
269
                                iQPpred = pmbmdLeft->m_stepSize;        
 
270
                        }
 
271
                }
 
272
        }
 
273
        else if  (predDir == VERTICAL)  {
 
274
                switch (iBlk)   {
 
275
                case Y_BLOCK1:
 
276
                        if (pmbmTop != NULL && 
 
277
                                (pmbmdTop->m_dctMd == INTRA || pmbmdTop->m_dctMd == INTRAQ) &&
 
278
                                pmbmdTop->m_rgTranspStatus [Y_BLOCK3] != ALL)   {
 
279
                                blkmRet = pmbmTop->rgblkm [Y_BLOCK3 - 1];
 
280
                                iQPpred = pmbmdTop->m_stepSize; 
 
281
                        }
 
282
                        break;
 
283
                case Y_BLOCK2:
 
284
                        if (pmbmTop != NULL && 
 
285
                                (pmbmdTop->m_dctMd == INTRA || pmbmdTop->m_dctMd == INTRAQ) &&
 
286
                                pmbmdTop->m_rgTranspStatus [Y_BLOCK4] != ALL)   {
 
287
                                blkmRet = pmbmTop->rgblkm [Y_BLOCK4 - 1];
 
288
                                iQPpred = pmbmdTop->m_stepSize; 
 
289
                        }
 
290
                        break;
 
291
                case Y_BLOCK3:
 
292
                        if (pmbmdCurr->m_rgTranspStatus [Y_BLOCK1] != ALL)      {
 
293
                                blkmRet = pmbmCurr->rgblkm [Y_BLOCK1 - 1];
 
294
                                iQPpred = pmbmdCurr->m_stepSize;        
 
295
                        }
 
296
                        break;
 
297
                case Y_BLOCK4:
 
298
                        if (pmbmdCurr->m_rgTranspStatus [Y_BLOCK2] != ALL)      {
 
299
                                blkmRet = pmbmCurr->rgblkm [Y_BLOCK2 - 1];
 
300
                                iQPpred = pmbmdCurr->m_stepSize;        
 
301
                        }
 
302
                        break;
 
303
                case A_BLOCK1:
 
304
                        if (pmbmTop != NULL && 
 
305
                                (pmbmdTop->m_dctMd == INTRA || pmbmdTop->m_dctMd == INTRAQ) &&
 
306
                                pmbmdTop->m_rgTranspStatus [Y_BLOCK3] != ALL)   {
 
307
                                blkmRet = pmbmTop->rgblkm [A_BLOCK3 + iAuxComp*4 - 1];
 
308
                                iQPpred = pmbmdTop->m_stepSizeAlpha;    
 
309
                        }
 
310
                        break;
 
311
                case A_BLOCK2:
 
312
                        if (pmbmTop != NULL && 
 
313
                                (pmbmdTop->m_dctMd == INTRA || pmbmdTop->m_dctMd == INTRAQ) &&
 
314
                                pmbmdTop->m_rgTranspStatus [Y_BLOCK4] != ALL)   {
 
315
                                blkmRet = pmbmTop->rgblkm [A_BLOCK4 + iAuxComp*4 - 1];
 
316
                                iQPpred = pmbmdTop->m_stepSizeAlpha;    
 
317
                        }
 
318
                        break;
 
319
                case A_BLOCK3:
 
320
                        if (pmbmdCurr->m_rgTranspStatus [Y_BLOCK1] != ALL)      {
 
321
                                blkmRet = pmbmCurr->rgblkm [A_BLOCK1 + iAuxComp*4 - 1];
 
322
                                iQPpred = pmbmdCurr->m_stepSizeAlpha;   
 
323
                        }
 
324
                        break;
 
325
                case A_BLOCK4:
 
326
                        if (pmbmdCurr->m_rgTranspStatus [Y_BLOCK2] != ALL)      {
 
327
                                blkmRet = pmbmCurr->rgblkm [A_BLOCK2 + iAuxComp*4 - 1];
 
328
                                iQPpred = pmbmdCurr->m_stepSizeAlpha;   
 
329
                        }
 
330
                        break;
 
331
                default:                                                                //U, V block
 
332
                        if (pmbmTop != NULL && 
 
333
                                (pmbmdTop->m_dctMd == INTRA || pmbmdTop->m_dctMd == INTRAQ) &&
 
334
                                pmbmdTop->m_rgTranspStatus [ALL_Y_BLOCKS] != ALL)       {
 
335
                                blkmRet = pmbmTop->rgblkm [iBlk - 1];
 
336
                                iQPpred = pmbmdTop->m_stepSize; 
 
337
                        }
 
338
                }
 
339
        }
 
340
        else if (predDir == DIAGONAL)   {
 
341
                switch (iBlk)   {
 
342
                case Y_BLOCK1:
 
343
                        if (pmbmLeftTop != NULL && 
 
344
                                (pmbmdLeftTop->m_dctMd == INTRA || pmbmdLeftTop->m_dctMd == INTRAQ) &&
 
345
                                pmbmdLeftTop->m_rgTranspStatus [Y_BLOCK4] != ALL)       {
 
346
                                blkmRet = pmbmLeftTop->rgblkm [Y_BLOCK4 - 1];
 
347
                                iQPpred = pmbmdLeftTop->m_stepSize;     
 
348
                        }
 
349
                        break;
 
350
                case Y_BLOCK2:
 
351
                        if (pmbmTop != NULL && 
 
352
                                (pmbmdTop->m_dctMd == INTRA || pmbmdTop->m_dctMd == INTRAQ) &&
 
353
                                pmbmdTop->m_rgTranspStatus [Y_BLOCK3] != ALL)   {
 
354
                                blkmRet = pmbmTop->rgblkm [Y_BLOCK3 - 1];
 
355
                                iQPpred = pmbmdTop->m_stepSize; 
 
356
                        }
 
357
                        break;
 
358
                case Y_BLOCK3:
 
359
                        if (pmbmLeft != NULL && 
 
360
                                (pmbmdLeft->m_dctMd == INTRA || pmbmdLeft->m_dctMd == INTRAQ) &&
 
361
                                pmbmdLeft->m_rgTranspStatus [Y_BLOCK2] != ALL)  {
 
362
                                blkmRet = pmbmLeft->rgblkm [Y_BLOCK2 - 1];
 
363
                                iQPpred = pmbmdLeft->m_stepSize;        
 
364
                        }
 
365
                        break;
 
366
                case Y_BLOCK4:
 
367
                        if (pmbmdCurr->m_rgTranspStatus [Y_BLOCK1] != ALL)      {
 
368
                                blkmRet = pmbmCurr->rgblkm [Y_BLOCK1 - 1];
 
369
                                iQPpred = pmbmdCurr->m_stepSize;        
 
370
                        }
 
371
                        break;
 
372
                case A_BLOCK1:
 
373
                        if (pmbmLeftTop != NULL && 
 
374
                                (pmbmdLeftTop->m_dctMd == INTRA || pmbmdLeftTop->m_dctMd == INTRAQ) &&
 
375
                                pmbmdLeftTop->m_rgTranspStatus [Y_BLOCK4] != ALL)       {
 
376
                                blkmRet = pmbmLeftTop->rgblkm [A_BLOCK4 + iAuxComp*4 - 1];
 
377
                                iQPpred = pmbmdLeftTop->m_stepSizeAlpha;        
 
378
                        }
 
379
                        break;
 
380
                case A_BLOCK2:
 
381
                        if (pmbmTop != NULL && 
 
382
                                (pmbmdTop->m_dctMd == INTRA || pmbmdTop->m_dctMd == INTRAQ) &&
 
383
                                pmbmdTop->m_rgTranspStatus [Y_BLOCK3] != ALL)   {
 
384
                                blkmRet = pmbmTop->rgblkm [A_BLOCK3 + iAuxComp*4 - 1];
 
385
                                iQPpred = pmbmdTop->m_stepSizeAlpha;    
 
386
                        }
 
387
                        break;
 
388
                case A_BLOCK3:
 
389
                        if (pmbmLeft != NULL && 
 
390
                                (pmbmdLeft->m_dctMd == INTRA || pmbmdLeft->m_dctMd == INTRAQ) &&
 
391
                                pmbmdLeft->m_rgTranspStatus [Y_BLOCK2] != ALL)  {
 
392
                                blkmRet = pmbmLeft->rgblkm [A_BLOCK2 + iAuxComp*4 - 1];
 
393
                                iQPpred = pmbmdLeft->m_stepSizeAlpha;   
 
394
                        }
 
395
                        break;
 
396
                case A_BLOCK4:
 
397
                        if (pmbmdCurr->m_rgTranspStatus [Y_BLOCK1] != ALL)      {
 
398
                                blkmRet = pmbmCurr->rgblkm [A_BLOCK1 + iAuxComp*4 - 1];
 
399
                                iQPpred = pmbmdCurr->m_stepSizeAlpha;   
 
400
                        }
 
401
                        break;
 
402
                default:                                                                //U, V block
 
403
                        if (pmbmLeftTop != NULL && 
 
404
                                (pmbmdLeftTop->m_dctMd == INTRA || pmbmdLeftTop->m_dctMd == INTRAQ) &&
 
405
                                pmbmdLeftTop->m_rgTranspStatus [ALL_Y_BLOCKS] != ALL)   {
 
406
                                blkmRet = pmbmLeftTop->rgblkm [iBlk - 1];
 
407
                                iQPpred = pmbmdLeftTop->m_stepSize;     
 
408
                        }
 
409
                }
 
410
        }
 
411
        else 
 
412
                assert (FALSE);
 
413
        /*BBM// Added for Boundary by Hyundai(1998-5-9)
 
414
        if (m_vopmd.bInterlace && pmbmdCurr->m_bMerged [0])
 
415
                swapTransparentModes ((CMBMode*)pmbmdCurr, BBS);
 
416
        // End of Hyundai(1998-5-9)*/
 
417
        return (blkmRet);
 
418
}