mp4.cpp

6410BSP1

    }
    return MP4_INVALID_TRACK_ID;
}

extern "C" u_int16_t MP4FindTrackIndex(
    MP4FileHandle hFile, MP4TrackId trackId)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->FindTrackIndex(trackId);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return (u_int16_t)-1;
}

/* specific track properties */

extern "C" const char* MP4GetTrackType(
    MP4FileHandle hFile, MP4TrackId trackId)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->GetTrackType(trackId);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return NULL;
}
extern "C" const char* MP4GetTrackMediaDataName(
    MP4FileHandle hFile, MP4TrackId trackId)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {

    __try {
            return ((MP4File*)hFile)->GetTrackMediaDataName(trackId);
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
//    printf("\nMP4GetTrackMediaDataName EXCEPTION....");
    }
/*
        __try {
            return ((MP4File*)hFile)->GetTrackMediaDataName(trackId);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
            PRINT_ERROR(e);
            delete e;
        }
*/
    }
    return NULL;
}


extern "C" MP4Duration MP4GetTrackDuration(
    MP4FileHandle hFile, MP4TrackId trackId)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->GetTrackDuration(trackId);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return MP4_INVALID_DURATION;
}

extern "C" u_int32_t MP4GetTrackTimeScale(
    MP4FileHandle hFile, MP4TrackId trackId)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->GetTrackTimeScale(trackId);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return 0;
}

extern "C" bool MP4SetTrackTimeScale(
    MP4FileHandle hFile, MP4TrackId trackId, u_int32_t value)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            ((MP4File*)hFile)->SetTrackTimeScale(trackId, value);
            return true;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return false;
}

extern "C" u_int8_t MP4GetTrackAudioMpeg4Type(
    MP4FileHandle hFile, MP4TrackId trackId)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->GetTrackAudioMpeg4Type(trackId);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return MP4_MPEG4_INVALID_AUDIO_TYPE;
}



// Replacement to MP4GetTrackVideoType and MP4GetTrackAudioType
// Basically does the same thing but with a more self-explanatory name
extern "C" u_int8_t MP4GetTrackEsdsObjectTypeId(
     MP4FileHandle hFile, MP4TrackId trackId)
{
  if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
    __try {
      
      return ((MP4File*)hFile)->GetTrackEsdsObjectTypeId(trackId);
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
//      PRINT_ERROR(e);
//      delete e;
    }
  }
  return MP4_INVALID_AUDIO_TYPE;
}

extern "C" MP4Duration MP4GetTrackFixedSampleDuration(
    MP4FileHandle hFile, MP4TrackId trackId)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->GetTrackFixedSampleDuration(trackId);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return MP4_INVALID_DURATION;
}

extern "C" u_int32_t MP4GetTrackBitRate(
    MP4FileHandle hFile, MP4TrackId trackId)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
      MP4File *pFile = (MP4File *)hFile;
        __try {
          return pFile->GetTrackIntegerProperty(trackId,
                "mdia.minf.stbl.stsd.*.esds.decConfigDescr.avgBitrate");
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
        // if we're here, we can't get the bitrate from above - 
        // lets calculate it
        __try {
          MP4Duration trackDur;
          trackDur = MP4GetTrackDuration(hFile, trackId);
          uint64_t msDuration = 
            pFile->ConvertFromTrackDuration(trackId, trackDur, 
                            MP4_MSECS_TIME_SCALE);
          if (msDuration == 0) return 0;

          MP4Track *pTrack = pFile->GetTrack(trackId);
          uint64_t bytes = pTrack->GetTotalOfSampleSizes();
          bytes *= TO_U64(8 * 1000);
          bytes /= msDuration;
          return (uint32_t)bytes;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
        
    }
    return 0;
}

extern "C" bool MP4GetTrackESConfiguration(
    MP4FileHandle hFile, MP4TrackId trackId, 
    u_int8_t** ppConfig, u_int32_t* pConfigSize)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            ((MP4File*)hFile)->GetTrackESConfiguration(
                trackId, ppConfig, pConfigSize);
            return true;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    *ppConfig = NULL;
    *pConfigSize = 0;
    return false;
}
extern "C" bool MP4GetTrackVideoMetadata(
    MP4FileHandle hFile, MP4TrackId trackId, 
    u_int8_t** ppConfig, u_int32_t* pConfigSize)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            ((MP4File*)hFile)->GetTrackVideoMetadata(
                trackId, ppConfig, pConfigSize);
            return true;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    *ppConfig = NULL;
    *pConfigSize = 0;
    return false;
}

extern "C" bool MP4SetTrackESConfiguration(
    MP4FileHandle hFile, MP4TrackId trackId, 
    const u_int8_t* pConfig, u_int32_t configSize)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            ((MP4File*)hFile)->SetTrackESConfiguration(
                trackId, pConfig, configSize);
            return true;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return false;
}

