1 /*

     2 * Copyright (c) 2010 Ixonos Plc.

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - Initial contribution

    11 *

    12 * Contributors:

    13 * Ixonos Plc

    14 *

    15 * Description:  

    16 * Implementation for MPEG4(H263) video transcoder. Operations may include:

    17 * 1. Bitstream Copying 

    18 * 2. BlackAndWhite Effect

    19 * 3. MPEG4 to VDT_RESYN (Simple profile)

    20 * 4. H.263 -> MPEG4 (Open Loop structure, no MV refinement)

    21 * 5. MPEG4 -> H263, partial implemented 

    22 *

    23 * We call functions 2~5 as transcoding functions since they involve MB level data processing

    24 *    

    25 * Note:

    26 * When RVLC is used and errors occur during  forward decoding, 

    27 * We don't do backward transcoding, the rest of the data is discarded, 

    28 *

    29 */

    30 

    31 

    32 

    33 /* 

    34 * Includes

    35 */

    36 #include "MPEG4Transcoder.h"

    37 #include "debug.h"

    38 

    39 /* Print macro */

    40 #ifdef _DEBUG

    41 #include <e32svr.h>

    42 #define PRINT(x) RDebug::Print x

    43 #else

    44 #define PRINT(x)

    45 #endif

    46 

    47 /* 

    48 * Defines and Typedefs

    49 */

    50 typedef unsigned int         uint32;

    51 

    52 #define EInternalAssertionFailure 1000

    53 #define VDT_NO_DATA(a, b, c, d) ((a) == (c) && (b) == (d))

    54 

    55 const int KDataNotValid = -1; 

    56 const int KMpeg4VopTimeIncrementResolutionLength = 16; 

    57 const int KOutputMpeg4TimeIncResolution = 30000;

    58 const int KShortHeaderMpeg4VosSize = 14; 

    59 const int KH263ToMpeg4VosSize = 28; 

    60 

    61 

    62 

    63 /*Bit stream formating*/

    64 #define WRITE32(op, x) sPutBits((op), 16, ((uint32)(x)) >> 16);       \

    65 sPutBits((op), 16, (x) & 0x0000ffff)

    66 

    67 /* 

    68 * Constants 

    69 */

    70 #ifdef _DEBUG

    71 const TUint KInitialBufferSize = 200000; /* MPEG4 Simple Visual Profile (Levels 0,1,2,3) initial frame data buffer size vga support */

    72 #endif

    73                                                                                 /* 

    74                                                                                 * Function Declarations 

    75 */

    76 

    77 //Static Functions 

    78 

    79 static void sStuffBitsH263(bibBuffer_t *outBuffer);

    80 static TVedVideoBitstreamMode sGetMPEG4Mode(int error_resilience_disable, int dp, int rvlc);

    81 static int sFindCBP(int *mbdata, int fUseIntraDCVLC);

    82 

    83 

    84 

    85 void vdtPutInterMBCMT(bibBuffer_t *outBuffer, int coeffStart, int *coeff, int *numTextureBits, int svh);

    86 void vdtPutIntraMBCMT(bibBuffer_t *outBuffer, int *coeff, int *numTextureBits, int index,  int skipDC, int skipAC);

    87 void vbmEncodeMVDifferential(int32 mvdx, int32 mvdy, int32 fCode, bibBuffer_t *outBuffer);

    88 void vbmGetH263IMCBPC(int lDQuant, int vopCodingType, int colorEffect, int cbpy, int& mcbpcVal, int& len);

    89 void vbmGetH263PMCBPC(int lDQuant, int colorEffect, int cbpy, int& mcbpcVal, int& len);

    90 tBool vbmMVOutsideBound(tMBPosition *mbPos, tMotionVector* bestMV, tBool halfPixel);

    91 void vbmMvPrediction(tMBInfo *mbi, int32 mBCnt, tMotionVector *predMV,  int32 mbinWidth);

    92 void vbmPutInterMB(tMBPosition* mbPos, bibBuffer_t *outBuf, dmdPParam_t *paramMB, tMotionVector *initPred, 

    93                                      int32 noOfPredictors, u_int32 vopWidth, u_int32 vopHeight, int32 searchRange, 

    94                                      int32 mbNo, int32* numTextureBits, int16 colorEffect, tMBInfo *mbsinfo);

    95 

    96 void sPutBits (bibBuffer_t *buf, int numBits, unsigned int value);  //forward decl

    97 

    98 /* 

    99 * Function Definitions 

   100 */

   101 

   102 /*

   103 * sStuffBitsH263

   104 *

   105 * Parameters: 

   106 *    outBuffer    output buffer

   107 *

   108 * Function:

   109 *    This function stuffs bits for H.263 format

   110 * Returns:

   111 *    None

   112 * Error codes:

   113 *    None.

   114 *

   115 */

   116 static void sStuffBitsH263(bibBuffer_t *outBuffer)

   117 {

   118     const int stuffingBits[8][2] = { {1,0}, {2,0}, {3,0}, {4,0}, {5,0}, {6,0}, {7,0}, {0,0} };

   119     

   120     VDTASSERT(outBuffer->baseAddr);

   121     

   122     /* find the number of stuffing bits to insert in the output buffer */

   123     int bi = outBuffer->bitIndex;

   124     int newNumBits = stuffingBits[bi][0]; 

   125     int newValue = stuffingBits[bi][1]; 

   126     sPutBits(outBuffer, newNumBits, newValue);

   127         

   128     return;

   129 }

   130 

   131 

   132 

   133 /*

   134 * sGetMPEG4Mode

   135 *

   136 * Parameters: 

   137 *    

   138 *

   139 * Function:

   140 *    This function gets the mode of the MPEG-4 bitstream

   141 * Returns:

   142 *    Nothing

   143 * Error codes:

   144 *    None.

   145 *

   146 */

   147 static TVedVideoBitstreamMode sGetMPEG4Mode(int error_resilience_disable, int dp, int rvlc)

   148 {

   149     TVedVideoBitstreamMode mode = EVedVideoBitstreamModeUnknown;

   150     int combination = ((!error_resilience_disable) << 2) | (dp << 1) | rvlc;

   151     switch (combination)

   152     {

   153         case 0:

   154             mode = EVedVideoBitstreamModeMPEG4Regular;

   155             break;

   156         case 2:

   157             mode = EVedVideoBitstreamModeMPEG4DP;

   158             break;

   159         case 3:

   160             mode = EVedVideoBitstreamModeMPEG4DP_RVLC;

   161             break;

   162         case 4:

   163             mode = EVedVideoBitstreamModeMPEG4Resyn;

   164             break;

   165         case 6:

   166             mode = EVedVideoBitstreamModeMPEG4Resyn_DP;

   167             break;

   168         case 7:

   169             mode = EVedVideoBitstreamModeMPEG4Resyn_DP_RVLC;

   170             break;

   171         default:

   172             mode = EVedVideoBitstreamModeUnknown;

   173     }

   174     

   175     return mode;

   176 }

   177 

   178 

   179 /* {{-output"vdtGetVideoBitstreamInfo.txt"}} */

   180 /*

   181 * sFindCBP

   182 *

   183 * Parameters: 

   184 *    mbdata          Contains the actual MB data to be quantized

   185 *    fUseIntraDCVLC  ON for INTRA, OFF for INTER

   186 *

   187 * Function:

   188 *    This function finds the coded bit pattern of the MB 

   189 * Returns:

   190 *    Coded Block Pattern.

   191 * Error codes:

   192 *    None.

   193 *

   194 */

   195 static int sFindCBP(int *mbdata, int fUseIntraDCVLC)

   196 {

   197     int coeffCnt;

   198     int *block;

   199     int blkCnt;

   200     int cbpFlag = 0;

   201     int codedBlockPattern = 0;

   202 

   203     for (blkCnt = 0; blkCnt < 6; blkCnt++)

   204     {   

   205         cbpFlag = 0;

   206         codedBlockPattern <<= 1;

   207         block = &mbdata[blkCnt * BLOCK_COEFF_SIZE];

   208         for (coeffCnt = fUseIntraDCVLC; coeffCnt < BLOCK_COEFF_SIZE;

   209              coeffCnt++)

   210              {

   211                  if (block[coeffCnt])

   212                  {

   213                      cbpFlag = 1;

   214                      codedBlockPattern |= cbpFlag;

   215                      break;

   216                  }

   217              }

   218     }

   219     

   220     return codedBlockPattern;

   221 }   

   222 

   223 

   224 

   225 

   226 

   227 

   228 /* {{-output"sPutBits.txt"}} */

   229 /*

   230 * sPutBits

   231 *

   232 * Parameters:

   233 *          outBuf           output buffer

   234 *           numBits         number of bits to output

   235 *           value           new value

   236 *

   237 * Function:

   238 *    This function puts some bits to the output buffer

   239 * Returns:

   240 *    Nothing.

   241 * Error codes:

   242 *    None.

   243 *

   244 */

   245 void sPutBits (bibBuffer_t *buf, int numBits, unsigned int value)

   246 {

   247     

   248     bibEditParams_t edParam;

   249     

   250     edParam.curNumBits = edParam.newNumBits = numBits;

   251     edParam.StartByteIndex = edParam.StartBitIndex = 0; /* used for source buffer only  */

   252     edParam.newValue = value;                           /* use value 128, encoded as codeword "1111 1111" = 255 */

   253     

   254     CopyBufferEdit((bibBuffer_t*)NULL, buf, &edParam, 0); 

   255 }

   256 

   257 

   258 

   259 /*

   260 * GetTimeIncPosition

   261 *    

   262 *

   263 * Parameters:

   264 *    hInstance                  instance handle

   265 *

   266 * Function:

   267 *    Calculates the time increment position for the current VOP.

   268 *

   269 * Returns:

   270 *    VDX error codes

   271 *    

   272 */

   273 

   274 int GetTimeIncPosition(

   275    bibBuffer_t *inBuffer,

   276    const vdxGetVopHeaderInputParam_t *inpParam,

   277    vdxVopHeader_t *header,

   278    int * ModuloByteIndex,

   279    int * ModuloBitIndex,

   280    int * ByteIndex,

   281    int * BitIndex,

   282    int *bitErrorIndication)

   283 /* {{-output"vdxGetVopHeader.txt"}} */

   284 {

   285   /* Get VOP header */

   286     int ret = vdxGetVopHeader(inBuffer, inpParam, header, 

   287         ModuloByteIndex, ModuloBitIndex, ByteIndex, BitIndex,

   288         bitErrorIndication);

   289     

   290     return ret;

   291     

   292 }

   293 

   294 

   295 

   296 /*

   297 * CopyEditVop

   298 *    

   299 *

   300 * Parameters:

   301 *    hInstance                  instance handle

   302 *

   303 * Function:

   304 *    This function copies the VOP header with edited time stamps of the VOP.

   305 *

   306 * Returns:

   307 *    TX error codes

   308 */

   309 

   310 int CopyEditVop(vdeHInstance_t hInstance, int aNrOfBytesToSkip, bibBuffer_t * inBuffer, 

   311                  vdeDecodeParamters_t *aDecoderInfo)

   312 {

   313     PRINT((_L("CopyEditVop() begin")));

   314     int StartByteIndex = 0;

   315     int StartBitIndex = 7;

   316     int16 error;

   317     int sncCode;

   318     int timeIncByteIndex, timeIncBitIndex;

   319     int moduloBaseByteIndex, moduloBaseBitIndex;

   320     int vopheaderBitLeft;

   321     int numBitChange = 0;

   322     int increaseBytes = 0;

   323     int stuffingLength = 0;

   324 

   325     tMPEG4TimeParameter * timeStamp = aDecoderInfo->aMPEG4TimeStamp;

   326     MPEG4TimeParameter CurNewTimeCode;

   327 

   328     int outTirDecreased = 0;

   329     int outputTimeResolution = *aDecoderInfo->aMPEG4TargetTimeResolution;

   330     int numOutputTrBits;

   331     for (numOutputTrBits = 1; ((outputTimeResolution-1) >> numOutputTrBits) != 0; numOutputTrBits++)

   332         {

   333         }

   334 

   335     int num_bits;

   336     vdxGetVopHeaderInputParam_t inpParam;

   337     vdxVopHeader_t vopheader;

   338     int bitErrorIndication;

   339     vdeInstance_t * vdeTemp = (vdeInstance_t *)hInstance;

   340     bibBuffer_t *outBuffer = vdeTemp->outBuffer;

   341     bibBufferEdit_t * bufEdit = vdeTemp->bufEdit;

   342     

   343     int FrameSizeInByte = outBuffer->numBytesRead;

   344     bibRewindBits(bibNumberOfFlushedBits(inBuffer),inBuffer,&error);

   345     bibRewindBits(bibNumberOfFlushedBits(outBuffer),outBuffer,&error);

   346     if ( aNrOfBytesToSkip > 0 )

   347         {

   348         // VOS header is already in the beginning of the output buffer

   349         bibForwardBits(aNrOfBytesToSkip<<3, outBuffer);

   350         // need to also skip the VOS header from input

   351         }

   352     bufEdit->copyMode = CopyWhole; /* CopyWhole - default */

   353 

   354     /* record position */

   355     StartByteIndex = inBuffer->numBytesRead;

   356     StartBitIndex = inBuffer->bitIndex;

   357 

   358     /* get time increment resolution */

   359     vdcInstance_t * vdcTemp = (vdcInstance_t *)(vdeTemp->vdcHInstance);

   360     int currentTimeIncResolution = vdcTemp->pictureParam.time_increment_resolution > 0? vdcTemp->pictureParam.time_increment_resolution : outputTimeResolution;

   361     inpParam.time_increment_resolution = currentTimeIncResolution;

   362 

   363     /* find the next vop start code */

   364     do 

   365     {

   366         sncCode = sncSeekMPEGStartCode(inBuffer, vdcTemp->pictureParam.fcode_forward, vdcTemp->pictureParam.error_res_disable, 0, &error);

   367         bibForwardBits(32,inBuffer); // one start code is found, move on  

   368         if(inBuffer->bitsLeft <= 0) 

   369         {

   370             return TX_ERR;  // did not find any sync code --- vop is corrupted

   371         }

   372     }

   373     while (sncCode != SNC_VOP);

   374     bibRewindBits(32,inBuffer, &error);  // go back 

   375 

   376     // if we have VOS header in the input, we are now just after it. If aNrOfBytesToSkip > 0, we should not copy it

   377     // however, aNrOfBytesToSkip refers to output buffer, so we should not use it when skipping the input

   378     if ( aNrOfBytesToSkip > 0 )

   379         {

   380         StartByteIndex = inBuffer->numBytesRead;

   381         StartBitIndex = inBuffer->bitIndex;

   382         }

   383 

   384     /* read vop header */

   385     GetTimeIncPosition(inBuffer, &inpParam, &vopheader, 

   386         &moduloBaseByteIndex, &moduloBaseBitIndex, &timeIncByteIndex, 

   387         &timeIncBitIndex, &bitErrorIndication);

   388 

   389     /* record the header end; */

   390     vopheaderBitLeft = inBuffer->bitsLeft;

   391 

   392     /* copy-edit the part from the begin to the end of modulo base */

   393     CurNewTimeCode = *timeStamp;

   394 

   395     if (CurNewTimeCode.modulo_time_base != vopheader.time_base_incr)

   396     {

   397         if (!bufEdit->editParams)

   398         {

   399             bufEdit->editParams = (bibEditParams_t *) malloc(sizeof(bibEditParams_t));

   400             if(!bufEdit->editParams)

   401             {

   402                 //Memory not available 

   403                 return TX_ERR; //indicating error;

   404             }

   405             else

   406             {

   407                 bufEdit->numChanges = 1;

   408             }

   409         }

   410         bufEdit->copyMode = CopyWithEdit; /* CopyWithEdit */

   411         bufEdit->editParams->curNumBits = vopheader.time_base_incr + 1;

   412         bufEdit->editParams->newNumBits = CurNewTimeCode.modulo_time_base + 1;

   413         bufEdit->editParams->newValue = ((1 << CurNewTimeCode.modulo_time_base) - 1) << 1;

   414         bufEdit->editParams->StartByteIndex = moduloBaseByteIndex;

   415         bufEdit->editParams->StartBitIndex = moduloBaseBitIndex;

   416         numBitChange += bufEdit->editParams->newNumBits - bufEdit->editParams->curNumBits;

   417     }

   418     else

   419     {

   420         bufEdit->copyMode = CopyWhole; /* CopyWithEdit */

   421     }

   422     /* set the end of copy point */

   423     bibRewindBits((inBuffer->numBytesRead<<3)+7-inBuffer->bitIndex,inBuffer,&error);

   424     bibForwardBits((moduloBaseByteIndex<<3)+7-moduloBaseBitIndex+vopheader.time_base_incr+2, inBuffer);

   425       

   426     /* copy data */

   427     CopyStream(inBuffer,outBuffer,bufEdit,StartByteIndex,StartBitIndex);

   428     StartByteIndex=inBuffer->getIndex;

   429     StartBitIndex=inBuffer->bitIndex;

   430     bufEdit->copyMode = CopyWhole; /* CopyWhole */

   431 

   432     /* copy and edit until the end of Vop header */

   433     if (currentTimeIncResolution != outputTimeResolution /* && volheader.time_increment_resolution != 30 */

   434         || vopheader.time_inc != CurNewTimeCode.time_inc)

   435     {

   436         for (num_bits = 1; ((currentTimeIncResolution-1) >> num_bits) != 0; num_bits++) 

   437             {

   438             }

   439         /* prepare editing position */

   440         if (!bufEdit->editParams)

   441         {

   442             bufEdit->editParams = (bibEditParams_t *) malloc(sizeof(bibEditParams_t));

   443             if(!bufEdit->editParams)

   444             {

   445                 //Memory not available 

   446                 return TX_ERR; //indicating error no memory;

   447             }

   448             else

   449             {

   450                 bufEdit->numChanges = 1;

   451             }

   452             

   453         }

   454         bufEdit->copyMode = CopyWithEdit; /* CopyWithEdit */

   455         bufEdit->editParams->StartByteIndex = timeIncByteIndex;

   456         bufEdit->editParams->StartBitIndex = timeIncBitIndex;

   457         bufEdit->editParams->curNumBits = num_bits;

   458         bufEdit->editParams->newNumBits = numOutputTrBits;

   459         bufEdit->editParams->newValue = vopheader.time_inc;

   460 

   461         /* update time increment */

   462         if (vopheader.time_inc != CurNewTimeCode.time_inc)

   463         {

   464             /*bufEdit->editParams->newValue = (int)(vopheader.time_inc * (float)outputTimeResolution /

   465             (float)currentTimeIncResolution + 0.5); //CurNewTimeCode.time_inc;

   466             */

   467             bufEdit->editParams->newValue = CurNewTimeCode.time_inc;

   468         }

   469         numBitChange += bufEdit->editParams->newNumBits - bufEdit->editParams->curNumBits;

   470     }

   471 

   472     /* set the copy end point to the end of vop header */

   473     bibForwardBits(inBuffer->bitsLeft - vopheaderBitLeft, inBuffer);

   474 

   475     /* copy data */

   476     CopyStream(inBuffer,outBuffer,bufEdit,StartByteIndex,StartBitIndex);

   477     StartByteIndex=inBuffer->getIndex;

   478     StartBitIndex=inBuffer->bitIndex;

   479     

   480     if ( vdcTemp->pictureParam.error_res_disable && (inBuffer->bitsLeft > 40) )   // 40 as below to avoid negative values below

   481         {

   482         // there are no VP headers => no need to search for VP start codes => can jump to the end.

   483         // 40 = 5 bytes; in the end there is a start code that has 4 bytes

   484         bibForwardBits( inBuffer->bitsLeft-40 ,inBuffer);

   485         }

   486 

   487     PRINT((_L("CopyEditVop() seek sync")));

   488     /* find the next resync marker */

   489     sncCode = sncSeekMPEGStartCode(inBuffer, vopheader.fcode_forward, vdcTemp->pictureParam.error_res_disable, 0, &error);

   490     if ( sncCode == SNC_NO_SYNC )

   491         {

   492         PRINT((_L("CopyEditVop() sync NOT found, interrupt the copying and return")));

   493         return TX_ERR;

   494         }

   495     PRINT((_L("CopyEditVop() sync found")));

   496 

   497     /* record next resync position */

   498     int resyncBitsLeft = inBuffer->bitsLeft;

   499         

   500     /* rewind stuffing bits */

   501     sncRewindStuffing(inBuffer, &error);        

   502     

   503     if (!bufEdit->editParams)

   504     {

   505         bufEdit->editParams = (bibEditParams_t *) malloc(sizeof(bibEditParams_t));

   506         if(!bufEdit->editParams)

   507         {

   508             //Memory not available 

   509             return TX_ERR; //indicating error no memory;

   510         }

   511         else

   512         {

   513             bufEdit->numChanges = 1;

   514         }

   515     }

   516 

   517     /* record position */

   518     bufEdit->editParams->StartByteIndex = inBuffer->getIndex;

   519     bufEdit->editParams->StartBitIndex = inBuffer->bitIndex;

   520 

   521     /* calculate new stuffing bits */

   522     bufEdit->editParams->curNumBits = inBuffer->bitsLeft - resyncBitsLeft;

   523     /* calculate number of bits/bytes changed */

   524     if (numBitChange<0)

   525     {

   526         outTirDecreased = 1;

   527         numBitChange = -numBitChange;

   528     }

   529     int numByteChange = numBitChange >> 3;

   530 

   531     if (outTirDecreased)

   532     {

   533         increaseBytes -= numByteChange;

   534         stuffingLength = bufEdit->editParams->curNumBits + (numBitChange - (numByteChange << 3));

   535         if (stuffingLength > 8)

   536         {

   537             stuffingLength -= 8;

   538             increaseBytes --;

   539         }

   540     }

   541     else

   542     {

   543         increaseBytes += numByteChange;

   544         stuffingLength = bufEdit->editParams->curNumBits - (numBitChange - (numByteChange << 3));

   545         if (stuffingLength <= 0)

   546         {

   547             stuffingLength += 8;

   548             increaseBytes ++;

   549         }

   550     }

   551         

   552     /* adjust the output buffer size */

   553     if (increaseBytes != 0)

   554     {

   555         outBuffer->size += increaseBytes;

   556         if (increaseBytes>=0)

   557         {

   558             outBuffer->bitsLeft += (increaseBytes << 3);

   559         }

   560         else

   561         {

   562             outBuffer->bitsLeft -= ((-increaseBytes) << 3);

   563         }

   564     }

   565 

   566     /* update edit statistics */

   567     bufEdit->editParams->newNumBits = stuffingLength;

   568     bufEdit->editParams->newValue = stuffingLength>0?(1<<(stuffingLength-1))-1:0;

   569     if (stuffingLength != bufEdit->editParams->curNumBits)

   570     {

   571         bufEdit->copyMode = CopyWithEdit;

   572     }

   573 

   574     bibForwardBits(bufEdit->editParams->curNumBits, inBuffer);

   575     /* copy data */

   576     CopyStream(inBuffer,outBuffer,bufEdit,StartByteIndex,StartBitIndex);

   577     /* record position */

   578     StartByteIndex = inBuffer->getIndex;

   579     StartBitIndex = inBuffer->bitIndex;

   580         

   581     do

   582     {

   583         /* if it is the start of a video packet, copy it with edit */

   584         if (sncCode == SNC_VIDPACK )

   585         {

   586             /* copy video packet with edit */

   587             int retVal = CopyEditVideoPacket(inBuffer, outBuffer, bufEdit, vdcTemp, aDecoderInfo, &vopheader, 

   588                 &sncCode, &StartByteIndex, &StartBitIndex);

   589             if(retVal<0)

   590             {

   591                 //error inside function return error

   592                 return TX_ERR;

   593             }

   594         }

   595         else if (sncCode == SNC_EOB || sncCode == SNC_EOS || sncCode == SNC_GOV)

   596         {

   597             // since it is EOB, so end of sequence has occurred, so no more data, so exit       

   598             break;

   599         }

   600     } 

   601     while(sncCode != SNC_VOP);

   602 

   603     /* copy the rest of bits */

   604     if ((int)inBuffer->numBytesRead < FrameSizeInByte)

   605     {

   606         bufEdit->copyMode = CopyWhole;

   607         bibForwardBits((FrameSizeInByte-StartByteIndex)<<3, inBuffer);

   608         CopyStream(inBuffer,outBuffer,bufEdit,StartByteIndex,StartBitIndex);

   609     }

   610 

   611     PRINT((_L("CopyEditVop() end")));

   612     return TX_OK;

   613     }

   614 

   615 

   616 /*

   617 * CopyEditVideoPacket

   618 *    

   619 *

   620 * Parameters:

   621 *

   622 * Function:

   623 *    This function copies the video packet with edited time stamps, if HEC is enabled

   624 *

   625 * Returns:

   626 *    TX error codes

   627 */

   628 

   629 int CopyEditVideoPacket(bibBuffer_t* aInBuffer, 

   630                         bibBuffer_t* aOutBuffer, 

   631                         bibBufferEdit_t* aBufEdit, 

   632                         vdcInstance_t * aVdcTemp,

   633                         vdeDecodeParamters_t* aDecoderInfo, 

   634                         vdxVopHeader_t* aVopheader, 

   635                         int* aSncCode, 

   636                         int* aStartByteIndex, 

   637                         int* aStartBitIndex)

   638 {

   639     int16 error = 0;

   640     int value = 0;

   641     int bitsGot = 0;

   642     int num_bits = 0;

   643     int *bitErrorIndication = 0;

   644     int numOutputTrBits = 0;

   645     int resyncMarkerLength = 0;

   646     int numMBs = 0;

   647     int mbNumberLength = 0;

   648     int startByteIndex = *aStartByteIndex;

   649     int startBitIndex  = *aStartBitIndex;

   650     int currentTimeIncResolution = 0;

   651     int outputTimeResolution = 0;

   652     MPEG4TimeParameter curNewTimeCode;

   653     MPEG4TimeParameter* timeStamp = aDecoderInfo->aMPEG4TimeStamp;

   654 

   655     int numBitChange = 0;

   656     int increaseBytes = 0;

   657     int stuffingLength = 0;

   658     int outTirDecreased = 0;

   659 

   660     currentTimeIncResolution = aVdcTemp->pictureParam.time_increment_resolution > 0? aVdcTemp->pictureParam.time_increment_resolution : 30000;

   661     outputTimeResolution = *aDecoderInfo->aMPEG4TargetTimeResolution;

   662     for (numOutputTrBits=1; ((outputTimeResolution-1)>>numOutputTrBits)!=0; numOutputTrBits++)

   663         {

   664         }

   665     /* evaluate resync marker length */

   666     resyncMarkerLength = (aVopheader->coding_type == 0 ? 17 : 16+aVopheader->fcode_forward);

   667     /* evaluate MB number length */

   668     numMBs = ((aVdcTemp->pictureParam.lumWidth+15)>>4) * ((aVdcTemp->pictureParam.lumHeight+15)>>4);

   669     for (mbNumberLength = 1; ((numMBs-1) >> mbNumberLength) != 0; mbNumberLength++)

   670         {

   671         }

   672 

   673     value = bibGetBits(resyncMarkerLength, aInBuffer, &bitsGot, bitErrorIndication, &error);    // resync marker

   674     value = bibGetBits(mbNumberLength, aInBuffer, &bitsGot, bitErrorIndication, &error);    // mb number

   675     value = bibGetBits(5, aInBuffer, &bitsGot, bitErrorIndication, &error); // quant scale

   676     value = bibGetBits(1, aInBuffer, &bitsGot, bitErrorIndication, &error); // header extension code

   677     

   678     /* if HEC enabled, copy edit time increment fields in the video packet */

   679     if (value == 1) 

   680     {

   681         /* copy-edit the part from the begin to the end of modulo base */

   682         curNewTimeCode = *timeStamp;

   683         

   684         if (curNewTimeCode.modulo_time_base != aVopheader->time_base_incr)

   685         {

   686             if (!aBufEdit->editParams)

   687             {

   688                 aBufEdit->editParams = (bibEditParams_t *) malloc(sizeof(bibEditParams_t));

   689                 if(!aBufEdit->editParams)

   690                 {

   691                     //Memory not available 

   692                     return TX_ERR; //indicating error no memory;

   693                 }

   694                 else

   695                 {

   696                     aBufEdit->numChanges = 1;

   697                 }

   698             }

   699             aBufEdit->copyMode = CopyWithEdit; /* CopyWithEdit */

   700             aBufEdit->editParams->curNumBits = aVopheader->time_base_incr + 1;

   701             aBufEdit->editParams->newNumBits = curNewTimeCode.modulo_time_base + 1;

   702             aBufEdit->editParams->newValue = ((1 << curNewTimeCode.modulo_time_base) - 1) << 1;

   703             aBufEdit->editParams->StartByteIndex = aInBuffer->getIndex;

   704             aBufEdit->editParams->StartBitIndex = aInBuffer->bitIndex;

   705             numBitChange += aBufEdit->editParams->newNumBits - aBufEdit->editParams->curNumBits;

   706         } 

   707         else

   708         {

   709             aBufEdit->copyMode = CopyWhole; /* CopyWithEdit */

   710         }

   711         /* set the end of copy point */

   712         bibForwardBits(aVopheader->time_base_incr+2, aInBuffer); // includes one bit for Marker

   713         

   714         /* copy data */

   715         CopyStream(aInBuffer,aOutBuffer,aBufEdit,startByteIndex,startBitIndex);

   716         startByteIndex = aInBuffer->getIndex;

   717         startBitIndex  = aInBuffer->bitIndex;

   718         aBufEdit->copyMode = CopyWhole; /* CopyWhole */

   719         

   720         /* copy and edit 'time increment' field */

   721         if (currentTimeIncResolution != outputTimeResolution /* && volheader.time_increment_resolution != 30 */

   722             || aVopheader->time_inc != curNewTimeCode.time_inc)

   723         {

   724             for (num_bits = 1; ((currentTimeIncResolution-1) >> num_bits) != 0; num_bits++)

   725                 {

   726                 }

   727             

   728             /* prepare editing position */

   729             if (!aBufEdit->editParams)

   730             {

   731                 aBufEdit->editParams = (bibEditParams_t *) malloc(sizeof(bibEditParams_t));

   732                 if(!aBufEdit->editParams)

   733                 {

   734                     //Memory not available 

   735                     return TX_ERR; //indicating error no memory;

   736                 }

   737                 else

   738                 {

   739                     aBufEdit->numChanges = 1;

   740                 } 

   741             } 

   742             aBufEdit->copyMode = CopyWithEdit; /* CopyWithEdit */

   743             aBufEdit->editParams->StartByteIndex = aInBuffer->getIndex;

   744             aBufEdit->editParams->StartBitIndex = aInBuffer->bitIndex;

   745             aBufEdit->editParams->curNumBits = num_bits;

   746             aBufEdit->editParams->newNumBits = numOutputTrBits;

   747             aBufEdit->editParams->newValue = aDecoderInfo->aMPEG4TimeStamp->time_inc;

   748     

   749             /* move to end position of 'time increment' field */

   750             bibForwardBits(num_bits, aInBuffer);    // move to end of 'time increment' field

   751             /* update time increment */

   752             if (aVopheader->time_inc != curNewTimeCode.time_inc)

   753             {

   754                 aBufEdit->editParams->newValue = curNewTimeCode.time_inc;

   755             }

   756             numBitChange += aBufEdit->editParams->newNumBits - aBufEdit->editParams->curNumBits;

   757         } 

   758        

   759         /* copy time increment field with edit */

   760         CopyStream(aInBuffer,aOutBuffer,aBufEdit,startByteIndex,startBitIndex);

   761         startByteIndex=aInBuffer->getIndex;

   762         startBitIndex=aInBuffer->bitIndex;

   763         

   764     }

   765 

   766     /* copy rest of video packet */

   767     

   768     /* find the next resync marker */

   769     *aSncCode = sncSeekMPEGStartCode(aInBuffer, aVopheader->fcode_forward, 0 /* VPs used*/, 0, &error);

   770 

   771     /* record next resync position */

   772     int resyncBitsLeft = aInBuffer->bitsLeft;

   773         

   774     /* rewind stuffing bits */

   775     sncRewindStuffing(aInBuffer, &error);       

   776         

   777     if (!aBufEdit->editParams)

   778     {

   779         aBufEdit->editParams = (bibEditParams_t *) malloc(sizeof(bibEditParams_t));

   780         if(!aBufEdit->editParams)

   781         { 

   782             //Memory not available 

   783             return TX_ERR; //indicating error no memory;

   784         }

   785         else

   786         {

   787             aBufEdit->numChanges = 1;

   788         }

   789     }

   790 

   791     /* record position */

   792     aBufEdit->editParams->StartByteIndex = aInBuffer->getIndex;

   793     aBufEdit->editParams->StartBitIndex = aInBuffer->bitIndex;

   794         

   795     /* calculate new stuffing bits */

   796     aBufEdit->editParams->curNumBits = aInBuffer->bitsLeft - resyncBitsLeft;

   797 

   798     /* calculate number of bits/bytes changed */

   799     if (numBitChange<0)

   800     {

   801         outTirDecreased = 1;

   802         numBitChange = -numBitChange;

   803     }

   804     int numByteChange = numBitChange >> 3;

   805         

   806     /* evaluate change in buffer size */

   807     if (outTirDecreased)

   808     {

   809         increaseBytes -= numByteChange;

   810         stuffingLength = aBufEdit->editParams->curNumBits + (numBitChange - (numByteChange << 3));

   811         if (stuffingLength > 8)

   812         {

   813             stuffingLength -= 8;

   814             increaseBytes --;

   815         }

   816     }

   817     else

   818     {

   819         increaseBytes += numByteChange;

   820         stuffingLength = aBufEdit->editParams->curNumBits - (numBitChange - (numByteChange << 3));

   821         if (stuffingLength <= 0)

   822         {

   823             stuffingLength += 8;

   824             increaseBytes ++;

   825         }

   826     }

   827         

   828     /* adjust the output buffer size */

   829     if (increaseBytes != 0)

   830     {

   831         aOutBuffer->size += increaseBytes;

   832         if (increaseBytes>=0)

   833         {

   834             aOutBuffer->bitsLeft += (increaseBytes << 3);

   835         }

   836         else

   837         {

   838             aOutBuffer->bitsLeft -= ((-increaseBytes) << 3);

   839         }

   840     }

   841     /* update edit statistics */

   842     aBufEdit->editParams->newNumBits = stuffingLength;

   843     aBufEdit->editParams->newValue = stuffingLength>0?(1<<(stuffingLength-1))-1:0;

   844     if (stuffingLength != aBufEdit->editParams->curNumBits)

   845     {

   846         aBufEdit->copyMode = CopyWithEdit; // copy with edit

   847     }

   848     else 

   849     {

   850         aBufEdit->copyMode = CopyWhole; // copy whole 

   851     }

   852         

   853     bibForwardBits(aBufEdit->editParams->curNumBits, aInBuffer);

   854     /* copy video packet with stuffing bits edited */

   855     CopyStream(aInBuffer, aOutBuffer, aBufEdit, startByteIndex, startBitIndex);

   856     /* record position */

   857     startByteIndex = aInBuffer->getIndex;

   858     startBitIndex  = aInBuffer->bitIndex;

   859         

   860     /* update position for return */

   861     *aStartByteIndex = startByteIndex;

   862     *aStartBitIndex  = startBitIndex;

   863 

   864     return TX_OK;

   865 }

   866 

   867 

   868 /*

   869 * sPutBits

   870 *

   871 * Parameters:

   872 *      outBuf           output buffer

   873 *           numBits         number of bits to output

   874 *           value           new value

   875 *

   876 * Function:

   877 *    Wrapper to sPutBits

   878 * Returns:

   879 *    None.

   880 * Error codes:

   881 *    None.

   882 *

   883 */

   884 void vdtPutBits (void *buf,  int numBits, unsigned int value)

   885 {

   886     /* must be in this type! "void" is used here only because of the interface with vlb.cpp */

   887     sPutBits ((bibBuffer_t *)(buf),  numBits, value);

   888 }

   889 

   890 

   891 

   892 /* {{-output"vdtCopyBuffer.txt"}} */

   893 /*

   894 * vdtCopyBuffer

   895 *

   896 * Parameters:

   897 *

   898 * Function:

   899 *    This function copies some data from source buffer to destination buffer

   900 * Returns:

   901 *    None.

   902 * Error codes:

   903 *    None.

   904 *

   905 */

   906 void vdtCopyBuffer(bibBuffer_t *SrcBuffer,bibBuffer_t *DestBuffer,

   907                                      int ByteStart,int BitStart, int ByteEnd, int BitEnd)

   908 {

   909     int startByteIndex = SrcBuffer->getIndex;

   910     int startBitIndex  = SrcBuffer->bitIndex;

   911     int bitsLeft = SrcBuffer->bitsLeft;

   912     int numBytesRead = SrcBuffer->numBytesRead;

   913     

   914     CopyBuffer(SrcBuffer,DestBuffer, ByteStart, BitStart, ByteEnd, BitEnd);

   915     

   916     /* recover the postion */

   917     SrcBuffer->getIndex = startByteIndex ;

   918     SrcBuffer->bitIndex = startBitIndex;

   919     SrcBuffer->bitsLeft = bitsLeft;

   920     SrcBuffer->numBytesRead = numBytesRead;

   921 }

   922 

   923 

   924 

   925 

   926 /* {{-output"vdtStuffBitsMPEG4.txt"}} */

   927 /*

   928 * vdtStuffBitsMPEG4

   929 *

   930 * Parameters:

   931 *          outBuf           output buffer

   932 *

   933 * Function:

   934 *    This function puts some stuffing bits to the output buffer

   935 *   bits need to be stuffed in the output buffer at the end of vp in all cases (bw or not)

   936 * Returns:

   937 *    None.

   938 * Error codes:

   939 *    None.

   940 *

   941 */

   942 void vdtStuffBitsMPEG4(bibBuffer_t *outBuffer)

   943 {

   944     const int stuffingBits[8][2] = { {1,0}, {2,1}, {3,3}, {4,7}, {5,15}, {6,31}, {7,63}, {8,127} };

   945   VDTASSERT(outBuffer->baseAddr);

   946     

   947     /* find the number of stuffing bits to insert in the output buffer */

   948     int bi = outBuffer->bitIndex;

   949     int newNumBits = stuffingBits[bi][0]; 

   950     int newValue = stuffingBits[bi][1]; 

   951     sPutBits(outBuffer, newNumBits, newValue);

   952         

   953     return;

   954 }

   955 

   956 

   957 /*************************************************************/

   958 

   959 

   960 /* {{-output"sResetH263IntraDcUV.txt"}} */

   961 /*

   962 * sResetH263IntraDcUV

   963 *

   964 * Parameters: output buffer

   965 *             uValue

   966 *             vValue

   967 *

   968 * Function:

   969 *    This function reset the chrominace INTRADC when black and white color effect is applied 

   970 * Returns:

   971 *    none

   972 * Error codes:

   973 *    None.

   974 *

   975 */

   976 inline void sResetH263IntraDcUV(bibBuffer_t *DestBuffer, TInt uValue, TInt vValue)

   977 {

   978     /* For the Color Effects Fill the U and V buffers with the 

   979     corresponding color values */

   980    

   981     sPutBits(DestBuffer, 8, uValue);

   982     sPutBits(DestBuffer, 8, vValue);

   983 }

   984 

   985 

   986 /* {{-output"vdtGetPMBBlackAndWhiteMCBPC.txt"}} */

   987 /*

   988 * vdtGetPMBBlackAndWhiteMCBPC

   989 *

   990 * Parameters: 

   991 *

   992 * Function:

   993 *    This function compute the new mcbpc for black and white effect *

   994 * Returns:

   995 *    the length of the input mcbpc.

   996 * Error codes:

   997 *    None.

   998 *

   999 */

  1000 int vdtGetPMBBlackAndWhiteMCBPC(int& new_len, int& new_val, int mcbpc)

  1001 {

  1002     int cur_index, new_index, cur_len;

  1003         

  1004     const tVLCTable sCBPCPType[21] = 

  1005     {

  1006     {1, 1}, {3, 4}, {2, 4}, {5, 6},

  1007     {3, 3}, {7, 7}, {6, 7}, {5, 9}, 

  1008     {2, 3}, {5, 7}, {4, 7}, {5, 8},

  1009     {3, 5}, {4, 8}, {3, 8}, {3, 7},

  1010     {4, 6}, {4, 9}, {3, 9}, {2, 9}, 

  1011     {1, 9}

  1012     };

  1013     

  1014      /* evaluate MCBPC parameters */

  1015     int cur_cbpc = mcbpc & 3;       

  1016     int new_cbpc = 0;       // cpbc=0 indicates chroma is 0

  1017     int mbType; 

  1018     

  1019     mbType = mcbpc / 4;

  1020     /* evaluate indices in table */

  1021     cur_index = mbType * 4 + cur_cbpc;  

  1022     new_index = mbType * 4 + new_cbpc;  

  1023     

  1024     /* retrieve values */

  1025     cur_len = sCBPCPType[cur_index].length;

  1026     new_len = sCBPCPType[new_index].length;

  1027     new_val = sCBPCPType[new_index].code;

  1028     

  1029     return cur_len;

  1030 }

  1031 

  1032 

  1033 /* {{-output"vdtGetIMBBlackAndWhiteMCBPC.txt"}} */

  1034 /*

  1035 * vdtGetIMBBlackAndWhiteMCBPC

  1036 *

  1037 * Parameters: None

  1038 *

  1039 * Function:

  1040 *    This function compute the new mcbpc for black and white effect

  1041 * Returns:

  1042 *    the length of the input mcbpc.

  1043 * Error codes:

  1044 *    None.

  1045 *

  1046 */

  1047 int vdtGetIMBBlackAndWhiteMCBPC(int& new_len, int& new_val, int mcbpc)

  1048 {

  1049     int cur_index, new_index, cur_len;

  1050     

  1051     const tVLCTable sCBPCIType[9] = 

  1052     {

  1053     {1, 1}, {1, 3}, {2, 3}, {3, 3}, {1, 4},

  1054     {1, 6}, {2, 6}, {3, 6}, {1, 9}

  1055     };

  1056     

  1057     /* evaluate MCBPC parameters */

  1058     int cur_cbpc = mcbpc & 3;       

  1059     int new_cbpc = 0;       // cpbc=0 indicates chroma is 0

  1060     int mbType = (mcbpc <4)?3:4;

  1061     

  1062     /* evaluate indices in table */

  1063     cur_index = (mbType == 3 ? 0 : 4) + cur_cbpc;   

  1064     new_index = (mbType == 3 ? 0 : 4) + new_cbpc;   

  1065     

  1066     /* retrieve values */

  1067     cur_len = sCBPCIType[cur_index].length;

  1068     new_len = sCBPCIType[new_index].length;

  1069     new_val = sCBPCIType[new_index].code;

  1070     

  1071     return cur_len;

  1072 }

  1073 

  1074 

  1075 

  1076 

  1077 

  1078 /* {{-output"vdtGetVideoBitstreamInfo.txt"}} */

  1079 /*

  1080 * vdtGetVideoBitstreamInfo

  1081 *

  1082 * Parameters: 

  1083 *

  1084 * Function:

  1085 *    This function provides the bitstream info to the processor *

  1086 * Returns:

  1087 *    VDE error codes

  1088 * Error codes:

  1089 *    None.

  1090 *

  1091 */

  1092 int vdtGetVideoBitstreamInfo(bibBuffer_t *inBuffer, vdeDecodeParamters_t *aInfoOut, int *aByteIndex, int *aBitIndex)

  1093 {

  1094     int numBitsGot,

  1095     bitErrorIndication = 0;

  1096     int16 error = 0;

  1097     u_int32 bits;

  1098     int timeResolution = 0;

  1099     TVedVideoBitstreamMode streamMode = EVedVideoBitstreamModeUnknown;

  1100     vdxVolHeader_t volHeader;  

  1101     volHeader.user_data = NULL;

  1102     

  1103     bits = bibShowBits(32, inBuffer, &numBitsGot, &bitErrorIndication, &error);

  1104     if (error)

  1105     {

  1106         streamMode = EVedVideoBitstreamModeUnknown;

  1107         goto exitFunction;

  1108     }

  1109     /* If PSC */

  1110     if ((bits >> 10) == 32) {

  1111         streamMode = EVedVideoBitstreamModeH263;

  1112     } 

  1113 

  1114     /* Else check for Visual Sequence, Visual Object or Video Object start code */

  1115     else if ((bits == MP4_VOS_START_CODE) || 

  1116         (bits == MP4_VO_START_CODE) ||

  1117         ((bits >> MP4_VID_ID_CODE_LENGTH) == MP4_VID_START_CODE) ||

  1118         ((bits >> MP4_VOL_ID_CODE_LENGTH) == MP4_VOL_START_CODE)) 

  1119     {

  1120         

  1121         /* read the Stream headers from the bitstream */

  1122         if ((vdxGetVolHeader(inBuffer, &volHeader, &bitErrorIndication, 1, aByteIndex, aBitIndex, NULL) != 0) ||

  1123             (bitErrorIndication != 0)) 

  1124         {

  1125             goto exitFunction;

  1126         }   

  1127 

  1128         timeResolution = volHeader.time_increment_resolution;

  1129         streamMode = sGetMPEG4Mode(volHeader.error_res_disable, volHeader.data_partitioned, volHeader.reversible_vlc);

  1130         bits = bibShowBits(22, inBuffer, &numBitsGot, &bitErrorIndication, &error);

  1131         if (error)

  1132             goto exitFunction;

  1133         

  1134       /* Check if H.263 PSC follows the VOL header, in which case this is