mp4ifc.c

MPEG2/MPEG4编解码参考程序(实现了MPEG4的部分功能)

        {
          MP4Track theTrack;
          u32    enabled = 0;

          err = MP4GetMovieIndTrack (theMovie, idx, &theTrack) ; if (err) goto bail;
          err = MP4GetTrackEnabled (theTrack, &enabled ); if (err) goto bail;

          if (enabled)
          {
            MP4Media theMedia;
      	    u32    handlerType;

	          err = MP4GetTrackMedia(theTrack, &theMedia ); if (err) goto bail;
	          err = MP4GetMediaHandlerDescription(theMedia, &handlerType, NULL ); if (err) goto bail;

            if (handlerType == MP4AudioHandlerType)
            {
              MP4Track refTrack ;
              u32 outRefIndex = 0, i ;

              err = MP4GetTrackReferenceCount (theTrack, MP4StreamDependencyReferenceType, &outRefIndex) ;

              for (i = 1 ; i <= outRefIndex ; i++)
              {
                err = MP4GetTrackReference (theTrack, MP4StreamDependencyReferenceType, i, &refTrack) ;
                if (refTrack == baseTrack)
                {
                  trackNumber [suitableTracks++] = idx ;
                  baseTrack = theTrack ;
                  break ;
                }
              }
            }
          }
        }
      }
      while (idx < trackCount) ;
    }
  }

bail :

  return suitableTracks ;
}

static int MP4Audio_ReadInitialOD (MP4Movie theMovie, int ignoreProfiles)
{
  MP4Handle initialODH = NULL ;
  MP4Err err ;

  err = MP4NewHandle( 0, &initialODH ); 
  err = MP4GetMovieInitialObjectDescriptor (theMovie, initialODH );

  if (!err)
  {
    unsigned long tag, tmp ;
    unsigned long sizeOfClass ;

    unsigned long id ;
    unsigned long urlFlag ;
    unsigned long inlineFlag ;

    unsigned long odProfile = 0 ;
    unsigned long sceneProfile = 0 ;
    unsigned long audioProfile = 0 ;
    unsigned long visualProfile = 0 ;
    unsigned long graphicsProfile = 0 ;

    BsBitStream *bs = MP4Audio_BsFromHandle (initialODH) ;

    BsGetBit (bs, &tag, 8) ;
    if (tag != initialObjectDescrTag)
    {
      fprintf (stderr, "Failure: IOD class tag == %ld \n", tag);
      err = MP4BadDataErr ; goto bail ;
    }

    for (sizeOfClass = 0, tmp = 0x80 ; tmp &= 0x80 ;
         sizeOfClass = (sizeOfClass << 7) | (tmp & 0x7F))
         BsGetBit (bs, &tmp, 8) ;

    BsGetBit (bs, &id, 10) ;
    BsGetBit (bs, &urlFlag, 1) ;
    BsGetBit (bs, &inlineFlag, 1) ;
    BsGetBit (bs, &tmp, 4) ;

    if (!urlFlag)
    {
      BsGetBit (bs, &odProfile, 8) ;
      BsGetBit (bs, &sceneProfile, 8) ;
      BsGetBit (bs, &audioProfile, 8) ;
      BsGetBit (bs, &visualProfile, 8) ;
      BsGetBit (bs, &graphicsProfile, 8) ;
    }

    if (!ignoreProfiles)
    {
      if (odProfile != 0xFF)
      {
        fprintf (stderr, "Failure: Can't handle OD profile %ld \n", tag);
        err = MP4BadDataErr ; goto bail ;
      }

      if (sceneProfile != 0xFF)
      {
        fprintf (stderr, "Failure: Can't handle BIFS profile %ld \n", tag);
        err = MP4BadDataErr ; goto bail ;
      }

      if (visualProfile != 0xFF)
      {
        fprintf (stderr, "Failure: Can't handle VIDEO profile %ld \n", tag);
        err = MP4BadDataErr ; goto bail ;
      }

      if (graphicsProfile != 0xFF)
      {
        fprintf (stderr, "Failure: Can't handle GRAPHICS profile %ld \n", tag);
        err = MP4BadDataErr ; goto bail ;
      }
    }

bail :

    BsCloseRemove (bs, 0) ;
  }

  MP4DisposeHandle (initialODH) ;

  return err ;
}

