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 * H.263 bitstream parsing.

    17 *

    18 */

    19 

    20 

    21 

    22 /*

    23  * Includes

    24  */

    25 

    26 #include "h263dConfig.h"

    27 #include "viddemux.h"

    28 #include "vdxint.h"

    29 #include "debug.h"

    30 #include "biblin.h"

    31 /* MVE */

    32 #include "MPEG4Transcoder.h"

    33 

    34 /*

    35  * Defines

    36  */

    37 

    38 #ifdef DEB_STDOUT

    39 /* Use back-channel debug output file when printing back-channel related 

    40    messages. */

    41 #include <stdio.h>

    42 extern FILE *bcmDebFile;

    43 #endif

    44 

    45  

    46 /*

    47  * Module-scope typedefs

    48  */

    49 

    50 /* Another type for VLC (variable length code) lookup tables used in 

    51    Annex I implementation.*/

    52 typedef struct {

    53    u_char LAST;   /* see section 5.4.2 of the H.263 recommendation */

    54    u_char RUN;    /* to understand LAST, RUN and LEVEL */

    55    u_char LEVEL;

    56    u_char len;    /* actual length of code in bits */

    57 } vdxVLCTableNew_t;

    58 

    59 

    60 /*

    61  * Global constants

    62  */

    63 

    64 /* Used to convert a luminance block index defined in section 4.2.1

    65    of the H.263 recommendation to a coded block pattern mask (see sections

    66    5.3.4 and 5.3.5 of the H.263 recommendation. 

    67    See also macros section in viddemux.h. */

    68 const int vdxBlockIndexToCBPYMask[5] = {0, 8, 4, 2, 1};

    69 const int vdxYBlockIndexToCBPBMask[5] = {0, 32, 16, 8, 4};

    70 

    71 

    72 /*

    73  * Local function prototypes

    74  */

    75 

    76 /* Picture Layer */

    77 

    78 static int vdxActAfterIncorrectSEI(

    79    bibBuffer_t *inBuffer,

    80    int fPLUSPTYPE,

    81    int *fLast,

    82    int *bitErrorIndication);

    83 

    84 static void vdxStandardSourceFormatToFrameSize(int sourceFormat, int *width, int *height);

    85 

    86 /* Slice Layer */

    87 int vdxFrameSizeToPictureFormat(int width, int height);

    88 

    89 /* Macroblock Layer */

    90 

    91 static int vdxGetIntraMode(bibBuffer_t *inBuffer,int *index,

    92    int *bitErrorIndication);

    93 

    94 static int vdxUMVGetMVD(bibBuffer_t *inBuffer,int *mvdx10,

    95    int *bitErrorIndication);

    96 

    97 static int vdxGetNormalMODB(bibBuffer_t *inBuffer, int *index, 

    98    int *bitErrorIndication);

    99 

   100 static int vdxGetImpPBMODB(bibBuffer_t *inBuffer, int *index,

   101    int *bitErrorIndication);

   102 

   103 

   104 

   105 

   106 /*

   107  * Picture Layer Global Functions

   108  */

   109 

   110 /* {{-output"vdxGetPictureHeader.txt"}} */

   111 /*

   112  * vdxGetPictureHeader

   113  *    

   114  *

   115  * Parameters:

   116  *    inBuffer                   pointer to bit buffer instance

   117  *    inpParam                   input parameters

   118  *    header                     output parameters: picture header

   119  *    bitErrorIndication         non-zero if a bit error has been detected

   120  *                               within the bits accessed in this function,

   121  *                               see biterr.h for possible values

   122  *

   123  * Function:

   124  *    This function reads the H.263 picture header.

   125  *

   126  * Returns:

   127  *    VDX_OK                     the function was successful

   128  *    VDX_OK_BUT_BIT_ERROR       the function behaved normally, but a bit error

   129  *                               occured

   130  *    VDX_ERR_BIB                an error occured when accessing bit buffer

   131  *

   132  *    

   133  */

   134 

   135 int vdxGetPictureHeader(

   136    bibBuffer_t *inBuffer, 

   137    const vdxGetPictureHeaderInputParam_t *inpParam,

   138    vdxPictureHeader_t *header,

   139    int *bitErrorIndication)

   140 /* {{-output"vdxGetPictureHeader.txt"}} */

   141 {

   142    bibFlushBits_t

   143       flushBits;

   144    bibGetBits_t

   145       getBits;

   146    int

   147       numBitsGot,

   148       bits1To5OfPTYPE,

   149       sourceFormat;

   150    int16

   151       bibError = 0;

   152    u_int32 tmp = 0;          /* temporary variable for reading some redundant bits */

   153 

   154    vdxAssert(inBuffer != NULL);

   155    vdxAssert(inpParam != NULL);

   156    vdxAssert(inpParam->flushBits != NULL);

   157    vdxAssert(inpParam->getBits != NULL);

   158    vdxAssert(header != NULL);

   159    vdxAssert(bitErrorIndication != NULL);

   160 

   161    flushBits = inpParam->flushBits;

   162    getBits = inpParam->getBits;

   163 

   164    memset(header, 0, sizeof(vdxPictureHeader_t));

   165    *bitErrorIndication = 0;

   166 

   167    /* Assume that the existence of a PSC has been checked,

   168       it is the next code in the buffer, and

   169       its byte alignment has been checked */

   170 

   171    /* Flush stuffing (PSTUF) */

   172    if (inpParam->numStuffBits) {

   173       flushBits(inpParam->numStuffBits, inBuffer, &numBitsGot, bitErrorIndication, &bibError);

   174    }

   175 

   176    /* Flush PSC */

   177    flushBits(22, inBuffer, &numBitsGot, bitErrorIndication, &bibError);

   178    /* PSC cannot contain fatal bit errors (checked earlier) */

   179    header->numBits += 22;

   180 

   181    *bitErrorIndication = 0;   

   182 

   183    /* TR */

   184    header->tr = (int) getBits(8, inBuffer, &numBitsGot, bitErrorIndication,

   185       &bibError);

   186    header->numBits += 8;

   187 

   188 

   189    #ifdef DEB_STDOUT

   190       if (bcmDebFile)

   191          deb1f(bcmDebFile, "TR %d\n", header->tr);

   192    #endif

   193 

   194    /* The first 5 bits from PTYPE */

   195    bits1To5OfPTYPE = (int) getBits(5, inBuffer, &numBitsGot,

   196       bitErrorIndication, &bibError);

   197    header->numBits += 5;

   198 

   199 

   200    /* PTYPE bit 1 should be 1 */

   201    if ((bits1To5OfPTYPE & 16) == 0 ) {

   202       deb0p("ERROR. PTYPE bit 1 invalid.\n");

   203       goto exitAfterBitError;

   204    }

   205 

   206    /* PTYPE bit 2 should be 0 for distinction with H.261 */

   207    if (bits1To5OfPTYPE & 8) {

   208       deb0p("ERROR. PTYPE bit 2 indicates H.261.\n");

   209       goto exitAfterBitError;

   210    }

   211 

   212    /* PTYPE bit 3, Split Screen Indicator */

   213    header->fSplitScreen = ((bits1To5OfPTYPE & 4) > 0);

   214 

   215    /* PTYPE bit 4, Document camera indicator */

   216    header->fDocumentCamera = ((bits1To5OfPTYPE & 2) > 0);

   217 

   218    /* PTYPE bit 5, Freeze Picture Release */

   219    header->fFreezePictureRelease = (bits1To5OfPTYPE & 1);

   220 

   221    /* PTYPE bits 6 - 8, Source Format */

   222    sourceFormat = (int) getBits(3, inBuffer, &numBitsGot,

   223       bitErrorIndication, &bibError);

   224    header->numBits += 3;

   225 

   226 

   227    /* If H.263 version 1 */

   228    if (sourceFormat >= 1 && sourceFormat <= 5) {

   229       int bits9To13OfPTYPE;

   230 

   231       header->fPLUSPTYPE = 0;

   232 

   233       vdxStandardSourceFormatToFrameSize(sourceFormat, &header->lumWidth, &header->lumHeight);

   234 

   235       /* PTYPE bits 9 - 13 */

   236       bits9To13OfPTYPE = (int) getBits(5, inBuffer, &numBitsGot,

   237          bitErrorIndication, &bibError);

   238       header->numBits += 5;

   239 

   240 

   241       /* PTYPE bit 9, Picture coding type */

   242       header->pictureType = ((bits9To13OfPTYPE & 16) > 0);

   243 

   244       /* PTYPE bit 10, Unrestricted motion vector mode */

   245       header->fUMV = ((bits9To13OfPTYPE & 8) > 0);

   246 

   247       /* PTYPE bit 11, Syntax-based Arithmetic Coding mode */

   248       header->fSAC = ((bits9To13OfPTYPE & 4) > 0);

   249 

   250       /* PTYPE bit 12, Advanced prediction mode */

   251       header->fAP = ((bits9To13OfPTYPE & 2) > 0);

   252 

   253       /* PTYPE bit 13, PB-frames mode */

   254 

   255       /* If PTYPE bit 9 indicates a P-picture */

   256       if (header->pictureType) {

   257          /* Check if it is actually a PB-picture */

   258          if (bits9To13OfPTYPE & 1)

   259             header->pictureType = VDX_PIC_TYPE_PB;

   260       }

   261 

   262       /* Else PTYPE bit 9 indicates an I-picture */

   263       else {

   264          /* Check that bit 13 is 0 */

   265          if (bits9To13OfPTYPE & 1) {

   266             deb0p("ERROR. PTYPE bit 9 and 13 mismatch.\n");

   267             goto exitAfterBitError;

   268          }

   269       }

   270    }

   271 

   272    /* Else if H.263 version 2 (PLUSPTYPE) */

   273    else if (sourceFormat == 7) {

   274       int bits4To9OfMPPTYPE;

   275 

   276       header->fPLUSPTYPE = 1;

   277 

   278       /* UFEP */

   279       header->ufep = (int) getBits(3, inBuffer, &numBitsGot,

   280          bitErrorIndication, &bibError);

   281       header->numBits += 3;

   282 

   283 

   284       if (header->ufep > 1) {

   285          deb0p("ERROR. UFEP illegal.\n");

   286          goto exitAfterBitError;

   287       }

   288 

   289       /* If UFEP = '001' */

   290       if (header->ufep) {

   291          int bits4To18OfOPPTYPE;

   292 

   293          /* OPPTYPE bits 1 - 3, Source format */

   294          sourceFormat = (int) getBits(3, inBuffer, &numBitsGot,

   295             bitErrorIndication, &bibError);

   296          header->numBits += 3;

   297 

   298 

   299 

   300          if (sourceFormat >= 1 && sourceFormat <= 5) {

   301             header->fCustomSourceFormat = 0;

   302             vdxStandardSourceFormatToFrameSize(sourceFormat, 

   303                &header->lumWidth, &header->lumHeight);

   304          }

   305 

   306          else if (sourceFormat == 6)

   307             header->fCustomSourceFormat = 1;

   308 

   309          else {

   310             deb0p("ERROR. Source format illegal.\n");

   311             goto exitAfterBitError;

   312          }

   313 

   314          /* OPPTYPE bits 4 - 18 */

   315          bits4To18OfOPPTYPE = (int) getBits(15, inBuffer, &numBitsGot,

   316             bitErrorIndication, &bibError);

   317          header->numBits += 15;

   318 

   319 

   320          /* OPPTYPE bit 4, Custom PCF */

   321          header->fCustomPCF = ((bits4To18OfOPPTYPE & 0x4000) > 0);

   322 

   323          /* OPPTYPE bit 5, Unrestricted Motion Vector mode */

   324          header->fUMV = ((bits4To18OfOPPTYPE & 0x2000) > 0);

   325 

   326          /* OPPTYPE bit 6, Syntax-based Arithmetic Coding mode */

   327          header->fSAC = ((bits4To18OfOPPTYPE & 0x1000) > 0);

   328 

   329          /* OPPTYPE bit 7, Advanced Prediction mode */

   330          header->fAP = ((bits4To18OfOPPTYPE & 0x0800) > 0);

   331 

   332          /* OPPTYPE bit 8, Advanced INTRA Coding mode */

   333          header->fAIC = ((bits4To18OfOPPTYPE & 0x0400) > 0);

   334 

   335          /* OPPTYPE bit 9, Deblocking filter mode */

   336          header->fDF = ((bits4To18OfOPPTYPE & 0x0200) > 0);

   337 

   338          /* OPPTYPE bit 10, Slice Structured mode */

   339          header->fSS = ((bits4To18OfOPPTYPE & 0x0100) > 0);

   340 

   341          /* OPPTYPE bit 11, Reference Picture Selection mode */

   342          header->fRPS = ((bits4To18OfOPPTYPE & 0x0080) > 0);

   343 

   344          /* OPPTYPE bit 12, Independent Segment Decoding mode */

   345          header->fISD = ((bits4To18OfOPPTYPE & 0x0040) > 0);

   346 

   347          /* OPPTYPE bit 13, Alternative Inter VLC mode */

   348          header->fAIV = ((bits4To18OfOPPTYPE & 0x0020) > 0);

   349 

   350          /* OPPTYPE bit 14, Modified Quantization mode */

   351          header->fMQ = ((bits4To18OfOPPTYPE & 0x0010) > 0);

   352 

   353          /* OPPTYPE bits 15 - 18 must be '1000' */

   354          if ((bits4To18OfOPPTYPE & 0x000F) != 8) {

   355             deb0p("ERROR. OPPTYPE bits 15 - 18 illegal.\n");

   356             goto exitAfterBitError;

   357          }

   358 

   359          /* Mode interaction restrictions, see section 5.1.4.6 of 

   360             the H.263 recommendation */

   361          if (header->fSAC && (header->fAIV || header->fMQ || header->fUMV)) {

   362             deb0p("ERROR. Illegal bit pattern (section 5.1.4.6).\n");

   363             goto exitAfterBitError;

   364          }

   365       }

   366 

   367       /* MPPTYPE, bits 1 - 3, Picture type code */

   368       header->pictureType = (int) getBits(3, inBuffer, &numBitsGot,

   369          bitErrorIndication, &bibError);

   370       header->numBits += 3;

   371 

   372 

   373       if (header->pictureType >= 6) {

   374          deb0p("ERROR. Picture type code illegal.\n");

   375          goto exitAfterBitError;

   376       }

   377 

   378       /* MPPTYPE, bits 4 - 9 */

   379       bits4To9OfMPPTYPE = (int) getBits(6, inBuffer, &numBitsGot,

   380          bitErrorIndication, &bibError);

   381       header->numBits += 6;

   382 

   383 

   384       /* MPPTYPE bit 4, Reference Picture Resampling mode */

   385       header->fRPR = ((bits4To9OfMPPTYPE & 32) > 0);

   386 

   387       /* MPPTYPE bit 5, Reduced-Resolution Update mode */

   388       header->fRRU = ((bits4To9OfMPPTYPE & 16) > 0);

   389 

   390       /* RPR/RRU must not be set for I or EI-pictures.

   391          (See section 5.1.4.5 of the H.263 recommendation.) */

   392       if ((header->fRPR || header->fRRU) &&

   393          (header->pictureType == VDX_PIC_TYPE_I || 

   394             header->pictureType == VDX_PIC_TYPE_EI)) {

   395          deb0p("ERROR. RPR or RRU is set for I or EI.\n");

   396          goto exitAfterBitError;

   397       }

   398 

   399       /* MPPTYPE bit 6, Rounding type */

   400       header->rtype = ((bits4To9OfMPPTYPE & 8) > 0);

   401 

   402       /* RTYPE must be 0 if other than P, Improved PB or EP picture

   403          (see section 5.1.4.3 of the H.263 recommendation */

   404 

   405       /* MPPTYPE bits 7 - 9, must be '001' */

   406       if ((bits4To9OfMPPTYPE & 7) != 1) {

   407          deb0p("ERROR. MPPTYPE bits 7 - 9 illegal.\n");

   408          goto exitAfterBitError;

   409       }

   410 

   411       /* CPM */

   412       header->cpm = (int) getBits(1, inBuffer, &numBitsGot,

   413          bitErrorIndication, &bibError);

   414       header->numBits += 1;

   415 

   416 

   417       if (header->cpm) {

   418          /* PSBI */

   419          header->psbi = (int) getBits(2, inBuffer, &numBitsGot,

   420             bitErrorIndication, &bibError);

   421          header->numBits += 2;

   422 

   423 

   424       }

   425 

   426       if (header->fCustomSourceFormat) {

   427          int parCode, fExtendedPAR = 0, pwi, phi;

   428 

   429          /* CPFMT bits 1 - 4, Pixel Aspect Ratio code */

   430          parCode = (int) getBits(4, inBuffer, &numBitsGot,

   431             bitErrorIndication, &bibError);

   432          header->numBits += 4;

   433 

   434 

   435 

   436          switch (parCode) {

   437 

   438             case 1: /* Square */

   439                header->parWidth = 1;

   440                header->parHeight = 1;

   441                break;

   442 

   443             case 2: /* CIF for 4:3 picture */

   444                header->parWidth = 12;

   445                header->parHeight = 11;

   446                break;

   447 

   448             case 3: /* 525-type for 4:3 picture */

   449                header->parWidth = 10;

   450                header->parHeight = 11;

   451                break;

   452 

   453             case 4: /* CIF stretched for 16:9 picture */

   454                header->parWidth = 16;

   455                header->parHeight = 11;

   456                break;

   457 

   458             case 5: /* 525-type stretched for 16:9 picture */

   459                header->parWidth = 40;

   460                header->parHeight = 33;

   461                break;

   462 

   463             case 15: /* extended PAR */

   464                fExtendedPAR = 1;

   465                break;

   466 

   467             default:

   468                deb0p("ERROR. PAR code illegal.\n");

   469                goto exitAfterBitError;

   470          }

   471 

   472          /* CPFMT bits 5 - 13, picture width indication */

   473          pwi = (int) getBits(9, inBuffer, &numBitsGot,

   474             bitErrorIndication, &bibError);

   475          header->numBits += 9;

   476 

   477 

   478          header->lumWidth = ((pwi + 1) <<2 /** 4*/);

   479 

   480          /* CPFMT bit 14 must be 1 */

   481          tmp = getBits(1, inBuffer, &numBitsGot, bitErrorIndication, &bibError);

   482          header->numBits += 1;

   483 

   484 

   485          if ( tmp == 0 ) {

   486             deb0p("ERROR. CPFMT bit 14 is 0.\n");

   487             goto exitAfterBitError;

   488          }

   489 

   490          /* CPFMT bits 15 - 23, picture height indication */

   491          phi = (int) getBits(9, inBuffer, &numBitsGot,

   492             bitErrorIndication, &bibError);

   493          header->numBits += 9;

   494 

   495 

   496          if (phi == 0 || phi > 288) {

   497             deb0p("ERROR. PHI illegal.\n");

   498             goto exitAfterBitError;

   499          }

   500          header->lumHeight = (phi <<2 /** 4*/);

   501 

   502          if (fExtendedPAR) {

   503             /* EPAR bits 1 - 8, PAR Width */

   504             header->parWidth = (int) getBits(8, inBuffer, &numBitsGot,

   505                bitErrorIndication, &bibError);

   506             header->numBits += 8;

   507 

   508 

   509             if (header->parWidth == 0) {

   510                deb0p("ERROR. PAR width illegal.\n");

   511                goto exitAfterBitError;

   512             }

   513 

   514             /* EPAR bits 9 - 16, PAR Height */

   515             header->parHeight = (int) getBits(8, inBuffer, &numBitsGot,

   516                bitErrorIndication, &bibError);

   517             header->numBits += 8;

   518 

   519 

   520             if (header->parHeight == 0) {

   521                deb0p("ERROR. PAR height illegal.\n");

   522                goto exitAfterBitError;

   523             }

   524          }

   525       } /* endif (customSourceFormat) */

   526 

   527       if (header->fCustomPCF) {

   528          int clockConversionCode;

   529          u_int32 clockDivisor, conversionFactor;

   530 

   531          /* CPCFC bit 1, Clock conversion code */

   532          clockConversionCode = (int) getBits(1, inBuffer, &numBitsGot,

   533             bitErrorIndication, &bibError);

   534          header->numBits += 1;

   535 

   536 

   537          if (clockConversionCode)

   538             conversionFactor = 1001;

   539          else

   540             conversionFactor = 1000;

   541 

   542          /* CPCFC bits 2 - 8, Clock divisor */

   543          clockDivisor = getBits(7, inBuffer, &numBitsGot,

   544             bitErrorIndication, &bibError);

   545          header->numBits += 7;

   546 

   547 

   548          if (clockDivisor == 0) {

   549             deb0p("ERROR. Illegal clock divisor.\n");

   550             goto exitAfterBitError;

   551          }

   552  

   553          header->pcfRate = 1800000LU;

   554          header->pcfScale = clockDivisor * conversionFactor;

   555       }

   556 

   557       else {

   558          /* CIF clock frequency */

   559          header->pcfRate = 2997;

   560          header->pcfScale = 100;

   561       }

   562 

   563       if (header->fCustomPCF || (!header->ufep && inpParam->fCustomPCF)) {

   564          int etr;

   565 

   566          /* ETR */

   567          etr = (int) getBits(2, inBuffer, &numBitsGot,

   568             bitErrorIndication, &bibError);

   569          header->numBits += 2;

   570 

   571 

   572 

   573          header->tr |= (etr << 8);

   574       }

   575 

   576       if (header->fUMV) {

   577          /* UUI */

   578          tmp = getBits(1, inBuffer, &numBitsGot, bitErrorIndication, &bibError);

   579          header->numBits += 1;

   580 

   581 

   582          if ( tmp )

   583             header->fUMVLimited = 1;

   584 

   585          else {

   586             tmp = getBits(1, inBuffer, &numBitsGot, bitErrorIndication, &bibError);

   587             header->numBits += 1;

   588 

   589 

   590             if ( tmp )

   591                header->fUMVLimited = 0;

   592             else {

   593                /* '00' forbidden */

   594                deb0p("ERROR. Illegal UUI.\n");

   595                goto exitAfterBitError;

   596             }

   597          }

   598 

   599 

   600       }

   601 

   602       if (header->fSS) {

   603          /* SSS */

   604          tmp = (int) getBits(1, inBuffer, &numBitsGot,

   605             bitErrorIndication, &bibError);

   606 

   607          header->fRectangularSlices = tmp;

   608          header->numBits += 1;

   609 

   610          header->fArbitrarySliceOrdering = (int) getBits(1, inBuffer, &numBitsGot,

   611             bitErrorIndication, &bibError);

   612          header->numBits += 1;

   613 

   614 

   615          /* Mode interaction restriction, see section 5.1.4.6 of 

   616             the H.263 recommendation */

   617          if (header->fISD && !header->fRectangularSlices) {

   618             deb0p("ERROR. Illegal bit pattern (section 5.1.4.6).\n");

   619             goto exitAfterBitError;

   620          }

   621       }

   622 

   623       if (inpParam->fScalabilityMode) {

   624          /* ELNUM */

   625          header->elnum = (int) getBits(4, inBuffer, &numBitsGot,

   626             bitErrorIndication, &bibError);

   627          header->numBits += 4;

   628 

   629       }

   630 

   631       if (inpParam->fScalabilityMode && header->ufep) {

   632          /* RLNUM */

   633          header->rlnum = (int) getBits(4, inBuffer, &numBitsGot,

   634             bitErrorIndication, &bibError);

   635          header->numBits += 4;

   636 

   637       }

   638 

   639       if (header->fRPS) {

   640          /* RPSMF */

   641          header->rpsMode = (int) getBits(3, inBuffer, &numBitsGot,

   642             bitErrorIndication, &bibError);

   643          header->numBits += 3;

   644 

   645 

   646          if (header->rpsMode < 4) {

   647             deb0p("ERROR. Illegal RPSMF.\n");

   648             goto exitAfterBitError;

   649          }

   650 

   651          header->rpsMode -= 4; /* 4..7 --> 0..3 */

   652       }

   653 

   654       /* If no OPPTYPE but RPS was previously on or RPS signaled in OPPTYPE */

   655       if ((inpParam->fRPS && header->ufep == 0) || header->fRPS) {

   656          /* TRPI */

   657          header->trpi = (int) getBits(1, inBuffer, &numBitsGot,

   658             bitErrorIndication, &bibError);

   659          header->numBits += 1;

   660 

   661 

   662          if (header->trpi) {

   663             /* TRP */

   664             header->trp = (int) getBits(10, inBuffer, &numBitsGot,

   665                bitErrorIndication, &bibError);

   666             header->numBits += 10;

   667 

   668 

   669             deb2f(bcmDebFile, "TRPI in picture header. TR = %d, TRP = %d.\n", 

   670                header->tr, header->trp);            

   671          }

   672 

   673             /* Code following the standard */

   674 

   675             /* BCI */

   676             tmp = getBits(1, inBuffer, &numBitsGot, bitErrorIndication, &bibError);

   677             header->numBits += 1;

   678 

   679 

   680             if ( tmp ) {

   681                /* BCM not supported */

   682                deb0p("ERROR. BCM not supported.\n");

   683                goto exitAfterBitError;

   684             }

   685 

   686             else {

   687                tmp = getBits(1, inBuffer, &numBitsGot,bitErrorIndication, &bibError);

   688                header->numBits += 1;

   689 

   690 

   691                if ( !tmp ) {

   692                   /* BCI '00' is illegal */

   693                   deb0p("ERROR. Illegal BCI.\n");

   694                   goto exitAfterBitError;

   695                }

   696             }

   697 

   698       }

   699 

   700       if (header->fRPR) {

   701          /* RPRP not supported */

   702          deb0p("ERROR. RPRP not supported.\n");

   703          goto exitAfterBitError;

   704       }

   705    }

   706 

   707    else {

   708       deb0p("ERROR. Source format illegal.\n");

   709       goto exitAfterBitError;

   710    }

   711 

   712    /* PQUANT */

   713    header->pquantPosition = header->numBits;

   714    header->pquant = (int) getBits(5, inBuffer, &numBitsGot,

   715       bitErrorIndication, &bibError);

   716    header->numBits += 5;

   717 

   718 

   719    if (header->pquant == 0) {

   720       deb0p("ERROR. PQUANT illegal.\n");

   721       goto exitAfterBitError;

   722    }

   723 

   724    if (!header->fPLUSPTYPE) {

   725       /* CPM */

   726       header->cpm = (int) getBits(1, inBuffer, &numBitsGot,

   727          bitErrorIndication, &bibError);

   728       header->numBits += 1;

   729 

   730 

   731       if (header->cpm) {

   732          /* PSBI */

   733          header->psbi = (int) getBits(2, inBuffer, &numBitsGot,

   734             bitErrorIndication, &bibError); 

   735          header->numBits += 2;

   736 

   737 

   738       }

   739    }

   740 

   741    /* If PB-frame */

   742    if (header->pictureType == VDX_PIC_TYPE_PB || 

   743       header->pictureType == VDX_PIC_TYPE_IPB) {

   744 

   745       /* TRB */

   746 

   747       /* If custom picture clock frequence is used */

   748       if (header->fCustomPCF || inpParam->fCustomPCF) {

   749          header->trb = (int) getBits(5, inBuffer, &numBitsGot,

   750             bitErrorIndication, &bibError);

   751          header->numBits += 5;

   752 

   753 

   754       }

   755 

   756       else {

   757          header->trb = (int) getBits(3, inBuffer, &numBitsGot,

   758             bitErrorIndication, &bibError);

   759          header->numBits += 3;

   760 

   761 

   762       }

   763 

   764       if (header->trb == 0) {

   765          deb0p("ERROR. TRB illegal.\n");

   766          goto exitAfterBitError;

   767       }

   768 

   769       /* DBQUANT */

   770       header->dbquant = (int) getBits(2, inBuffer, &numBitsGot,

   771          bitErrorIndication, &bibError);

   772       header->numBits += 2;

   773 

   774 

   775    }

   776 

   777 

   778    /* Check success and return */

   779 

   780 

   781 

   782    /* If no error in bit buffer functions */

   783    if (!bibError)

   784       return VDX_OK;

   785 

   786    /* Else if ran out of data (i.e. decoding out of sync) */

   787    else if (bibError == ERR_BIB_NOT_ENOUGH_DATA) {

   788       return VDX_OK_BUT_BIT_ERROR;

   789    }

   790 

   791    /* Else other error in bit buffer functions */

   792    else

   793       return VDX_ERR_BIB;

   794 

   795    exitAfterBitError:

   796       if (bibError && bibError != ERR_BIB_NOT_ENOUGH_DATA)

   797          return VDX_ERR_BIB;

   798       return VDX_OK_BUT_BIT_ERROR;

   799 }

   800 

   801 

   802 /* {{-output"vdxFlushSEI.txt"}} */

   803 /*

   804  * vdxFlushSEI

   805  *    

   806  *

   807  * Parameters:

   808  *    inBuffer                   pointer to bit buffer instance

   809  *    bitErrorIndication         non-zero if a bit error has been detected

   810  *                               within the bits accessed in this function,

   811  *                               see biterr.h for possible values

   812  *

   813  * Function:

   814  *    This function discards (flushes) all consequent PEI/PSUPP pairs.

   815  *

   816  * Returns:

   817  *    VDX_OK                     the function was successful

   818  *    VDX_OK_BUT_BIT_ERROR       the function behaved normally, but a bit error

   819  *                               occured

   820  *    VDX_ERR_BIB                an error occured when accessing bit buffer

   821  *

   822  *    

   823  */

   824 

   825 int vdxFlushSEI(

   826    bibBuffer_t *inBuffer,

   827    int *bitErrorIndication )

   828 /* {{-output"vdxFlushSEI.txt"}} */

   829 {

   830    int

   831       numBitsGot;

   832    int16

   833       bibError = 0;

   834    u_int32 

   835       pei,

   836       psupp;

   837 

   838    vdxAssert(inBuffer != NULL);

   839    vdxAssert(bitErrorIndication != NULL);

   840 

   841    do {

   842       /* PEI */

   843       pei = bibGetBits(1, inBuffer, &numBitsGot, bitErrorIndication, &bibError);

   844 

   845 

   846       if (pei) {

   847          /* PSUPP */

   848          psupp = bibGetBits(8, inBuffer, &numBitsGot, bitErrorIndication, 

   849             &bibError);

   850          // ignore the value of psupp; this is flush-function

   851          if ( psupp )

   852             {

   853             }

   854 

   855 

   856       }

   857    } while (pei);   

   858 

   859    return VDX_OK;

   860 

   861 }

   862 

   863 

   864 /* {{-output"vdxGetSEI.txt"}} */

   865 /*

   866  * vdxGetSEI

   867  *    

   868  *

   869  * Parameters:

   870  *    inBuffer                   pointer to bit buffer instance

   871  *

   872  *    ftype                      FTYPE field as defined in table L.1 of H.263,

   873  *                               -1 if the value is not valid

   874  *

   875  *    dsize                      DSIZE as defined in section L.2 of H.263

   876  *

   877  *    parameterData              an array of (min) 16 entries,

   878  *                               filled with dsize octets of parameter data

   879  *

   880  *    fLast                      set to 1 if the first PEI indicates that

   881  *                               no PSUPPs follow. Otherwise 0.

   882  *

   883  *    bitErrorIndication         non-zero if a bit error has been detected

   884  *                               within the bits accessed in this function,

   885  *                               see biterr.h for possible values

   886  *

   887  * Function:

   888  *    This function gets supplemental enhancement information as defined

   889  *    in Annex L of H.263.

   890  *

   891  * Note:

   892  *    The start code emulation prevention necessity using "Do Nothing" function

   893  *    is not checked. See section L.3 of H.263 for more details.

   894  *    

   895  * Returns:

   896  *    VDX_OK                     the function was successful

   897  *    VDX_OK_BUT_BIT_ERROR       the function behaved normally, but a bit error

   898  *                               occured

   899  *    VDX_ERR_BIB                an error occured when accessing bit buffer

   900  *

   901  *    

   902  */

   903 

   904 int vdxGetSEI(

   905    bibBuffer_t *inBuffer,

   906    int *ftype,

   907    int *dsize,

   908    u_char *parameterData,

   909    int *fLast,

   910    int *bitErrorIndication)

   911 /* {{-output"vdxGetSEI.txt"}} */

   912 {

   913    int

   914       numBitsGot,

   915       paramNum,

   916       lftype, /* local FTYPE */

   917       ldsize; /* local DSZIE */

   918    int16

   919       bibError = 0;

   920    u_int32 

   921       pei;

   922 

   923    vdxAssert(inBuffer != NULL);

   924    vdxAssert(ftype != NULL);

   925    vdxAssert(dsize != NULL);

   926    vdxAssert(parameterData != NULL);

   927    vdxAssert(fLast != NULL);

   928    vdxAssert(bitErrorIndication != NULL);

   929 

   930    *ftype = -1;

   931    *dsize = 0;   

   932 

   933    /* PEI */

   934    pei = bibGetBits(1, inBuffer, &numBitsGot, bitErrorIndication, &bibError);

   935 

   936 

   937    if (pei) {

   938       *fLast = 0;

   939 

   940       /* FTYPE */

   941       lftype = (int) bibGetBits(4, inBuffer, &numBitsGot, bitErrorIndication, 

   942          &bibError);

   943 

   944 

   945       /* DSIZE */

   946       ldsize = (int) bibGetBits(4, inBuffer, &numBitsGot, bitErrorIndication, 

   947          &bibError);

   948 

   949    }

   950 

   951    else {

   952       *fLast = 1;

   953       return VDX_OK;

   954    }

   955 

   956    for (paramNum = 0; paramNum < ldsize; paramNum++) {

   957       /* PEI */

   958       pei = bibGetBits(1, inBuffer, &numBitsGot, bitErrorIndication, &bibError);

   959 

   960 

   961       if (!pei) {

   962          deb0p("ERROR. DSIZE does not match with PEI.\n");

   963          *fLast = 1;

   964          return VDX_OK_BUT_BIT_ERROR;

   965       }

   966 

   967       /* PSUPP containing parameter data */

   968       parameterData[paramNum] = (u_char) bibGetBits(8, inBuffer, &numBitsGot, 

   969          bitErrorIndication, &bibError);

   970 

   971    }

   972 

   973    *ftype = lftype;

   974    *dsize = ldsize;

   975      

   976    return VDX_OK;

   977 

   978 }

   979 

   980 

   981 /* {{-output"vdxGetAndParseSEI.txt"}} */

   982 /*

   983  * vdxGetAndParseSEI

   984  *

   985  * Parameters:

   986  *    inBuffer                   pointer to bit buffer instance

   987  *

   988  *    fPLUSPTYPE                 indicates if PLUSPTYPE is in use

   989  *

   990  *    numScalabilityLayers       -1 if the very first picture,

   991  *                               0 if Annex N scalability layers not in use,

   992  *                               2..15 if Annex N scalability layers in use

   993  *

   994  *    sei                        parsed SEI data

   995  *

   996  *    bitErrorIndication         non-zero if a bit error has been detected

   997  *                               within the bits accessed in this function,

   998  *                               see biterr.h for possible values

   999  *

  1000  * Function:

  1001  *    This function gets supplemental enhancement information as defined

  1002  *    in Annex L and W of H.263 and returns the parsed data.

  1003  *

  1004  * Returns:

  1005  *    VDX_OK                     the function was successful

  1006  *    VDX_OK_BUT_BIT_ERROR       the function behaved normally, but a bit error

  1007  *                               occured

  1008  *    VDX_ERR_BIB                an error occured when accessing bit buffer

  1009  */

  1010 

  1011 int vdxGetAndParseSEI(

  1012    bibBuffer_t *inBuffer,

  1013    int fPLUSPTYPE,

  1014    int numScalabilityLayers,

  1015    vdxSEI_t *sei,

  1016    int *bitErrorIndication)

  1017 /* {{-output"vdxGetAndParseSEI.txt"}} */

  1018 {

  1019    int 

  1020        ret = VDX_OK,              /* Temporary variable to carry return values */

  1021       fSecondFTYPESet = 0,       /* 1 = Extended FTYPE in use, 

  1022                                     0 = Annex L/W FTYPE in use,

  1023                                     see L.15 for further details */

  1024       ftype,                     /* FTYPE as in section L.2 of H.263 */

  1025       dsize,                     /* DSIZE as in section L.2 of H.263 */

  1026       fLast,                     /* 1 if PEI is zero, 0 otherwise */

  1027       cont = 0,                  /* CONT as in section W.6 of H.263 */ 

  1028       ebit,                      /* EBIT as in section W.6 of H.263 */

  1029       mtype,                     /* MTYPE as in section W.6 of H.263 */

  1030       prevCONT = 0,              /* CONT field in the previous picture msg */

  1031       prevMTYPE = -1;            /* MTYPE in the previous picture msg */

  1032       

  1033    u_char

  1034       parameterData[16];

  1035 

  1036    /* Initialize output data */

  1037    sei->fFullPictureFreezeRequest = 0;

  1038    sei->fFullPictureSnapshot = 0;

  1039    sei->snapshotId = 0;

  1040    sei->snapshotStatus = 255;

  1041    sei->scalabilityLayer = -1;

  1042    sei->numScalabilityLayers = 0;

  1043    memset(sei->prevPicHeader, 0, VDX_MAX_BYTES_IN_PIC_HEADER);

  1044    sei->numBytesInPrevPicHeader = 0;

  1045    sei->numBitsInLastByteOfPrevPicHeader = 0;

  1046    sei->fPrevPicHeaderTooLarge = 0;

  1047 

  1048    do {

  1049       /* Get supplemental enhancement information */

  1050       ret = vdxGetSEI(inBuffer, &ftype, &dsize, parameterData, &fLast, 

  1051          bitErrorIndication);

  1052 

  1053       /* If fatal error or bit error */

  1054       if (ret != VDX_OK)

  1055          return ret;

  1056 

  1057       /* If the previous FTYPE indicated Extended Function Type */

  1058       if (fSecondFTYPESet) {

  1059 

  1060          /* Let's discard FTYPE/DSIZE and parameters as suggested in 

  1061             section L.15 of H.263 Recommendation to allow backward

  1062             compatibility to to-be-defined set of extended FTYPEs. */

  1063             

  1064          /* The next expected FTYPE is a normal one defined in Annex L/W. */

  1065          fSecondFTYPESet = 0;

  1066 

  1067          continue;

  1068       }

  1069 

  1070       switch (ftype) {

  1071 

  1072          /* If "Reserved" */

  1073          case 0:

  1074             ret = vdxActAfterIncorrectSEI(

  1075                inBuffer, fPLUSPTYPE, &fLast, bitErrorIndication);

  1076             break;

  1077 

  1078          /* If "Do Nothing" */

  1079          case 1:

  1080 

  1081             if (dsize != 0) {

  1082                ret = vdxActAfterIncorrectSEI(

  1083                   inBuffer, fPLUSPTYPE, &fLast, bitErrorIndication);

  1084             }

  1085 

  1086             break;

  1087 

  1088          /* If Full-Picture Freeze Request */

  1089          case 2:

  1090             if (dsize != 0) {

  1091                ret = vdxActAfterIncorrectSEI(

  1092                   inBuffer, fPLUSPTYPE, &fLast, bitErrorIndication);

  1093             }

  1094 

  1095             else

  1096                sei->fFullPictureFreezeRequest = 1;

  1097 

  1098             break;

  1099 

  1100          /* If Partial-Picture Freeze Request */

  1101          case 3:

  1102             if (dsize != 4) {

  1103                ret = vdxActAfterIncorrectSEI(

  1104                   inBuffer, fPLUSPTYPE, &fLast, bitErrorIndication);

  1105             }

  1106 

  1107             break;

  1108 

  1109          /* If Resizing Partial-Picture Freeze Request */

  1110          case 4:

  1111             if (dsize != 8) {

  1112                ret = vdxActAfterIncorrectSEI(

  1113                   inBuffer, fPLUSPTYPE, &fLast, bitErrorIndication);

  1114             }

  1115 

  1116             break;

  1117 

  1118          /* If Partial-Picture Freeze-Release Request */

  1119          case 5:

  1120             if (dsize != 4) {

  1121                ret = vdxActAfterIncorrectSEI(

  1122                   inBuffer, fPLUSPTYPE, &fLast, bitErrorIndication);

  1123             }

  1124 

  1125             break;

  1126 

  1127          /* If Full-Picture Snapshot Tag */

  1128          case 6:

  1129             if (dsize != 4) {

  1130                ret = vdxActAfterIncorrectSEI(

  1131                   inBuffer, fPLUSPTYPE, &fLast, bitErrorIndication);

  1132             }

  1133 

  1134             else {