extern "C" bool MP4GetTrackH264ProfileLevel (MP4FileHandle hFile, 
                         MP4TrackId trackId,
                         uint8_t *pProfile,
                         uint8_t *pLevel)
{
  if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
    __try {
      ((MP4File*)hFile)->GetTrackH264ProfileLevel(trackId, pProfile, pLevel);
      return true;
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
//      PRINT_ERROR(e);
//      delete e;
    }
  }
  return false;
}
extern "C" bool MP4GetTrackH264SeqPictHeaders (MP4FileHandle hFile, 
                           MP4TrackId trackId,
                           uint8_t ***pSeqHeader,
                           uint32_t **pSeqHeaderSize,
                           uint8_t ***pPictHeader,
                           uint32_t **pPictHeaderSize)
{
  if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
    __try {
      ((MP4File*)hFile)->GetTrackH264SeqPictHeaders(trackId, 
                            pSeqHeader,
                            pSeqHeaderSize,
                            pPictHeader,
                            pPictHeaderSize);
      return true;
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
//      PRINT_ERROR(e);
//      delete e;
    }
  }
  return false;
}
extern "C" bool MP4GetTrackH264LengthSize (MP4FileHandle hFile, 
                       MP4TrackId trackId,
                       uint32_t *pLength)
{
  if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
    __try {
      ((MP4File*)hFile)->GetTrackH264LengthSize(trackId, 
                        pLength);
      return true;
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
//      PRINT_ERROR(e);
//      delete e;
    }
  }
  return false;
}
  
extern "C" MP4SampleId MP4GetTrackNumberOfSamples(
    MP4FileHandle hFile, MP4TrackId trackId)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->GetTrackNumberOfSamples(trackId);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return 0;
}

extern "C" u_int16_t MP4GetTrackVideoWidth(
    MP4FileHandle hFile, MP4TrackId trackId)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
               return ((MP4File*)hFile)->GetTrackIntegerProperty(trackId,
                "mdia.minf.stbl.stsd.*.width");
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return 0;
}

extern "C" u_int16_t MP4GetTrackVideoHeight(
    MP4FileHandle hFile, MP4TrackId trackId)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->GetTrackIntegerProperty(trackId,
                "mdia.minf.stbl.stsd.*.height");
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return 0;
}

extern "C" double MP4GetTrackVideoFrameRate(
    MP4FileHandle hFile, MP4TrackId trackId)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->GetTrackVideoFrameRate(trackId);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return 0.0;
}

extern "C" int MP4GetTrackAudioChannels (MP4FileHandle hFile,
                          MP4TrackId trackId)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->GetTrackAudioChannels(trackId);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return -1;
}

// returns true if the track is a media track encrypted according to ismacryp
extern "C" bool MP4IsIsmaCrypMediaTrack(
    MP4FileHandle hFile, MP4TrackId trackId)
{
  bool retval = false;
  uint32_t verb = MP4GetVerbosity(hFile);
  MP4SetVerbosity(hFile, verb & ~(MP4_DETAILS_ERROR));

        if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
               __try {
         retval = ((MP4File*)hFile)->IsIsmaCrypMediaTrack(trackId); 
           }
               __except (EXCEPTION_EXECUTE_HANDLER) {
//                       PRINT_ERROR(e);
//                       delete e;
               }
        }
    MP4SetVerbosity(hFile, verb);
        return retval;
}


/* generic track properties */

extern "C" bool MP4HaveTrackAtom (MP4FileHandle hFile, 
                  MP4TrackId trackId, 
                  const char *atomName)
{
  if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
    __try {
      return ((MP4File*)hFile)->FindTrackAtom(trackId, atomName) != NULL;
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
//      PRINT_ERROR(e);
//      delete e;
    }
  }
  return false;
}
                  
extern "C" bool MP4GetTrackIntegerProperty (
    MP4FileHandle hFile, MP4TrackId trackId, 
    const char* propName,
    u_int64_t *retvalue)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            *retvalue = ((MP4File*)hFile)->GetTrackIntegerProperty(trackId, 
                propName);
            return true;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return false;
}

extern "C" bool MP4GetTrackFloatProperty(
    MP4FileHandle hFile, MP4TrackId trackId, 
    const char* propName,
    float *retvalue)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            *retvalue = ((MP4File*)hFile)->GetTrackFloatProperty(trackId, propName);
            return true;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return false;
}

extern "C" bool MP4GetTrackStringProperty(
    MP4FileHandle hFile, MP4TrackId trackId, 
    const char* propName,
    const char **retvalue)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            *retvalue = ((MP4File*)hFile)->GetTrackStringProperty(trackId, propName);
            return true;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return false;
}

extern "C" bool MP4GetTrackBytesProperty(
    MP4FileHandle hFile, MP4TrackId trackId, const char* propName, 
    u_int8_t** ppValue, u_int32_t* pValueSize)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            ((MP4File*)hFile)->GetTrackBytesProperty(
                trackId, propName, ppValue, pValueSize);
            return true;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    *ppValue = NULL;
    *pValueSize = 0;
    return false;
}