mp4.cpp

6410BSP1

            ((MP4File*)hFile)->GetBytesProperty(propName, ppValue, pValueSize);
            return true;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    *ppValue = NULL;
    *pValueSize = 0;
    return false;
}

extern "C" bool MP4SetIntegerProperty(
    MP4FileHandle hFile, const char* propName, int64_t value)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            ((MP4File*)hFile)->SetIntegerProperty(propName, value);
            return true;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return false;
}

extern "C" bool MP4SetFloatProperty(
    MP4FileHandle hFile, const char* propName, float value)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            ((MP4File*)hFile)->SetFloatProperty(propName, value);
            return true;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return false;
}

extern "C" bool MP4SetStringProperty(
    MP4FileHandle hFile, const char* propName, const char* value)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            ((MP4File*)hFile)->SetStringProperty(propName, value);
            return true;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return false;
}

extern "C" bool MP4SetBytesProperty(
    MP4FileHandle hFile, const char* propName, 
    const u_int8_t* pValue, u_int32_t valueSize)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            ((MP4File*)hFile)->SetBytesProperty(propName, pValue, valueSize);
            return true;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return false;
}

/* track operations */

extern "C" MP4TrackId MP4AddTrack(
    MP4FileHandle hFile, const char* type)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->AddSystemsTrack(type);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return MP4_INVALID_TRACK_ID;
}

extern "C" MP4TrackId MP4AddSystemsTrack(
    MP4FileHandle hFile, const char* type)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->AddSystemsTrack(type);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return MP4_INVALID_TRACK_ID;
}

extern "C" MP4TrackId MP4AddODTrack(MP4FileHandle hFile)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->AddODTrack();
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return MP4_INVALID_TRACK_ID;
}

extern "C" MP4TrackId MP4AddSceneTrack(MP4FileHandle hFile)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->AddSceneTrack();
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return MP4_INVALID_TRACK_ID;
}

extern "C" MP4TrackId MP4AddAudioTrack(
    MP4FileHandle hFile, 
    u_int32_t timeScale, 
    MP4Duration sampleDuration, 
    u_int8_t audioType)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->
                AddAudioTrack(timeScale, sampleDuration, audioType);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return MP4_INVALID_TRACK_ID;
}

extern "C" MP4TrackId MP4AddEncAudioTrack(MP4FileHandle hFile, 
                      u_int32_t timeScale, 
                      MP4Duration sampleDuration,
                                          mp4v2_ismacrypParams *icPp,
                      u_int8_t audioType)
{
  if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
    __try {
      if (icPp == NULL) {
    return ((MP4File*)hFile)->
      AddEncAudioTrack(timeScale, sampleDuration, audioType,
               0, 0, 
               0, 0, 
               false, NULL, false);
      } else {
    return ((MP4File*)hFile)->
      AddEncAudioTrack(timeScale, sampleDuration, audioType,
               icPp->scheme_type, icPp->scheme_version, 
               icPp->key_ind_len, icPp->iv_len, 
               icPp->selective_enc, icPp->kms_uri, true);
      }
    } __except (EXCEPTION_EXECUTE_HANDLER) {
//      PRINT_ERROR(e);
//      delete e;
    }
  }
  return MP4_INVALID_TRACK_ID;
}
extern "C" MP4TrackId MP4AddAmrAudioTrack(
        MP4FileHandle hFile,
        u_int32_t timeScale,
        u_int16_t modeSet,
        u_int8_t modeChangePeriod,
        u_int8_t framesPerSample,
        bool isAmrWB)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->
                AddAmrAudioTrack(timeScale, modeSet, modeChangePeriod, framesPerSample, isAmrWB);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return MP4_INVALID_TRACK_ID;
}

extern "C" void MP4SetAmrVendor(
        MP4FileHandle hFile,
        MP4TrackId trackId,
        u_int32_t vendor)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            ((MP4File*)hFile)->
                SetAmrVendor(trackId, vendor);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
}

extern "C" void MP4SetAmrDecoderVersion(
        MP4FileHandle hFile,
        MP4TrackId trackId,
        u_int8_t decoderVersion)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            ((MP4File*)hFile)->
                SetAmrDecoderVersion(trackId, decoderVersion);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
}

extern "C" void MP4SetAmrModeSet(
        MP4FileHandle hFile,
        MP4TrackId trackId,
        u_int16_t modeSet)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            ((MP4File*)hFile)->
                SetAmrModeSet(trackId, modeSet);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
}

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

extern "C" MP4TrackId MP4AddHrefTrack (MP4FileHandle hFile,
                       uint32_t timeScale,
                       MP4Duration sampleDuration)
{
  if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
    __try {
      MP4File *pFile = (MP4File *)hFile;

      return pFile->AddHrefTrack(timeScale, 
                 sampleDuration);
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
//      PRINT_ERROR(e);
//      delete e;
    }
  }
  return MP4_INVALID_TRACK_ID;
}