static int MP4Audio_ReadDecoderConfig (MP4Handle decConfigH, DecoderConfigDescr *decConfig)
{
  MP4Err err = MP4NoErr ;

  unsigned long tag, tmp ;
  unsigned long sizeOfClass ;

  BsBitStream *bs = MP4Audio_BsFromHandle (decConfigH) ;

  BsGetBit (bs, &tag, 8) ;
  if (tag != decoderConfigDescrTag)
  {
    fprintf (stderr, "Failure: DecoderConfig class tag == %ld\n", tag);
    err = MP4BadDataErr ; goto bail ;
  }

  for (sizeOfClass = 0, tmp = 0x80 ; tmp &= 0x80 ;
       sizeOfClass = (sizeOfClass << 7) | (tmp & 0x7F))
       BsGetBit (bs, &tmp, 8) ;

  BsGetBit (bs, &decConfig->objectTypeIndication, 8) ;
  if (decConfig->objectTypeIndication != 0x40)
  {
    fprintf (stderr, "Failure: objectTypeIndication not Audio\n");
    err = MP4BadDataErr ; goto bail ;
  }

  BsGetBit (bs, &decConfig->streamType, 6) ;
  if (decConfig->streamType != 0x5)
  {
    fprintf (stderr, "Failure: streamType not Audio\n");
    err = MP4BadDataErr ; goto bail ;
  }

  BsGetBit (bs, &decConfig->upStream, 1) ;
  BsGetBit (bs, &tmp, 1) ;
  BsGetBit (bs, &decConfig->bufferSizeDB, 24) ;
  BsGetBit (bs, &decConfig->maxBitrate, 32) ;
  BsGetBit (bs, &decConfig->avgBitrate, 32) ;

  /* DecoderSpecificInfo */

  BsGetBit (bs, &tag, 8) ;
  if (tag != decSpecificInfoTag)
  {
    fprintf (stderr, "Failure: DecoderSpecificInfo class tag == %ld\n", tag);
    err = MP4BadDataErr ; goto bail ;
  }

  for (sizeOfClass = 0, tmp = 0x80 ; tmp &= 0x80 ;
       sizeOfClass = (sizeOfClass << 7) | (tmp & 0x7F))
       BsGetBit (bs, &tmp, 8) ;

  BsGetBit (bs, &decConfig->audioObjectType, 5) ;
  BsGetBit (bs, &decConfig->samplingFrequencyIndex, 4) ;
  if (decConfig->samplingFrequencyIndex == 0x0F)
  {
    BsGetBit (bs, &decConfig->samplingFrequency, 4) ;
  }
  else
  {
    static const unsigned long samplingRate [] = 
    {
      96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350
    } ;

    decConfig->samplingFrequency = samplingRate [decConfig->samplingFrequencyIndex] ;
  }

  BsGetBit (bs, &decConfig->channelConfiguration, 4) ;

  switch (decConfig->audioObjectType)
  {
    case 1 : /* AAC Main */
    case 2 : /* AAC LC */
    case 6 : /* AAC Scalable */

      BsGetBit (bs, &decConfig->frameLengthFlag, 1) ;
      BsGetBit (bs, &decConfig->dependsOnCoreCoder, 1) ;
      if (decConfig->dependsOnCoreCoder)
      {
        BsGetBit (bs, &decConfig->coreCoderDelay, 14) ;
      }
      else
        decConfig->coreCoderDelay = 0 ;

      BsGetBit (bs, &decConfig->extensionFlag, 1) ;
      break ;

    default :

      fprintf (stderr, "Failure: audioObjectType == %ld\n", decConfig->audioObjectType);
      err = MP4BadDataErr ; goto bail ;
  }

bail :

  BsCloseRemove (bs, 0) ;

  return err ;
}

static BsBitStream *MP4Audio_BsFromHandle (MP4Handle theHandle)
{
  u32    handleSize ;
  MP4Err err = MP4GetHandleSize (theHandle, &handleSize) ;
  if (!err)
  {
    BsBitBuffer *bb = (BsBitBuffer *)malloc (sizeof (BsBitBuffer)) ;
    bb->data = (unsigned char *) (*theHandle) ;
    bb->numBit = handleSize * 8 ;
    bb->size = handleSize * 8 ;

    return BsOpenBufferRead (bb) ;
  }

  return NULL ;
}

int MP4Audio_SetupDecoders (FRAME_DATA *fD, DecoderConfigDescr decConfig [maxTracks],
                            int maxLayer,          /* in: number of Layers */
                            char *audioFileName,   /* in: audio file name */
                            char *audioFileFormat, /* in: audio file format (au, wav, aif, raw) */
                            int   numChannelOut,   /* in: num audio channels */
                            float fSampleOut,      /* in: sampling frequency [Hz] */
                            char *decPara)         /* in: decoder parameter string */
{
  int layer ;
  


  memset (fD, sizeof (FRAME_DATA), 0) ;
  AudioInit(NULL,0 /* audioDebugLevel */);

  initObjDescr(&objDescr);
  fD->od = &objDescr;

  fD->od->streamCount.value = maxLayer ;

  for ( layer = 0; layer < maxLayer; layer++ )
  {
    AUDIO_SPECIFIC_CONFIG *audSpC ;
    
    initESDescr(&(fD->od->ESDescriptor[layer]));
    
    audSpC = &fD->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig;

    audSpC->audioDecoderType.value = decConfig [layer].audioObjectType ;
    audSpC->channelConfiguration.value = decConfig [layer].channelConfiguration ;
    audSpC->samplingFreqencyIndex.value = decConfig [layer].samplingFrequencyIndex ;

    audSpC->specConf.TFSpecificConfig.frameLength.value = decConfig [layer].frameLengthFlag ;
    fD->od->ESDescriptor[layer]->DecConfigDescr.avgBitrate.value = decConfig [layer].avgBitrate ;
   
    fD->layer [layer].bitBuf = BsAllocBuffer(64000);
    fD->layer [layer].sampleRate = decConfig [layer].samplingFrequency ;
    fD->layer [layer].bitRate = decConfig [layer].avgBitrate ;

    if (decConfig [layer].audioObjectType == 6)
    {
      /* patch for getModeFromOD() scal_dec_frame.c */

      fD->od->ESDescriptor[layer]->DecConfigDescr.audioSpecificConfig.audioDecoderType.value = 0 ;
    }
  }

  /* audioObjectType AAC Scalable */

  DecTfInitNew (decPara,
                NULL, /* aacDebugString */
                &hFault->hVm,
                &hFault->hHcrSpecData,
                fD,
                &tfData,
                &lpcData,
                &nttData,
                0, /* mainDebugLevel */
                0
                ) ; /* layer */

  /* open audio file */
  /* (sample format: 16 bit twos complement, uniform quantisation) */

  audioFile = AudioOpenWrite(audioFileName,audioFileFormat,
                             numChannelOut,fSampleOut);
  if (audioFile==NULL)
    CommonExit(1,"Decode: error opening audio file %s "
               "(maybe unknown format \"%s\")",
               audioFileName,audioFileFormat);

  return 0 ;
}