shorten.c

无损音频压缩源码. 毕业设计 qq 64134703 更多毕业设计 www.rmlcd.cn

        }
        if(magic[nscan] != '\0' && byte == magic[nscan])
          nscan++;
        else if(magic[nscan] == '\0' && byte <= MAX_VERSION)
          version = byte;
        else
        {
          for(i = 0; i < nscan; i++)
            if (0 == WriteSeekTable) {
              putc_exit(magic[i], fileo);
            }
          if(byte == magic[0])
            nscan = 1;
          else
          {
            if (0 == WriteSeekTable) {
              putc_exit(byte, fileo);
            }
            nscan = 0;
          }
          version = MAX_VERSION + 1;
        }
      }
    }

    /* check version number */
    if(version > MAX_SUPPORTED_VERSION)
      update_exit(1, "can't decode version %d\n", version);

    /* set up the default nmean, ignoring the command line state */
    nmean = (version < 2) ? DEFAULT_V0NMEAN : DEFAULT_V2NMEAN;

    /* initialise the variable length file read for the compressed stream */
    var_get_init();

    /* initialise the fixed length file write for the uncompressed stream */
    fwrite_type_init();

    /* get the internal file type */
    internal_ftype = UINT_GET(TYPESIZE, filei);

    /* has the user requested a change in file type? */
    if(internal_ftype != ftype) {
      if(ftype == TYPE_EOF)
        ftype = internal_ftype;    /*  no problems here */
      else             /* check that the requested conversion is valid */
        if(internal_ftype == TYPE_AU1 || internal_ftype == TYPE_AU2 ||
           internal_ftype == TYPE_AU3 || ftype == TYPE_AU1 ||ftype == TYPE_AU2 || ftype == TYPE_AU3)
          error_exit("Not able to perform requested output format conversion\n");
    }

    nchan = UINT_GET(CHANSIZE, filei);

    /* get blocksize if version > 0 */
    if(version > 0)
    {
      blocksize = UINT_GET((int) (log((double) DEFAULT_BLOCK_SIZE) / M_LN2),filei);
      maxnlpc = UINT_GET(LPCQSIZE, filei);
      nmean = UINT_GET(0, filei);
      nskip = UINT_GET(NSKIPSIZE, filei);
      for(i = 0; i < nskip; i++)
      {
        int byte = uvar_get(XBYTESIZE, filei);
        putc_exit(byte, fileo);
      }
    }
    else
      blocksize = DEFAULT_BLOCK_SIZE;

    nwrap = MAX(NWRAP, maxnlpc);

    /* grab some space for the input buffer */
    buffer  = long2d((ulong) nchan, (ulong) (blocksize + nwrap));
    offset  = long2d((ulong) nchan, (ulong) MAX(1, nmean));

    for(chan = 0; chan < nchan; chan++)
    {
      for(i = 0; i < nwrap; i++)
       buffer[chan][i] = 0;
      buffer[chan] += nwrap;
    }

    if(maxnlpc > 0)
      qlpc = (int*) pmalloc((ulong) (maxnlpc * sizeof(*qlpc)));

    if(version > 1)
      lpcqoffset = V2LPCQOFFSET;

    init_offset(offset, nchan, MAX(1, nmean), internal_ftype);

    if(WriteSeekTable && extract)
    {
      if(0 == Pass && (saw_s_op || saw_S_op))
        fprintf(stderr,"creating seek table file: '%s'\n",SeekTableFilename);
      else if (AppendSeekInfo)
        fprintf(stderr,"appending seek table to '%s'\n",filenamei);

      if((SeekTableFile = fopen(SeekTableFilename, writemode)) == NULL)
        usage_exit(1, "could not open seek table file '%s'\n", SeekTableFilename);

      fwrite(SeekTableHeader.data,1,SEEK_HEADER_SIZE,SeekTableFile);
    }

    /* get commands from file and execute them */
    chan = 0;
    while(1)
    {
      ReadingFunctionCode=TRUE;
      cmd = uvar_get(FNSIZE, filei);

      CBuf_0_Minus1=(slong)buffer[0][-1];
      CBuf_0_Minus2=(slong)buffer[0][-2];
      CBuf_0_Minus3=(slong)buffer[0][-3];
      Offset_0_0=(slong)offset[0][0];
      Offset_0_1=(slong)offset[0][1];
      Offset_0_2=(slong)offset[0][2];
      Offset_0_3=(slong)offset[0][3];

      if (nchan > 1)
      {
        CBuf_1_Minus1=(slong)buffer[1][-1];
        CBuf_1_Minus2=(slong)buffer[1][-2];
        CBuf_1_Minus3=(slong)buffer[1][-3];
        Offset_1_0=(slong)offset[1][0];
        Offset_1_1=(slong)offset[1][1];
        Offset_1_2=(slong)offset[1][2];
        Offset_1_3=(slong)offset[1][3];
      }
      else
      {
        CBuf_1_Minus1=0;
        CBuf_1_Minus2=0;
        CBuf_1_Minus3=0;
        Offset_1_0=0;
        Offset_1_1=0;
        Offset_1_2=0;
        Offset_1_3=0;
      }

      ReadingFunctionCode=FALSE;

      if(FN_QUIT==cmd)
        break;
      else
      {
#ifdef _WINDOWS
        /* Include processing to enable Windows program to abort */
        CheckWindowsAbort();
#endif
        switch(cmd)
        {
          case FN_ZERO:
          case FN_DIFF0:
          case FN_DIFF1:
          case FN_DIFF2:
          case FN_DIFF3:
          case FN_QLPC:
          {
            slong coffset, *cbuffer = buffer[chan];
            int resn = 0, nlpc, j;

            if(cmd != FN_ZERO)
            {
              resn = uvar_get(ENERGYSIZE, filei);
              /* this is a hack as version 0 differed in definition of var_get */
              if(version == 0)
                resn--;
            }

            /* find mean offset : N.B. this code duplicated */
            if(nmean == 0)
              coffset = offset[chan][0];
            else
            {
              slong sum = (version < 2) ? 0 : nmean / 2;
              for(i = 0; i < nmean; i++)
                sum += offset[chan][i];
              if(version < 2)
                coffset = sum / nmean;
              else
                coffset = ROUNDEDSHIFTDOWN(sum / nmean, bitshift);
            }

            switch(cmd)
            {
              case FN_ZERO:
                for(i = 0; i < blocksize; i++)
                  cbuffer[i] = 0;
                break;
              case FN_DIFF0:
                for(i = 0; i < blocksize; i++)
                  cbuffer[i] = var_get(resn, filei) + coffset;
                break;
              case FN_DIFF1:
                for(i = 0; i < blocksize; i++)
                  cbuffer[i] = var_get(resn, filei) + cbuffer[i - 1];
                break;
              case FN_DIFF2:
                for(i = 0; i < blocksize; i++)
                  cbuffer[i] = var_get(resn, filei) + (2 * cbuffer[i - 1] - cbuffer[i - 2]);
                break;
              case FN_DIFF3:
                for(i = 0; i < blocksize; i++)
                  cbuffer[i] = var_get(resn, filei) + 3 * (cbuffer[i - 1] -  cbuffer[i - 2]) + cbuffer[i - 3];
                break;
              case FN_QLPC:
                nlpc = uvar_get(LPCQSIZE, filei);

                for(i = 0; i < nlpc; i++)
                  qlpc[i] = var_get(LPCQUANT, filei);
                for(i = 0; i < nlpc; i++)
                  cbuffer[i - nlpc] -= coffset;
                for(i = 0; i < blocksize; i++)
                {
                  slong sum = lpcqoffset;

                  for(j = 0; j < nlpc; j++)
                    sum += qlpc[j] * cbuffer[i - j - 1];
                  cbuffer[i] = var_get(resn, filei) + (sum >> LPCQUANT);
                }
                if(coffset != 0)
                  for(i = 0; i < blocksize; i++)
                    cbuffer[i] += coffset;
                break;
            }

            /* store mean value if appropriate : N.B. Duplicated code */
            if(nmean > 0)
            {
              slong sum = (version < 2) ? 0 : blocksize / 2;

              for(i = 0; i < blocksize; i++)
                sum += cbuffer[i];

              for(i = 1; i < nmean; i++)
                offset[chan][i - 1] = offset[chan][i];
              if(version < 2)
                offset[chan][nmean - 1] = sum / blocksize;
              else
                offset[chan][nmean - 1] = (sum / blocksize) << bitshift;
            }

            if(chan==0)
            {
              if(WriteSeekTable && WriteCount%100 == 0)
              {
                TSeekEntry SeekEntry;

                ulong_to_uchar_le(SeekEntry.data,SampleNumber);
                ulong_to_uchar_le(SeekEntry.data+4,SHNFilePosition);
                ulong_to_uchar_le(SeekEntry.data+8,SHNLastBufferReadPosition);
                ushort_to_uchar_le(SeekEntry.data+12,SHNByteGet);
                ushort_to_uchar_le(SeekEntry.data+14,SHNBufferOffset);
                ushort_to_uchar_le(SeekEntry.data+16,SHNBitPosition);
                ulong_to_uchar_le(SeekEntry.data+18,SHNGBuffer);
                ushort_to_uchar_le(SeekEntry.data+22,bitshift);

                long_to_uchar_le(SeekEntry.data+24,CBuf_0_Minus1);
                long_to_uchar_le(SeekEntry.data+28,CBuf_0_Minus2);
                long_to_uchar_le(SeekEntry.data+32,CBuf_0_Minus3);

                long_to_uchar_le(SeekEntry.data+36,CBuf_1_Minus1);
                long_to_uchar_le(SeekEntry.data+40,CBuf_1_Minus2);
                long_to_uchar_le(SeekEntry.data+44,CBuf_1_Minus3);

                long_to_uchar_le(SeekEntry.data+48,Offset_0_0);
                long_to_uchar_le(SeekEntry.data+52,Offset_0_1);
                long_to_uchar_le(SeekEntry.data+56,Offset_0_2);
                long_to_uchar_le(SeekEntry.data+60,Offset_0_3);

                long_to_uchar_le(SeekEntry.data+64,Offset_1_0);
                long_to_uchar_le(SeekEntry.data+68,Offset_1_1);
                long_to_uchar_le(SeekEntry.data+72,Offset_1_2);
                long_to_uchar_le(SeekEntry.data+76,Offset_1_3);

                fwrite(&SeekEntry,SEEK_ENTRY_SIZE,1,SeekTableFile);
              }
              WriteCount++;
            }

            /* do the wrap */
            for(i = -nwrap; i < 0; i++)
              cbuffer[i] = cbuffer[i + blocksize];

            fix_bitshift(cbuffer, blocksize, bitshift, internal_ftype);

            if(chan == nchan - 1)
            {
              SampleNumber+=blocksize;
              fwrite_type(buffer, ftype, nchan, blocksize, fileo);
            }
            chan = (chan + 1) % nchan;
            break;
          }

          case FN_BLOCKSIZE:
            blocksize = UINT_GET((int) (log((double) blocksize) / M_LN2), filei);
            break;
          case FN_BITSHIFT:
            bitshift = uvar_get(BITSHIFTSIZE, filei);
            break;
          case FN_VERBATIM:
          {
            int cklen = uvar_get(VERBATIM_CKSIZE_SIZE, filei);
            while (cklen--)
            {
              int ByteToWrite = uvar_get(VERBATIM_BYTE_SIZE, filei);
              if(WriteWaveFile)
                fputc(ByteToWrite,fileo);
            }
            break;
          }

          default:
            update_exit(1, "sanity check fails trying to decode function: %d\n",cmd);
        }
      }
    }

    /* wind up */
    var_get_quit();
    fwrite_type_quit();

    free((void *) buffer);
    free((void *) offset);
    if(maxnlpc > 0)
      free((void *) qlpc);
  }

  /* close the files if this function opened them */
  if(filei && filei != stdi)
    fclose(filei);
  if(fileo && fileo != stdo)
    fclose(fileo);

  /* make the output file look like the original if possible */
  if((filei != stdi) && (fileo != stdo))
    (void) dupfileinfo(filenamei, filenameo);

  filei = fileo = 0;

  if(!extract && filenamei && filenameo && strcmp(filenameo,minusstr))
  {
    extract=TRUE;
    WriteWaveFile=FALSE;
    AppendSeekInfo=WriteSeekTable=want_seeking;
    filenamei=filenameo;
    Pass++;
    strcpy(SeekTableFilename,filenamei);
    if(0==strcmp(filenamei+strlen(filenamei)-strlen(FILESUFFIX),FILESUFFIX))
      memcpy(SeekTableFilename+strlen(filenamei)-3,"skt",3);
    else
      strcat(SeekTableFilename,".skt");
    goto StartAgain;
  }

  if(SeekTableFile)
  {
    ulong SeekTableSize;
    uchar *pSeekTableBuffer;

    fclose(SeekTableFile);

    SeekTableFile=fopen(SeekTableFilename,"rb+");
    if(!SeekTableFile)
      usage_exit(1,"failure opening '%s': %s\n",SeekTableFilename,strerror(errno));

    fseek(SeekTableFile,0,SEEK_END);
    SeekTableSize=ftell(SeekTableFile);

    /* first, rewrite the seek table file with the correct shn file size */

    /* allocate some memory and reload the seek table */
    pSeekTableBuffer=(uchar*)malloc(SeekTableSize);
    fseek(SeekTableFile,0,SEEK_SET);
    fread(pSeekTableBuffer,SeekTableSize,1,SeekTableFile);

    /* copy the shn file size to the SeekTableHeader */
    ulong_to_uchar_le(pSeekTableBuffer+8,bytes_read);

    fclose(SeekTableFile);

    SeekTableFile=fopen(SeekTableFilename,"wb+");
    if(!SeekTableFile)
      usage_exit(1,"failure reopening '%s' - %s\n",SeekTableFilename,strerror(errno));

    /* rewrite the seek table file */
    fwrite(pSeekTableBuffer,1,SeekTableSize,SeekTableFile);

    /* close the seek table file, and re-open it */
    fclose(SeekTableFile);
    free(pSeekTableBuffer);

    SeekTableFile=fopen(SeekTableFilename,"rb+");
    if(!SeekTableFile)
      usage_exit(1,"failure reopening '%s' - %s\n",SeekTableFilename,strerror(errno));

    if(AppendSeekInfo)
    {
      filei = fopen(filenamei,"ab+");

      if(!filei)
        usage_exit(1,"failure opening '%s': %s\n",filenamei,strerror(errno));

      fseek(filei,0,SEEK_END);

      fseek(SeekTableFile,0,SEEK_END);
      SeekTableSize=ftell(SeekTableFile) + SEEK_TRAILER_SIZE;

      /* allocate some memory and reload the seek table */
      pSeekTableBuffer=(uchar*)malloc(SeekTableSize);
      fseek(SeekTableFile,0,SEEK_SET);
      fread(pSeekTableBuffer,SeekTableSize-SEEK_TRAILER_SIZE,1,SeekTableFile);

      /* set the seek table size and copy the trailer to the buffer */
      ulong_to_uchar_le(SeekTableTrailer.data,SeekTableSize);
      memcpy(pSeekTableBuffer+SeekTableSize-SEEK_TRAILER_SIZE,&SeekTableTrailer,SEEK_TRAILER_SIZE);

      /* append the seek table and the trailer to the shn file */
      fwrite(pSeekTableBuffer,1,SeekTableSize,filei);

      free(pSeekTableBuffer);

      if (!saw_s_op && !saw_S_op)
        if(unlink(SeekTableFilename))
          usage_exit(1, "could not remove seek table file '%s': %s\n",SeekTableFilename,strerror(errno));
    }

    /* and finally close the files */
    if (filei)
      fclose(filei);

    filei = 0;
    fclose(SeekTableFile);
  }

  if(tmpfilename != NULL)
    free(tmpfilename);

  if(nfilename == 1 && !(saw_s_op || saw_S_op || saw_k_op))
    if (unlink(filenamei_orig))
      usage_exit(1, "could not remove file '%s'\n", filenamei_orig);

#ifdef MSDOS
#ifdef MSDOS_DO_TIMING
  endTime = clock();
  fprintf(stderr,"elapsed time: %g sec\n",((double)(endTime-startTime))/CLOCKS_PER_SEC);
#endif
#endif

  /* quit happy */
  return(0);
}