libmng_read.c

奇趣公司比较新的qt/emd版本

  if (iRetcode)                        /* on error bail out */
    return iRetcode;

#endif /* MNG_SUPPORT_DISPLAY */
                                       /* can we continue processing now, or do we */
                                       /* need to wait for the timer to finish (again) ? */
#ifdef MNG_SUPPORT_DISPLAY
  if ((!pData->bTimerset) && (!pData->bSectionwait) && (!pData->bEOF))
#else
  if (!pData->bEOF)
#endif
  {
#ifdef MNG_SUPPORT_DISPLAY
                                       /* freezing in progress ? */
    if ((pData->bFreezing) && (pData->iSuspendpoint == 0))
      pData->bRunning = MNG_FALSE;     /* then this is the right moment to do it */
#endif

    if (pData->iSuspendpoint <= 2)
    {
      iBuflen  = sizeof (mng_uint32);  /* read length */
      iRetcode = read_databuffer (pData, pBuf, &pData->pReadbufnext, iBuflen, &iRead);

      if (iRetcode)                    /* bail on errors */
        return iRetcode;

      if (pData->bSuspended)           /* suspended ? */
        pData->iSuspendpoint = 2;
      else                             /* save the length */
      {
        pData->iChunklen = mng_get_uint32 (pBuf);
        if (pData->iChunklen > 0x7ffffff)
           return MNG_INVALIDLENGTH;
      }

    }

    if (!pData->bSuspended)            /* still going ? */
    {                                  /* previously suspended or not eof ? */
      if ((pData->iSuspendpoint > 2) || (iRead == iBuflen))
      {                                /* determine length chunkname + data (+ crc) */
        if (pData->iCrcmode & MNG_CRC_INPUT)
          iBuflen = pData->iChunklen + (mng_uint32)(sizeof (mng_chunkid) + sizeof (mng_uint32));
        else
          iBuflen = pData->iChunklen + (mng_uint32)(sizeof (mng_chunkid));

                                       /* do we have enough data in the current push buffer ? */
        if ((pData->pFirstpushdata) && (iBuflen <= pData->pFirstpushdata->iRemaining))
        {
          mng_pushdatap pPush  = pData->pFirstpushdata;
          pBuf                 = pPush->pDatanext;
          pPush->pDatanext    += iBuflen;
          pPush->iRemaining   -= iBuflen;
          pData->iSuspendpoint = 0;    /* safely reset this here ! */

          iRetcode = check_chunk_crc (pData, pBuf, iBuflen);
          if (iRetcode)
            return iRetcode;

          if (!pPush->iRemaining)      /* buffer depleted? then release it */
            iRetcode = mng_release_pushdata (pData);
        }
        else
        {
          if (iBuflen < iBufmax)       /* does it fit in default buffer ? */
          {                            /* note that we don't use the full size
                                          so there's always a zero-byte at the
                                          very end !!! */
            iRetcode = read_databuffer (pData, pBuf, &pData->pReadbufnext, iBuflen, &iRead);
            if (iRetcode)              /* bail on errors */
              return iRetcode;

            if (pData->bSuspended)     /* suspended ? */
              pData->iSuspendpoint = 3;
            else
            {
              if (iRead != iBuflen)    /* did we get all the data ? */
                MNG_ERROR (pData, MNG_UNEXPECTEDEOF);
              iRetcode = check_chunk_crc (pData, pBuf, iBuflen);
            }
          }
          else
          {
            if (iBuflen > 16777216)    /* is the length incredible? */
              MNG_ERROR (pData, MNG_IMPROBABLELENGTH);

            if (!pData->iSuspendpoint) /* create additional large buffer ? */
            {                          /* again reserve space for the last zero-byte */
              pData->iLargebufsize = iBuflen + 1;
              pData->pLargebufnext = MNG_NULL;
              MNG_ALLOC (pData, pData->pLargebuf, pData->iLargebufsize);
            }

            iRetcode = read_databuffer (pData, pData->pLargebuf, &pData->pLargebufnext, iBuflen, &iRead);
            if (iRetcode)
              return iRetcode;

            if (pData->bSuspended)     /* suspended ? */
              pData->iSuspendpoint = 4;
            else
            {
              if (iRead != iBuflen)    /* did we get all the data ? */
                MNG_ERROR (pData, MNG_UNEXPECTEDEOF);
              iRetcode = check_chunk_crc (pData, pData->pLargebuf, iBuflen);
                                       /* cleanup additional large buffer */
              MNG_FREE (pData, pData->pLargebuf, pData->iLargebufsize);
            }
          }
        }

        if (iRetcode)                  /* on error bail out */
          return iRetcode;

      }
      else
      {                                /* that's final */
        iRetcode = mng_process_eof (pData);

        if (iRetcode)                  /* on error bail out */
          return iRetcode;

        if ((iRead != 0) ||            /* did we get an unexpected eof ? */
#ifdef MNG_INCLUDE_JNG
            (pData->bHasIHDR || pData->bHasMHDR || pData->bHasJHDR))
#else
            (pData->bHasIHDR || pData->bHasMHDR))
#endif
          MNG_ERROR (pData, MNG_UNEXPECTEDEOF);
      } 
    }
  }