extern "C" MP4TrackId MP4AddVideoTrack(
    MP4FileHandle hFile, 
    u_int32_t timeScale, 
    MP4Duration sampleDuration,
    u_int16_t width, 
    u_int16_t height, 
    u_int8_t videoType)
{
  if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
    __try {
      MP4File *pFile = (MP4File *)hFile;

      return pFile->AddMP4VideoTrack(timeScale, 
                     sampleDuration, 
                     width, 
                     height, 
                     videoType);
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
//      PRINT_ERROR(e);
//      delete e;
    }
  }
  return MP4_INVALID_TRACK_ID;
}

extern "C" MP4TrackId MP4AddEncVideoTrack(MP4FileHandle hFile, 
                      u_int32_t timeScale, 
                      MP4Duration sampleDuration,
                      u_int16_t width, 
                      u_int16_t height, 
                                          mp4v2_ismacrypParams *icPp,
                      u_int8_t videoType )
{
  if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
    __try {
      if (icPp == NULL) {
    return ((MP4File*)hFile)->AddEncVideoTrack(timeScale, sampleDuration, 
                           width, height, videoType,
                           0, 0,
                           0, 0,
                           false, NULL,
                           false
                           );
      } else {
    return ((MP4File*)hFile)->AddEncVideoTrack(timeScale, sampleDuration, 
                           width, height, videoType,
                           icPp->scheme_type, icPp->scheme_version, 
                           icPp->key_ind_len, icPp->iv_len, 
                           icPp->selective_enc, icPp->kms_uri,
                           true
                           );
      }
    } __except (EXCEPTION_EXECUTE_HANDLER) {
//      PRINT_ERROR(e);
//      delete e;
    }
  }
  return MP4_INVALID_TRACK_ID;
}

extern "C" MP4TrackId MP4AddH264VideoTrack(
    MP4FileHandle hFile, 
    u_int32_t timeScale, 
    MP4Duration sampleDuration,
    u_int16_t width, 
    u_int16_t height, 
    uint8_t AVCProfileIndication,
    uint8_t profile_compat,
    uint8_t AVCLevelIndication,
    uint8_t sampleLenFieldSizeMinusOne)
{
  if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
    __try {
      MP4File *pFile = (MP4File *)hFile;

      return pFile->AddH264VideoTrack(timeScale, 
                      sampleDuration, 
                      width, 
                      height, 
                      AVCProfileIndication,
                      profile_compat,
                      AVCLevelIndication,
                      sampleLenFieldSizeMinusOne);
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
//      PRINT_ERROR(e);
//      delete e;
    }
  }
  return MP4_INVALID_TRACK_ID;
}

extern "C" bool MP4AddH264SequenceParameterSet (MP4FileHandle hFile,
                        MP4TrackId trackId,
                        const uint8_t *pSequence,
                        uint16_t sequenceLen)
{
  if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
    __try {
      MP4File *pFile = (MP4File *)hFile;

      return pFile->AddH264SequenceParameterSet(trackId,
                        pSequence,
                        sequenceLen);
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
//      PRINT_ERROR(e);
//      delete e;
    }
  }
    return false;
}
extern "C" bool MP4AddH264PictureParameterSet (MP4FileHandle hFile,
                           MP4TrackId trackId,
                           const uint8_t *pPict,
                           uint16_t pictLen)
{
  if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
    __try {
      MP4File *pFile = (MP4File *)hFile;

      return pFile->AddH264PictureParameterSet(trackId,
                           pPict,
                           pictLen);
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
//      PRINT_ERROR(e);
//      delete e;
    }
  }
    return false;
}

extern "C" MP4TrackId MP4AddH263VideoTrack(
        MP4FileHandle hFile,
        u_int32_t timeScale,
        MP4Duration sampleDuration,
        u_int16_t width,
        u_int16_t height,
        u_int8_t h263Level,
        u_int8_t h263Profile,
        u_int32_t avgBitrate,
        u_int32_t maxBitrate)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->
                AddH263VideoTrack(timeScale, sampleDuration, width, height, h263Level, h263Profile, avgBitrate, maxBitrate);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    
    return MP4_INVALID_TRACK_ID;
}

extern "C" void MP4SetH263Vendor(
        MP4FileHandle hFile,
        MP4TrackId trackId,
        u_int32_t vendor)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            ((MP4File*)hFile)->
                SetH263Vendor(trackId, vendor);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
}

extern "C" void MP4SetH263DecoderVersion(
        MP4FileHandle hFile,
        MP4TrackId trackId,
        u_int8_t decoderVersion)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        
        __try {
            ((MP4File*)hFile)->
                SetH263DecoderVersion(trackId, decoderVersion);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
}

extern "C" void MP4SetH263Bitrates(
        MP4FileHandle hFile,
        MP4TrackId trackId,
        u_int32_t avgBitrate,
        u_int32_t maxBitrate)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {

        __try {
            ((MP4File*)hFile)->
                SetH263Bitrates(trackId, avgBitrate, maxBitrate);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {