mpeg.c

本程序为ST公司开发的源代码

    return (MP4_INDEX->chunkMax > MP4_INDEX->chunkCount) ? kDecoderStatus_MoreData
                                                         : kDecoderStatus_NoError;
}

void mpeg_adjust_bitrate(eDecoderSampleRate sample, unsigned int* bitrate, void* buf)
{
    if((0 < MP4_INDEX->framePerChunk) && (8 < MP4_INDEX->chunkMax))
    {
        unsigned int count = MP4_INDEX->chunkMax - 1;
        *bitrate = ((*(MP4_INDEX->chunk + count)) - (*(MP4_INDEX->chunk)))
                 / (MP4_INDEX->framePerChunk * count)
                 * (sample / 128);
    }
}

unsigned int mpeg_get_offset(void* buf)
{
    return (MP4_INDEX->chunk[0]);
}

eDecoderStatus mpeg_get_frame(int offset, void* buf, unsigned int* poffset,
                              unsigned int* psize)
{
    tFrame* size_frame;
    tChunk* offset_chunk = MP4_INDEX->chunk;
    unsigned int framePerChunk = MP4_INDEX->framePerChunk;
    unsigned int chunk = 0;
    unsigned int cum = 0;

    while(offset_chunk[chunk] < offset)
    {
        if(!offset_chunk[chunk])
        {
            *poffset = 0;
            *psize = 0;
            return kDecoderStatus_NoError;
        }
        chunk ++;
    }
    if(chunk)
    {
        chunk --;
    }
    size_frame = MP4_INDEX->frame + (chunk * framePerChunk);
    cum = offset_chunk[chunk];
    while((cum < offset) && framePerChunk)
    {
        if(0 == *size_frame)
        {
            *poffset = 0;
            *psize = 0;
            return kDecoderStatus_NoError;
        }
        cum += *size_frame ++;
        framePerChunk --;
    }
    if(!framePerChunk)
    {
        cum = offset_chunk[chunk + 1];
    }
    *poffset = cum;
    *psize = *size_frame;
    if(cum == offset)
    {
        return kDecoderStatus_NoError;
    }
    return kDecoderStatus_MoreData;
}

eDecoderStatus AAC_ParseMpeg(t_SongInfos *song_info, oDecoderHandle handle,
                             void *scratch, sDecoderBitstream *bitstream)
{
  sMpegEsds esds;

  char* pos = bitstream->data;
  unsigned int size = bitstream->dataLength;

  bitstream->dataOffset = 0;
  if (bitstream->dataLength < bitstream->dataRequired)
  {
    return kDecoderStatus_MoreData;
  }
  bitstream->headerOffset = 0;

  /* Ignore bs_byte for a while */
  switch(AAC_Decoder->Mpeg_Header)
  {
    case MPEG_STATUS_TRAK :
      if(kDecoderStatus_Error == mpeg_find_tag(MPEG_TRAK, &pos, &size))
      {
        bitstream->dataOffset = bitstream->dataLength - 8;
        AAC_Decoder->Mpeg_StreamOffset += bitstream->dataOffset;
        return kDecoderStatus_MoreData;
      }
      AAC_Decoder->Mpeg_TrakBound = AAC_Decoder->Mpeg_StreamOffset
                                  + (pos - bitstream->data) + size;
      AAC_Decoder->Mpeg_Header = MPEG_STATUS_ESDS;
      pos = bitstream->data;
      size = bitstream->dataLength;

    case MPEG_STATUS_ESDS :
      switch(mpeg_find_tag(MPEG_ESDS, &pos, &size))
      {
        case kDecoderStatus_Error :
          bitstream->dataOffset = bitstream->dataLength - 8;
          AAC_Decoder->Mpeg_StreamOffset += bitstream->dataOffset;
          return kDecoderStatus_MoreData;

        case kDecoderStatus_MoreData :
          bitstream->dataOffset = pos - bitstream->data;
          AAC_Decoder->Mpeg_StreamOffset += bitstream->dataOffset;
          return kDecoderStatus_MoreData;
      }
      size = bitstream->dataLength - (pos - bitstream->data);
      if(kDecoderStatus_NoError != mpeg_decode_esds(pos, size, &esds))
      {
        return kDecoderStatus_Fatal_BadBitstream;
      }

      AAC_Decoder->Frequency = esds.Frequency;
      AAC_Decoder->Hdr_Profile = esds.Profile;
      bitstream->sampleRate = (eDecoderSampleRate)iSampFreqs[esds.Frequency];
      bitstream->bitRate = esds.BitRate;
      iDemux_AssignDefaultPositions(handle, esds.Channel);
//      AAC_Decoder->Hdr_OriginalCopy = 0;
//      AAC_Decoder->Hdr_Home = 0;
      AAC_Decoder->Hdr_CopyrightBits = 1;

#if 0
      if (AAC_Decoder->Hdr_CopyrightBits < 72)
      {
        AAC_Decoder->Hdr_CopyrightID[AAC_Decoder->Hdr_CopyrightBits / 8]
          = (char) (AAC_Decoder->Hdr_CopyrightID[AAC_Decoder->Hdr_CopyrightBits / 8] 
          & ~(0x80 >> (AAC_Decoder->Hdr_CopyrightBits % 8)));
        AAC_Decoder->Hdr_CopyrightBits++;
      }
#endif // 0

      AAC_Decoder->Mpeg_Header = MPEG_STATUS_STSC;
      pos = bitstream->data;
      size = bitstream->dataLength;

    case MPEG_STATUS_STSC :
      switch(mpeg_find_tag(MPEG_STSC, &pos, &size))
      {
        case kDecoderStatus_Error :
          bitstream->dataOffset = bitstream->dataLength - 8;
          AAC_Decoder->Mpeg_StreamOffset += bitstream->dataOffset;
          return kDecoderStatus_MoreData;

        case kDecoderStatus_MoreData :
          bitstream->dataOffset = pos - bitstream->data;
          AAC_Decoder->Mpeg_StreamOffset += bitstream->dataOffset;
          return kDecoderStatus_MoreData;
      }
      size = bitstream->dataLength - (pos - bitstream->data);
      if(kDecoderStatus_NoError != mpeg_decode_stsc(pos, size, scratch))
      {
        return kDecoderStatus_Fatal_BadBitstream;
      }

      AAC_Decoder->Mpeg_Header = MPEG_STATUS_STSZ;
      pos = bitstream->data;
      size = bitstream->dataLength;

    case MPEG_STATUS_STSZ :
      if(kDecoderStatus_Error == mpeg_find_tag(MPEG_STSZ, &pos, &size))
      {
        bitstream->dataOffset = bitstream->dataLength - 8;
        AAC_Decoder->Mpeg_StreamOffset += bitstream->dataOffset;
        return kDecoderStatus_MoreData;
      }
      size = bitstream->dataLength - (pos - bitstream->data);
      if(kDecoderStatus_MoreData == mpeg_decode_stsz(&pos, &size, scratch))
      {
        bitstream->dataOffset = pos - bitstream->data;
        AAC_Decoder->Mpeg_StreamOffset += bitstream->dataOffset;
        return kDecoderStatus_MoreData;
      }

      AAC_Decoder->Mpeg_Header = MPEG_STATUS_STSZX;
//      AAC_Decoder->Mpeg_HeaderOffset = 0;

    case MPEG_STATUS_STSZX :
//      pos += AAC_Decoder->Mpeg_HeaderOffset;
//      size -= AAC_Decoder->Mpeg_HeaderOffset;
      if(kDecoderStatus_MoreData == mpeg_read_stsz(&pos, size, scratch))
      {
        bitstream->dataOffset = pos - bitstream->data;
//        AAC_Decoder->Mpeg_HeaderOffset = bitstream->dataOffset & 0x03;
//        if(AAC_Decoder->Mpeg_HeaderOffset)
//        {
//          bitstream->dataOffset -= AAC_Decoder->Mpeg_HeaderOffset;
//        }
        AAC_Decoder->Mpeg_StreamOffset += bitstream->dataOffset;
        return kDecoderStatus_MoreData;
      }

      AAC_Decoder->Mpeg_Header = MPEG_STATUS_STCO;
      pos = bitstream->data;
      size = bitstream->dataLength;

    case MPEG_STATUS_STCO :
      if(kDecoderStatus_Error == mpeg_find_tag(MPEG_STCO, &pos, &size))
      {
        bitstream->dataOffset = bitstream->dataLength - 8;
        AAC_Decoder->Mpeg_StreamOffset += bitstream->dataOffset;
        return kDecoderStatus_MoreData;
      }
      size = bitstream->dataLength - (pos - bitstream->data);
      if(kDecoderStatus_MoreData == mpeg_decode_stco(&pos, &size, scratch))
      {
        bitstream->dataOffset = pos - bitstream->data;
        AAC_Decoder->Mpeg_StreamOffset += bitstream->dataOffset;
        return kDecoderStatus_MoreData;
      }

      AAC_Decoder->Mpeg_Header = MPEG_STATUS_STCOX;
//      AAC_Decoder->Mpeg_HeaderOffset = 0;

    case MPEG_STATUS_STCOX :
//      pos += AAC_Decoder->Mpeg_HeaderOffset;
//      size -= AAC_Decoder->Mpeg_HeaderOffset;
      if(kDecoderStatus_MoreData == mpeg_read_stco(&pos, size, scratch))
      {
        bitstream->dataOffset = pos - bitstream->data;
//        AAC_Decoder->Mpeg_HeaderOffset = bitstream->dataOffset & 0x03;
//        if(AAC_Decoder->Mpeg_HeaderOffset)
//        {
//          bitstream->dataOffset -= AAC_Decoder->Mpeg_HeaderOffset;
//        }
        AAC_Decoder->Mpeg_StreamOffset += bitstream->dataOffset;
        return kDecoderStatus_MoreData;
      }

      mpeg_adjust_bitrate(bitstream->sampleRate, &(bitstream->bitRate), scratch);
      bitstream->channels.total = AAC_Decoder->Hdr_NumberOfChannels;
      bitstream->dataRequired = AAC_CHANNEL_BUFFER_SIZE * AAC_Decoder->Hdr_NumberOfChannels;
      AAC_Decoder->Mpeg_FrameOffset = mpeg_get_offset(scratch);

//      AAC_Decoder->Mpeg_Header = MPEG_STATUS_UDTA;
      AAC_Decoder->Mpeg_Header = MPEG_STATUS_READY;
//      AAC_Decoder->Mpeg_HeaderOffset = 0;

      bitstream->headerOffset = 1;
      bitstream->frameRemain = AAC_Decoder->Mpeg_FrameOffset;
      bitstream->samplesPerChannelPerFrame = 1024;
//      return kDecoderStatus_MoreData;
      return kDecoderStatus_NoError;

#if 0
    case MPEG_STATUS_UDTA :
      if(kDecoderStatus_Error == mpeg_find_tag(MPEG_UDTA, &pos, &size))
      {
        bitstream->dataOffset = bitstream->dataLength - 8;
        AAC_Decoder->Mpeg_StreamOffset += bitstream->dataOffset;
        if(bitstream->frameRemain <= AAC_Decoder->Mpeg_StreamOffset)
        {
          return kDecoderStatus_NoError;
        }
        return kDecoderStatus_MoreData;
      }
      AAC_Decoder->Mpeg_TrakBound = AAC_Decoder->Mpeg_StreamOffset
                                  + (pos - bitstream->data) + size;
      if(bitstream->frameRemain <= AAC_Decoder->Mpeg_TrakBound)
      {
        return kDecoderStatus_NoError;
      }
      AAC_Decoder->Mpeg_Header = MPEG_STATUS_ILST;
      size = bitstream->dataLength - (pos - bitstream->data);

    case MPEG_STATUS_ILST :
      if(kDecoderStatus_Error == mpeg_find_tag(MPEG_ILST, &pos, &size))
      {
        bitstream->dataOffset = bitstream->dataLength - 8;
        AAC_Decoder->Mpeg_StreamOffset += bitstream->dataOffset;
        if(AAC_Decoder->Mpeg_TrakBound <= AAC_Decoder->Mpeg_StreamOffset)
        {
          return kDecoderStatus_NoError;
        }
        return kDecoderStatus_MoreData;
      }
      AAC_Decoder->Mpeg_TrakBound = AAC_Decoder->Mpeg_StreamOffset
                                  + (pos - bitstream->data) + size;
      if(bitstream->frameRemain <= AAC_Decoder->Mpeg_TrakBound)
      {
        return kDecoderStatus_NoError;
      }
      AAC_Decoder->Mpeg_Header = MPEG_STATUS_ILSTX;
      size = bitstream->dataLength - (pos - bitstream->data);

    case MPEG_STATUS_ILSTX :
      if(kDecoderStatus_MoreData == mpeg_decode_stco(&pos, &size, scratch))
      {
        bitstream->dataOffset = pos - bitstream->data;
        AAC_Decoder->Mpeg_StreamOffset += bitstream->dataOffset;
        return kDecoderStatus_MoreData;
      }
    
      AAC_Decoder->Mpeg_Header = MPEG_STATUS_STCOX;
#endif // 0
  }
  return kDecoderStatus_Fatal_Error;
}

#endif /* HAVE_AAC */