#ifdef MNG_SUPPORT_DISPLAY             /* refresh needed ? */
  if ((!pData->bTimerset) && (!pData->bSuspended) && (pData->bNeedrefresh))
  {
    iRetcode = mng_display_progressive_refresh (pData, 1);

    if (iRetcode)                      /* on error bail out */
      return iRetcode;
  }
#endif

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (pData, MNG_FN_READ_CHUNK, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

MNG_LOCAL mng_retcode process_pushedchunk (mng_datap pData)
{
  mng_pushdatap pPush;
  mng_retcode   iRetcode = MNG_NOERROR;

#ifdef MNG_SUPPORT_DISPLAY
  if (pData->pCurraniobj)              /* processing an animation object ? */
  {
    do                                 /* process it then */
    {
      iRetcode = ((mng_object_headerp)pData->pCurraniobj)->fProcess (pData, pData->pCurraniobj);
                                       /* refresh needed ? */
/*      if ((!iRetcode) && (!pData->bTimerset) && (pData->bNeedrefresh))
        iRetcode = display_progressive_refresh (pData, 1); */
                                       /* can we advance to next object ? */
      if ((!iRetcode) && (pData->pCurraniobj) &&
          (!pData->bTimerset) && (!pData->bSectionwait))
      {                                /* reset timer indicator on read-cycle */
        if ((pData->bReading) && (!pData->bDisplaying))
          pData->bTimerset = MNG_FALSE;

        pData->pCurraniobj = ((mng_object_headerp)pData->pCurraniobj)->pNext;
                                       /* TERM processing to be done ? */
        if ((!pData->pCurraniobj) && (pData->bHasTERM) && (!pData->bHasMHDR))
          iRetcode = mng_process_display_mend (pData);
      }
    }                                  /* until error or a break or no more objects */
    while ((!iRetcode) && (pData->pCurraniobj) &&
           (!pData->bTimerset) && (!pData->bSectionwait) && (!pData->bFreezing));
  }
  else
  {
    if (pData->iBreakpoint)            /* do we need to finish something first ? */
    {
      switch (pData->iBreakpoint)      /* return to broken display routine */
      {
#ifndef MNG_SKIPCHUNK_FRAM
        case  1 : { iRetcode = mng_process_display_fram2 (pData); break; }
#endif
        case  2 : { iRetcode = mng_process_display_ihdr  (pData); break; }
#ifndef MNG_SKIPCHUNK_SHOW
        case  3 : ;                     /* same as 4 !!! */
        case  4 : { iRetcode = mng_process_display_show  (pData); break; }
#endif
#ifndef MNG_SKIPCHUNK_CLON
        case  5 : { iRetcode = mng_process_display_clon2 (pData); break; }
#endif
#ifdef MNG_INCLUDE_JNG
        case  7 : { iRetcode = mng_process_display_jhdr  (pData); break; }
#endif
        case  6 : ;                     /* same as 8 !!! */
        case  8 : { iRetcode = mng_process_display_iend  (pData); break; }
#ifndef MNG_SKIPCHUNK_MAGN
        case  9 : { iRetcode = mng_process_display_magn2 (pData); break; }
#endif
        case 10 : { iRetcode = mng_process_display_mend2 (pData); break; }
#ifndef MNG_SKIPCHUNK_PAST
        case 11 : { iRetcode = mng_process_display_past2 (pData); break; }
#endif
      }
    }
  }

  if (iRetcode)                        /* on error bail out */
    return iRetcode;

#endif /* MNG_SUPPORT_DISPLAY */
                                       /* can we continue processing now, or do we */
                                       /* need to wait for the timer to finish (again) ? */
#ifdef MNG_SUPPORT_DISPLAY
  if ((!pData->bTimerset) && (!pData->bSectionwait) && (!pData->bEOF))
#else
  if (!pData->bEOF)
#endif
  {
    pData->iSuspendpoint = 0;            /* safely reset it here ! */
    pPush = pData->pFirstpushchunk;

    iRetcode = process_raw_chunk (pData, pPush->pData, pPush->iLength);
    if (iRetcode)
      return iRetcode;

#ifdef MNG_SUPPORT_DISPLAY             /* refresh needed ? */
    if ((!pData->bTimerset) && (!pData->bSuspended) && (pData->bNeedrefresh))
    {
      iRetcode = mng_display_progressive_refresh (pData, 1);
      if (iRetcode)                      /* on error bail out */
        return iRetcode;
    }
#endif
  }

  return mng_release_pushchunk (pData);
}

/* ************************************************************************** */

mng_retcode mng_read_graphic (mng_datap pData)
{
  mng_uint32  iBuflen;                 /* number of bytes requested */
  mng_uint32  iRead;                   /* number of bytes read */
  mng_retcode iRetcode;                /* temporary error-code */

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (pData, MNG_FN_READ_GRAPHIC, MNG_LC_START);
#endif

  if (!pData->pReadbuf)                /* buffer allocated ? */
  {
    pData->iReadbufsize = 4200;        /* allocate a default read buffer */
    MNG_ALLOC (pData, pData->pReadbuf, pData->iReadbufsize);
  }
                                       /* haven't processed the signature ? */
  if ((!pData->bHavesig) || (pData->iSuspendpoint == 1))
  {
    iBuflen = 2 * sizeof (mng_uint32); /* read signature */

    iRetcode = read_databuffer (pData, pData->pReadbuf, &pData->pReadbufnext, iBuflen, &iRead);

    if (iRetcode)
      return iRetcode;

    if (pData->bSuspended)             /* input suspension ? */
      pData->iSuspendpoint = 1;
    else
    {
      if (iRead != iBuflen)            /* full signature received ? */
        MNG_ERROR (pData, MNG_UNEXPECTEDEOF);
                                       /* is it a valid signature ? */
      if (mng_get_uint32 (pData->pReadbuf) == PNG_SIG)
        pData->eSigtype = mng_it_png;
      else
#ifdef MNG_INCLUDE_JNG
      if (mng_get_uint32 (pData->pReadbuf) == JNG_SIG)
        pData->eSigtype = mng_it_jng;
      else
#endif
      if (mng_get_uint32 (pData->pReadbuf) == MNG_SIG)
        pData->eSigtype = mng_it_mng;
      else
        MNG_ERROR (pData, MNG_INVALIDSIG);
                                       /* all of it ? */
      if (mng_get_uint32 (pData->pReadbuf+4) != POST_SIG)
        MNG_ERROR (pData, MNG_INVALIDSIG);

      pData->bHavesig = MNG_TRUE;
    }
  }

  if (!pData->bSuspended)              /* still going ? */
  {
    do
    {                                  /* reset timer during mng_read() ? */
      if ((pData->bReading) && (!pData->bDisplaying))
        pData->bTimerset = MNG_FALSE;

      if (pData->pFirstpushchunk)      /* chunks pushed ? */
        iRetcode = process_pushedchunk (pData); /* process the pushed chunk */
      else
        iRetcode = read_chunk (pData); /* read & process a chunk */

      if (iRetcode)                    /* on error bail out */
        return iRetcode;
    }
#ifdef MNG_SUPPORT_DISPLAY             /* until EOF or a break-request */
    while (((!pData->bEOF) || (pData->pCurraniobj)) &&
           (!pData->bSuspended) && (!pData->bSectionwait) &&
           ((!pData->bTimerset) || ((pData->bReading) && (!pData->bDisplaying))));
#else
    while ((!pData->bEOF) && (!pData->bSuspended));
#endif
  }

#ifdef MNG_SUPPORT_TRACE
  MNG_TRACE (pData, MNG_FN_READ_GRAPHIC, MNG_LC_END);
#endif

  return MNG_NOERROR;
}

/* ************************************************************************** */

#endif /* MNG_INCLUDE_READ_PROCS */

/* ************************************************************************** */
/* * end of file                                                            * */
/* ************************************************************************** */