Home | History | Annotate | Download | only in source
      1 /*
      2  * Copyright (C) 2009 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include "H264SwDecApi.h"
     18 #include <stdio.h>
     19 #include <stdlib.h>
     20 #include <string.h>
     21 
     22 /*------------------------------------------------------------------------------
     23     Module defines
     24 ------------------------------------------------------------------------------*/
     25 
     26 /* CHECK_MEMORY_USAGE prints and sums the memory allocated in calls to
     27  * H264SwDecMalloc() */
     28 /* #define CHECK_MEMORY_USAGE */
     29 
     30 /* _NO_OUT disables output file writing */
     31 /* #define _NO_OUT */
     32 
     33 /* Debug prints */
     34 #define DEBUG(argv) printf argv
     35 
     36 /* CVS tag name for identification */
     37 const char tagName[256] = "$Name: FIRST_ANDROID_COPYRIGHT $";
     38 
     39 void WriteOutput(char *filename, u8 *data, u32 picSize);
     40 u32 NextPacket(u8 **pStrm);
     41 u32 CropPicture(u8 *pOutImage, u8 *pInImage,
     42     u32 picWidth, u32 picHeight, CropParams *pCropParams);
     43 
     44 /* Global variables for stream handling */
     45 u8 *streamStop = NULL;
     46 u32 packetize = 0;
     47 u32 nalUnitStream = 0;
     48 FILE *foutput = NULL;
     49 
     50 #ifdef SOC_DESIGNER
     51 
     52 // Initialisation function defined in InitCache.s
     53 extern void cache_init(void);
     54 
     55 /*------------------------------------------------------------------------------
     56 
     57     Function name:  $Sub$$main
     58 
     59     Purpose:
     60         This function is called at the end of the C library initialisation and
     61         before main. Its purpose is to do any further initialisation before the
     62         application start.
     63 
     64 ------------------------------------------------------------------------------*/
     65 int $Sub$$main(char argc, char * argv[])
     66 {
     67   cache_init();                    // does some extra setup work setting up caches
     68   return $Super$$main(argc, argv); // calls the original function
     69 }
     70 #endif
     71 
     72 /*------------------------------------------------------------------------------
     73 
     74     Function name:  main
     75 
     76     Purpose:
     77         main function of decoder testbench. Provides command line interface
     78         with file I/O for H.264 decoder. Prints out the usage information
     79         when executed without arguments.
     80 
     81 ------------------------------------------------------------------------------*/
     82 
     83 int main(int argc, char **argv)
     84 {
     85 
     86     u32 i, tmp;
     87     u32 maxNumPics = 0;
     88     u8 *byteStrmStart;
     89     u8 *imageData;
     90     u8 *tmpImage = NULL;
     91     u32 strmLen;
     92     u32 picSize;
     93     H264SwDecInst decInst;
     94     H264SwDecRet ret;
     95     H264SwDecInput decInput;
     96     H264SwDecOutput decOutput;
     97     H264SwDecPicture decPicture;
     98     H264SwDecInfo decInfo;
     99     H264SwDecApiVersion decVer;
    100     u32 picDecodeNumber;
    101     u32 picDisplayNumber;
    102     u32 numErrors = 0;
    103     u32 cropDisplay = 0;
    104     u32 disableOutputReordering = 0;
    105 
    106     FILE *finput;
    107 
    108     char outFileName[256] = "";
    109 
    110     /* Print API version number */
    111     decVer = H264SwDecGetAPIVersion();
    112     DEBUG(("H.264 Decoder API v%d.%d\n", decVer.major, decVer.minor));
    113 
    114     /* Print tag name if '-T' argument present */
    115     if ( argc > 1 && strcmp(argv[1], "-T") == 0 )
    116     {
    117         DEBUG(("%s\n", tagName));
    118         return 0;
    119     }
    120 
    121     /* Check that enough command line arguments given, if not -> print usage
    122      * information out */
    123     if (argc < 2)
    124     {
    125         DEBUG((
    126             "Usage: %s [-Nn] [-Ooutfile] [-P] [-U] [-C] [-R] [-T] file.h264\n",
    127             argv[0]));
    128         DEBUG(("\t-Nn forces decoding to stop after n pictures\n"));
    129 #if defined(_NO_OUT)
    130         DEBUG(("\t-Ooutfile output writing disabled at compile time\n"));
    131 #else
    132         DEBUG(("\t-Ooutfile write output to \"outfile\" (default out_wxxxhyyy.yuv)\n"));
    133         DEBUG(("\t-Onone does not write output\n"));
    134 #endif
    135         DEBUG(("\t-P packet-by-packet mode\n"));
    136         DEBUG(("\t-U NAL unit stream mode\n"));
    137         DEBUG(("\t-C display cropped image (default decoded image)\n"));
    138         DEBUG(("\t-R disable DPB output reordering\n"));
    139         DEBUG(("\t-T to print tag name and exit\n"));
    140         return 0;
    141     }
    142 
    143     /* read command line arguments */
    144     for (i = 1; i < (u32)(argc-1); i++)
    145     {
    146         if ( strncmp(argv[i], "-N", 2) == 0 )
    147         {
    148             maxNumPics = (u32)atoi(argv[i]+2);
    149         }
    150         else if ( strncmp(argv[i], "-O", 2) == 0 )
    151         {
    152             strcpy(outFileName, argv[i]+2);
    153         }
    154         else if ( strcmp(argv[i], "-P") == 0 )
    155         {
    156             packetize = 1;
    157         }
    158         else if ( strcmp(argv[i], "-U") == 0 )
    159         {
    160             nalUnitStream = 1;
    161         }
    162         else if ( strcmp(argv[i], "-C") == 0 )
    163         {
    164             cropDisplay = 1;
    165         }
    166         else if ( strcmp(argv[i], "-R") == 0 )
    167         {
    168             disableOutputReordering = 1;
    169         }
    170     }
    171 
    172     /* open input file for reading, file name given by user. If file open
    173      * fails -> exit */
    174     finput = fopen(argv[argc-1],"rb");
    175     if (finput == NULL)
    176     {
    177         DEBUG(("UNABLE TO OPEN INPUT FILE\n"));
    178         return -1;
    179     }
    180 
    181     /* check size of the input file -> length of the stream in bytes */
    182     fseek(finput,0L,SEEK_END);
    183     strmLen = (u32)ftell(finput);
    184     rewind(finput);
    185 
    186     /* allocate memory for stream buffer. if unsuccessful -> exit */
    187     byteStrmStart = (u8 *)malloc(sizeof(u8)*strmLen);
    188     if (byteStrmStart == NULL)
    189     {
    190         DEBUG(("UNABLE TO ALLOCATE MEMORY\n"));
    191         return -1;
    192     }
    193 
    194     /* read input stream from file to buffer and close input file */
    195     fread(byteStrmStart, sizeof(u8), strmLen, finput);
    196     fclose(finput);
    197 
    198     /* initialize decoder. If unsuccessful -> exit */
    199     ret = H264SwDecInit(&decInst, disableOutputReordering);
    200     if (ret != H264SWDEC_OK)
    201     {
    202         DEBUG(("DECODER INITIALIZATION FAILED\n"));
    203         free(byteStrmStart);
    204         return -1;
    205     }
    206 
    207     /* initialize H264SwDecDecode() input structure */
    208     streamStop = byteStrmStart + strmLen;
    209     decInput.pStream = byteStrmStart;
    210     decInput.dataLen = strmLen;
    211     decInput.intraConcealmentMethod = 0;
    212 
    213     /* get pointer to next packet and the size of packet
    214      * (for packetize or nalUnitStream modes) */
    215     if ( (tmp = NextPacket(&decInput.pStream)) != 0 )
    216         decInput.dataLen = tmp;
    217 
    218     picDecodeNumber = picDisplayNumber = 1;
    219     /* main decoding loop */
    220     do
    221     {
    222         /* Picture ID is the picture number in decoding order */
    223         decInput.picId = picDecodeNumber;
    224 
    225         /* call API function to perform decoding */
    226         ret = H264SwDecDecode(decInst, &decInput, &decOutput);
    227 
    228         switch(ret)
    229         {
    230 
    231             case H264SWDEC_HDRS_RDY_BUFF_NOT_EMPTY:
    232                 /* Stream headers were successfully decoded
    233                  * -> stream information is available for query now */
    234 
    235                 ret = H264SwDecGetInfo(decInst, &decInfo);
    236                 if (ret != H264SWDEC_OK)
    237                     return -1;
    238 
    239                 DEBUG(("Profile %d\n", decInfo.profile));
    240 
    241                 DEBUG(("Width %d Height %d\n",
    242                     decInfo.picWidth, decInfo.picHeight));
    243 
    244                 if (cropDisplay && decInfo.croppingFlag)
    245                 {
    246                     DEBUG(("Cropping params: (%d, %d) %dx%d\n",
    247                         decInfo.cropParams.cropLeftOffset,
    248                         decInfo.cropParams.cropTopOffset,
    249                         decInfo.cropParams.cropOutWidth,
    250                         decInfo.cropParams.cropOutHeight));
    251 
    252                     /* Cropped frame size in planar YUV 4:2:0 */
    253                     picSize = decInfo.cropParams.cropOutWidth *
    254                               decInfo.cropParams.cropOutHeight;
    255                     picSize = (3 * picSize)/2;
    256                     tmpImage = malloc(picSize);
    257                     if (tmpImage == NULL)
    258                         return -1;
    259                 }
    260                 else
    261                 {
    262                     /* Decoder output frame size in planar YUV 4:2:0 */
    263                     picSize = decInfo.picWidth * decInfo.picHeight;
    264                     picSize = (3 * picSize)/2;
    265                 }
    266 
    267                 DEBUG(("videoRange %d, matrixCoefficients %d\n",
    268                     decInfo.videoRange, decInfo.matrixCoefficients));
    269 
    270                 /* update H264SwDecDecode() input structure, number of bytes
    271                  * "consumed" is computed as difference between the new stream
    272                  * pointer and old stream pointer */
    273                 decInput.dataLen -=
    274                     (u32)(decOutput.pStrmCurrPos - decInput.pStream);
    275                 decInput.pStream = decOutput.pStrmCurrPos;
    276 
    277                 /* If -O option not used, generate default file name */
    278                 if (outFileName[0] == 0)
    279                     sprintf(outFileName, "out_w%dh%d.yuv",
    280                             decInfo.picWidth, decInfo.picHeight);
    281                 break;
    282 
    283             case H264SWDEC_PIC_RDY_BUFF_NOT_EMPTY:
    284                 /* Picture is ready and more data remains in input buffer
    285                  * -> update H264SwDecDecode() input structure, number of bytes
    286                  * "consumed" is computed as difference between the new stream
    287                  * pointer and old stream pointer */
    288                 decInput.dataLen -=
    289                     (u32)(decOutput.pStrmCurrPos - decInput.pStream);
    290                 decInput.pStream = decOutput.pStrmCurrPos;
    291                 /* fall through */
    292 
    293             case H264SWDEC_PIC_RDY:
    294 
    295                 /*lint -esym(644,tmpImage,picSize) variable initialized at
    296                  * H264SWDEC_HDRS_RDY_BUFF_NOT_EMPTY case */
    297 
    298                 if (ret == H264SWDEC_PIC_RDY)
    299                     decInput.dataLen = NextPacket(&decInput.pStream);
    300 
    301                 /* If enough pictures decoded -> force decoding to end
    302                  * by setting that no more stream is available */
    303                 if (maxNumPics && picDecodeNumber == maxNumPics)
    304                     decInput.dataLen = 0;
    305 
    306                 /* Increment decoding number for every decoded picture */
    307                 picDecodeNumber++;
    308 
    309                 /* use function H264SwDecNextPicture() to obtain next picture
    310                  * in display order. Function is called until no more images
    311                  * are ready for display */
    312                 while ( H264SwDecNextPicture(decInst, &decPicture, 0) ==
    313                         H264SWDEC_PIC_RDY )
    314                 {
    315                     DEBUG(("PIC %d, type %s", picDisplayNumber,
    316                         decPicture.isIdrPicture ? "IDR" : "NON-IDR"));
    317                     if (picDisplayNumber != decPicture.picId)
    318                         DEBUG((", decoded pic %d", decPicture.picId));
    319                     if (decPicture.nbrOfErrMBs)
    320                     {
    321                         DEBUG((", concealed %d\n", decPicture.nbrOfErrMBs));
    322                     }
    323                     else
    324                         DEBUG(("\n"));
    325                     fflush(stdout);
    326 
    327                     numErrors += decPicture.nbrOfErrMBs;
    328 
    329                     /* Increment display number for every displayed picture */
    330                     picDisplayNumber++;
    331 
    332                     /*lint -esym(644,decInfo) always initialized if pictures
    333                      * available for display */
    334 
    335                     /* Write output picture to file */
    336                     imageData = (u8*)decPicture.pOutputPicture;
    337                     if (cropDisplay && decInfo.croppingFlag)
    338                     {
    339                         tmp = CropPicture(tmpImage, imageData,
    340                             decInfo.picWidth, decInfo.picHeight,
    341                             &decInfo.cropParams);
    342                         if (tmp)
    343                             return -1;
    344                         WriteOutput(outFileName, tmpImage, picSize);
    345                     }
    346                     else
    347                     {
    348                         WriteOutput(outFileName, imageData, picSize);
    349                     }
    350                 }
    351 
    352                 break;
    353 
    354             case H264SWDEC_STRM_PROCESSED:
    355             case H264SWDEC_STRM_ERR:
    356                 /* Input stream was decoded but no picture is ready
    357                  * -> Get more data */
    358                 decInput.dataLen = NextPacket(&decInput.pStream);
    359                 break;
    360 
    361             default:
    362                 DEBUG(("FATAL ERROR\n"));
    363                 return -1;
    364 
    365         }
    366     /* keep decoding until all data from input stream buffer consumed */
    367     } while (decInput.dataLen > 0);
    368 
    369     /* if output in display order is preferred, the decoder shall be forced
    370      * to output pictures remaining in decoded picture buffer. Use function
    371      * H264SwDecNextPicture() to obtain next picture in display order. Function
    372      * is called until no more images are ready for display. Second parameter
    373      * for the function is set to '1' to indicate that this is end of the
    374      * stream and all pictures shall be output */
    375     while (H264SwDecNextPicture(decInst, &decPicture, 1) == H264SWDEC_PIC_RDY)
    376     {
    377         DEBUG(("PIC %d, type %s", picDisplayNumber,
    378             decPicture.isIdrPicture ? "IDR" : "NON-IDR"));
    379         if (picDisplayNumber != decPicture.picId)
    380             DEBUG((", decoded pic %d", decPicture.picId));
    381         if (decPicture.nbrOfErrMBs)
    382         {
    383             DEBUG((", concealed %d\n", decPicture.nbrOfErrMBs));
    384         }
    385         else
    386             DEBUG(("\n"));
    387         fflush(stdout);
    388 
    389         numErrors += decPicture.nbrOfErrMBs;
    390 
    391         /* Increment display number for every displayed picture */
    392         picDisplayNumber++;
    393 
    394         /* Write output picture to file */
    395         imageData = (u8*)decPicture.pOutputPicture;
    396         if (cropDisplay && decInfo.croppingFlag)
    397         {
    398             tmp = CropPicture(tmpImage, imageData,
    399                 decInfo.picWidth, decInfo.picHeight,
    400                 &decInfo.cropParams);
    401             if (tmp)
    402                 return -1;
    403             WriteOutput(outFileName, tmpImage, picSize);
    404         }
    405         else
    406         {
    407             WriteOutput(outFileName, imageData, picSize);
    408         }
    409     }
    410 
    411     /* release decoder instance */
    412     H264SwDecRelease(decInst);
    413 
    414     if (foutput)
    415         fclose(foutput);
    416 
    417     /* free allocated buffers */
    418     free(byteStrmStart);
    419     free(tmpImage);
    420 
    421     DEBUG(("Output file: %s\n", outFileName));
    422 
    423     DEBUG(("DECODING DONE\n"));
    424     if (numErrors || picDecodeNumber == 1)
    425     {
    426         DEBUG(("ERRORS FOUND\n"));
    427         return 1;
    428     }
    429 
    430     return 0;
    431 }
    432 
    433 /*------------------------------------------------------------------------------
    434 
    435     Function name:  WriteOutput
    436 
    437     Purpose:
    438         Write picture pointed by data to file. Size of the
    439         picture in pixels is indicated by picSize.
    440 
    441 ------------------------------------------------------------------------------*/
    442 void WriteOutput(char *filename, u8 *data, u32 picSize)
    443 {
    444 
    445     /* foutput is global file pointer */
    446     if (foutput == NULL)
    447     {
    448         /* open output file for writing, can be disabled with define.
    449          * If file open fails -> exit */
    450         if (strcmp(filename, "none") != 0)
    451         {
    452 #if !defined(_NO_OUT)
    453             foutput = fopen(filename, "wb");
    454             if (foutput == NULL)
    455             {
    456                 DEBUG(("UNABLE TO OPEN OUTPUT FILE\n"));
    457                 exit(100);
    458             }
    459 #endif
    460         }
    461     }
    462 
    463     if (foutput && data)
    464         fwrite(data, 1, picSize, foutput);
    465 }
    466 
    467 /*------------------------------------------------------------------------------
    468 
    469     Function name: NextPacket
    470 
    471     Purpose:
    472         Get the pointer to start of next packet in input stream. Uses
    473         global variables 'packetize' and 'nalUnitStream' to determine the
    474         decoder input stream mode and 'streamStop' to determine the end
    475         of stream. There are three possible stream modes:
    476             default - the whole stream at once
    477             packetize - a single NAL-unit with start code prefix
    478             nalUnitStream - a single NAL-unit without start code prefix
    479 
    480         pStrm stores pointer to the start of previous decoder input and is
    481         replaced with pointer to the start of the next decoder input.
    482 
    483         Returns the packet size in bytes
    484 
    485 ------------------------------------------------------------------------------*/
    486 u32 NextPacket(u8 **pStrm)
    487 {
    488 
    489     u32 index;
    490     u32 maxIndex;
    491     u32 zeroCount;
    492     u8 *stream;
    493     u8 byte;
    494     static u32 prevIndex=0;
    495 
    496     /* For default stream mode all the stream is in first packet */
    497     if (!packetize && !nalUnitStream)
    498         return 0;
    499 
    500     index = 0;
    501     stream = *pStrm + prevIndex;
    502     maxIndex = (u32)(streamStop - stream);
    503 
    504     if (maxIndex == 0)
    505         return(0);
    506 
    507     /* leading zeros of first NAL unit */
    508     do
    509     {
    510         byte = stream[index++];
    511     } while (byte != 1 && index < maxIndex);
    512 
    513     /* invalid start code prefix */
    514     if (index == maxIndex || index < 3)
    515     {
    516         DEBUG(("INVALID BYTE STREAM\n"));
    517         exit(100);
    518     }
    519 
    520     /* nalUnitStream is without start code prefix */
    521     if (nalUnitStream)
    522     {
    523         stream += index;
    524         maxIndex -= index;
    525         index = 0;
    526     }
    527 
    528     zeroCount = 0;
    529 
    530     /* Search stream for next start code prefix */
    531     /*lint -e(716) while(1) used consciously */
    532     while (1)
    533     {
    534         byte = stream[index++];
    535         if (!byte)
    536             zeroCount++;
    537 
    538         if ( (byte == 0x01) && (zeroCount >= 2) )
    539         {
    540             /* Start code prefix has two zeros
    541              * Third zero is assumed to be leading zero of next packet
    542              * Fourth and more zeros are assumed to be trailing zeros of this
    543              * packet */
    544             if (zeroCount > 3)
    545             {
    546                 index -= 4;
    547                 zeroCount -= 3;
    548             }
    549             else
    550             {
    551                 index -= zeroCount+1;
    552                 zeroCount = 0;
    553             }
    554             break;
    555         }
    556         else if (byte)
    557             zeroCount = 0;
    558 
    559         if (index == maxIndex)
    560         {
    561             break;
    562         }
    563 
    564     }
    565 
    566     /* Store pointer to the beginning of the packet */
    567     *pStrm = stream;
    568     prevIndex = index;
    569 
    570     /* nalUnitStream is without trailing zeros */
    571     if (nalUnitStream)
    572         index -= zeroCount;
    573 
    574     return(index);
    575 
    576 }
    577 
    578 /*------------------------------------------------------------------------------
    579 
    580     Function name: CropPicture
    581 
    582     Purpose:
    583         Perform cropping for picture. Input picture pInImage with dimensions
    584         picWidth x picHeight is cropped with pCropParams and the resulting
    585         picture is stored in pOutImage.
    586 
    587 ------------------------------------------------------------------------------*/
    588 u32 CropPicture(u8 *pOutImage, u8 *pInImage,
    589     u32 picWidth, u32 picHeight, CropParams *pCropParams)
    590 {
    591 
    592     u32 i, j;
    593     u32 outWidth, outHeight;
    594     u8 *pOut, *pIn;
    595 
    596     if (pOutImage == NULL || pInImage == NULL || pCropParams == NULL ||
    597         !picWidth || !picHeight)
    598     {
    599         /* just to prevent lint warning, returning non-zero will result in
    600          * return without freeing the memory */
    601         free(pOutImage);
    602         return(1);
    603     }
    604 
    605     if ( ((pCropParams->cropLeftOffset + pCropParams->cropOutWidth) >
    606            picWidth ) ||
    607          ((pCropParams->cropTopOffset + pCropParams->cropOutHeight) >
    608            picHeight ) )
    609     {
    610         /* just to prevent lint warning, returning non-zero will result in
    611          * return without freeing the memory */
    612         free(pOutImage);
    613         return(1);
    614     }
    615 
    616     outWidth = pCropParams->cropOutWidth;
    617     outHeight = pCropParams->cropOutHeight;
    618 
    619     /* Calculate starting pointer for luma */
    620     pIn = pInImage + pCropParams->cropTopOffset*picWidth +
    621         pCropParams->cropLeftOffset;
    622     pOut = pOutImage;
    623 
    624     /* Copy luma pixel values */
    625     for (i = outHeight; i; i--)
    626     {
    627         for (j = outWidth; j; j--)
    628         {
    629             *pOut++ = *pIn++;
    630         }
    631         pIn += picWidth - outWidth;
    632     }
    633 
    634     outWidth >>= 1;
    635     outHeight >>= 1;
    636 
    637     /* Calculate starting pointer for cb */
    638     pIn = pInImage + picWidth*picHeight +
    639         pCropParams->cropTopOffset*picWidth/4 + pCropParams->cropLeftOffset/2;
    640 
    641     /* Copy cb pixel values */
    642     for (i = outHeight; i; i--)
    643     {
    644         for (j = outWidth; j; j--)
    645         {
    646             *pOut++ = *pIn++;
    647         }
    648         pIn += picWidth/2 - outWidth;
    649     }
    650 
    651     /* Calculate starting pointer for cr */
    652     pIn = pInImage + 5*picWidth*picHeight/4 +
    653         pCropParams->cropTopOffset*picWidth/4 + pCropParams->cropLeftOffset/2;
    654 
    655     /* Copy cr pixel values */
    656     for (i = outHeight; i; i--)
    657     {
    658         for (j = outWidth; j; j--)
    659         {
    660             *pOut++ = *pIn++;
    661         }
    662         pIn += picWidth/2 - outWidth;
    663     }
    664 
    665     return (0);
    666 }
    667 
    668 /*------------------------------------------------------------------------------
    669 
    670     Function name:  H264SwDecTrace
    671 
    672     Purpose:
    673         Example implementation of H264SwDecTrace function. Prototype of this
    674         function is given in H264SwDecApi.h. This implementation appends
    675         trace messages to file named 'dec_api.trc'.
    676 
    677 ------------------------------------------------------------------------------*/
    678 void H264SwDecTrace(char *string)
    679 {
    680     FILE *fp;
    681 
    682     fp = fopen("dec_api.trc", "at");
    683 
    684     if (!fp)
    685         return;
    686 
    687     fwrite(string, 1, strlen(string), fp);
    688     fwrite("\n", 1,1, fp);
    689 
    690     fclose(fp);
    691 }
    692 
    693 /*------------------------------------------------------------------------------
    694 
    695     Function name:  H264SwDecMalloc
    696 
    697     Purpose:
    698         Example implementation of H264SwDecMalloc function. Prototype of this
    699         function is given in H264SwDecApi.h. This implementation uses
    700         library function malloc for allocation of memory.
    701 
    702 ------------------------------------------------------------------------------*/
    703 void* H264SwDecMalloc(u32 size)
    704 {
    705 
    706 #if defined(CHECK_MEMORY_USAGE)
    707     /* Note that if the decoder has to free and reallocate some of the buffers
    708      * the total value will be invalid */
    709     static u32 numBytes = 0;
    710     numBytes += size;
    711     DEBUG(("Allocated %d bytes, total %d\n", size, numBytes));
    712 #endif
    713 
    714     return malloc(size);
    715 }
    716 
    717 /*------------------------------------------------------------------------------
    718 
    719     Function name:  H264SwDecFree
    720 
    721     Purpose:
    722         Example implementation of H264SwDecFree function. Prototype of this
    723         function is given in H264SwDecApi.h. This implementation uses
    724         library function free for freeing of memory.
    725 
    726 ------------------------------------------------------------------------------*/
    727 void H264SwDecFree(void *ptr)
    728 {
    729     free(ptr);
    730 }
    731 
    732 /*------------------------------------------------------------------------------
    733 
    734     Function name:  H264SwDecMemcpy
    735 
    736     Purpose:
    737         Example implementation of H264SwDecMemcpy function. Prototype of this
    738         function is given in H264SwDecApi.h. This implementation uses
    739         library function memcpy to copy src to dest.
    740 
    741 ------------------------------------------------------------------------------*/
    742 void H264SwDecMemcpy(void *dest, void *src, u32 count)
    743 {
    744     memcpy(dest, src, count);
    745 }
    746 
    747 /*------------------------------------------------------------------------------
    748 
    749     Function name:  H264SwDecMemset
    750 
    751     Purpose:
    752         Example implementation of H264SwDecMemset function. Prototype of this
    753         function is given in H264SwDecApi.h. This implementation uses
    754         library function memset to set content of memory area pointed by ptr.
    755 
    756 ------------------------------------------------------------------------------*/
    757 void H264SwDecMemset(void *ptr, i32 value, u32 count)
    758 {
    759     memset(ptr, value, count);
    760 }
    761 
    762