mp4.cpp

6410BSP1

//            PRINT_ERROR(e);
//            delete e;
        }
    }
}

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

extern "C" MP4TrackId MP4CloneTrack(
    MP4FileHandle srcFile, 
    MP4TrackId srcTrackId,
    MP4FileHandle dstFile,
    MP4TrackId dstHintTrackReferenceTrack)
{
    MP4TrackId dstTrackId = MP4_INVALID_TRACK_ID;

    if (dstFile == NULL) {
        dstFile = srcFile;
    }

    const char* trackType = 
        MP4GetTrackType(srcFile, srcTrackId);

    if (!trackType) {
        return dstTrackId;
    }

    if (MP4_IS_VIDEO_TRACK_TYPE(trackType)) {
                MP4SetVideoProfileLevel(dstFile, 
                                        MP4GetVideoProfileLevel(srcFile));
        dstTrackId = MP4AddVideoTrack(
            dstFile,
            MP4GetTrackTimeScale(srcFile, srcTrackId),
            MP4GetTrackFixedSampleDuration(srcFile, srcTrackId),
            MP4GetTrackVideoWidth(srcFile, srcTrackId),
            MP4GetTrackVideoHeight(srcFile, srcTrackId),
            MP4GetTrackEsdsObjectTypeId(srcFile, srcTrackId));

    } else if (MP4_IS_AUDIO_TRACK_TYPE(trackType)) {
                MP4SetAudioProfileLevel(dstFile, 
                                        MP4GetAudioProfileLevel(srcFile));
        dstTrackId = MP4AddAudioTrack(
            dstFile,
            MP4GetTrackTimeScale(srcFile, srcTrackId),
            MP4GetTrackFixedSampleDuration(srcFile, srcTrackId),
            MP4GetTrackEsdsObjectTypeId(srcFile, srcTrackId));

    } else if (MP4_IS_OD_TRACK_TYPE(trackType)) {
        dstTrackId = MP4AddODTrack(dstFile);

    } else if (MP4_IS_SCENE_TRACK_TYPE(trackType)) {
        dstTrackId = MP4AddSceneTrack(dstFile);

    } else if (MP4_IS_HINT_TRACK_TYPE(trackType)) {
      if (dstHintTrackReferenceTrack == MP4_INVALID_TRACK_ID) {
        dstTrackId = MP4_INVALID_TRACK_ID;
      } else {
        dstTrackId = MP4AddHintTrack(
            dstFile,
            dstHintTrackReferenceTrack);
      }

    } else if (MP4_IS_SYSTEMS_TRACK_TYPE(trackType)) {
        dstTrackId = MP4AddSystemsTrack(dstFile, trackType);

    } else {
        dstTrackId = MP4AddTrack(dstFile, trackType);
    }

    if (dstTrackId == MP4_INVALID_TRACK_ID) {
        return dstTrackId;
    }

    MP4SetTrackTimeScale(
        dstFile, 
        dstTrackId,
        MP4GetTrackTimeScale(srcFile, srcTrackId));

    if (MP4_IS_AUDIO_TRACK_TYPE(trackType) 
        || MP4_IS_VIDEO_TRACK_TYPE(trackType)) {
    // copy track ES configuration
    u_int8_t* pConfig = NULL;
    u_int32_t configSize = 0;

    MP4GetTrackESConfiguration(
        srcFile, 
        srcTrackId,
        &pConfig,
        &configSize);

    MP4SetTrackESConfiguration(
        dstFile, 
        dstTrackId,
        pConfig,
        configSize);

        free(pConfig);
    }

    if (MP4_IS_HINT_TRACK_TYPE(trackType)) {
        // probably not exactly what is wanted
        // but caller can adjust later to fit their desires

        char* payloadName = NULL;
        char *encodingParms = NULL;
        u_int8_t payloadNumber;
        u_int16_t maxPayloadSize;

        MP4GetHintTrackRtpPayload(
            srcFile,
            srcTrackId,
            &payloadName,
            &payloadNumber,
            &maxPayloadSize,
            &encodingParms);

        MP4SetHintTrackRtpPayload(
            dstFile,
            dstTrackId,
            payloadName,
            &payloadNumber,
            maxPayloadSize,
            encodingParms);
#if 0
        MP4SetHintTrackSdp(
            dstFile,
            dstTrackId,
            MP4GetHintTrackSdp(srcFile, srcTrackId));
#endif
    }

    return dstTrackId;
}

// Given a track, make an encrypted clone of it in the dest. file
extern "C" MP4TrackId MP4EncAndCloneTrack(MP4FileHandle srcFile,
                                          MP4TrackId srcTrackId,
                                          mp4v2_ismacrypParams *icPp,
                      MP4FileHandle dstFile,
                      MP4TrackId dstHintTrackReferenceTrack
                                          )
{
  MP4TrackId dstTrackId = MP4_INVALID_TRACK_ID;

  if (dstFile == NULL) {
    dstFile = srcFile;
  }

  const char* trackType = 
    MP4GetTrackType(srcFile, srcTrackId);

  if (!trackType) {
    return dstTrackId;
  }

  if (MP4_IS_VIDEO_TRACK_TYPE(trackType)) {
    MP4SetVideoProfileLevel(dstFile, MP4GetVideoProfileLevel(srcFile));
    dstTrackId = MP4AddEncVideoTrack(dstFile,
                     MP4GetTrackTimeScale(srcFile, srcTrackId),
                     MP4GetTrackFixedSampleDuration(srcFile, 
                                    srcTrackId),
                     MP4GetTrackVideoWidth(srcFile, srcTrackId),
                     MP4GetTrackVideoHeight(srcFile, srcTrackId),
                                     icPp,
                     MP4GetTrackEsdsObjectTypeId(srcFile, 
                                 srcTrackId)
                                     );

  } else if (MP4_IS_AUDIO_TRACK_TYPE(trackType)) {
    MP4SetAudioProfileLevel(dstFile, MP4GetAudioProfileLevel(srcFile));
    dstTrackId = MP4AddEncAudioTrack(dstFile,
                     MP4GetTrackTimeScale(srcFile, srcTrackId),
                     MP4GetTrackFixedSampleDuration(srcFile, 
                                    srcTrackId),
                                     icPp,
                     MP4GetTrackEsdsObjectTypeId(srcFile, 
                                 srcTrackId)
                                     );

  } else if (MP4_IS_OD_TRACK_TYPE(trackType)) {
    dstTrackId = MP4AddODTrack(dstFile);

  } else if (MP4_IS_SCENE_TRACK_TYPE(trackType)) {
    dstTrackId = MP4AddSceneTrack(dstFile);
    
  } else if (MP4_IS_HINT_TRACK_TYPE(trackType)) {
     if (dstHintTrackReferenceTrack == MP4_INVALID_TRACK_ID) {
         dstTrackId = MP4_INVALID_TRACK_ID;
    } else {     
         dstTrackId = MP4AddHintTrack(dstFile,
                 MP4GetHintTrackReferenceTrackId(srcFile, 
                                 srcTrackId));
    }
  } else if (MP4_IS_SYSTEMS_TRACK_TYPE(trackType)) {
    dstTrackId = MP4AddSystemsTrack(dstFile, trackType);
    
  } else {
    dstTrackId = MP4AddTrack(dstFile, trackType);
  }

  if (dstTrackId == MP4_INVALID_TRACK_ID) {
    return dstTrackId;
  }

  MP4SetTrackTimeScale(dstFile, 
               dstTrackId,
               MP4GetTrackTimeScale(srcFile, srcTrackId));

  if (MP4_IS_AUDIO_TRACK_TYPE(trackType) 
   || MP4_IS_VIDEO_TRACK_TYPE(trackType)) {
    // copy track ES configuration
    u_int8_t* pConfig = NULL;
    u_int32_t configSize = 0;
    if (MP4GetTrackESConfiguration(srcFile, srcTrackId,
                   &pConfig, &configSize)) {
    
      if (pConfig != NULL) {
    MP4SetTrackESConfiguration(dstFile, dstTrackId,
                   pConfig, configSize);
      }
    }
    if (pConfig != NULL)
      free(pConfig);
    }

  // Bill's change to MP4CloneTrack
  if (MP4_IS_HINT_TRACK_TYPE(trackType)) {
    // probably not exactly what is wanted
    // but caller can adjust later to fit their desires

    char* payloadName = NULL;
    char *encodingParms = NULL;
    u_int8_t payloadNumber;
    u_int16_t maxPayloadSize;

    MP4GetHintTrackRtpPayload(
                               srcFile,
                   srcTrackId,
                   &payloadName,
                   &payloadNumber,
                   &maxPayloadSize,
                   &encodingParms);

       MP4SetHintTrackRtpPayload(
                         dstFile,
                     dstTrackId,
                     payloadName,
                     &payloadNumber,
                     maxPayloadSize,
                     encodingParms);    
#if 0
      MP4SetHintTrackSdp(
                         dstFile,
                         dstTrackId,
                         MP4GetHintTrackSdp(srcFile, srcTrackId));
#endif
   }

  return dstTrackId;
}
extern "C" MP4TrackId MP4CopyTrack(MP4FileHandle srcFile, 
                   MP4TrackId srcTrackId,
                   MP4FileHandle dstFile, 
                   bool applyEdits,
                   MP4TrackId dstHintTrackReferenceTrack)
{
  bool copySamples = true;    // LATER allow false => reference samples

  MP4TrackId dstTrackId =
    MP4CloneTrack(srcFile, srcTrackId, dstFile, dstHintTrackReferenceTrack);

  if (dstTrackId == MP4_INVALID_TRACK_ID) {
    return dstTrackId;
  }

  bool viaEdits =
    applyEdits && MP4GetTrackNumberOfEdits(srcFile, srcTrackId);

  MP4SampleId sampleId = 0;
  MP4SampleId numSamples = 
    MP4GetTrackNumberOfSamples(srcFile, srcTrackId);

  MP4Timestamp when = 0;
  MP4Duration editsDuration = 
    MP4GetTrackEditTotalDuration(srcFile, srcTrackId);

  while (true) {
    MP4Duration sampleDuration = MP4_INVALID_DURATION;

    if (viaEdits) {
      sampleId = MP4GetSampleIdFromEditTime(
                        srcFile,
                        srcTrackId,
                        when,
                        NULL,
                        &sampleDuration);

      // in theory, this shouldn't happen
      if (sampleId == MP4_INVALID_SAMPLE_ID) {
    MP4DeleteTrack(dstFile, dstTrackId);
    return MP4_INVALID_TRACK_ID;
      }

      when += sampleDuration;
      
      if (when >= editsDuration) {
    break;
      }
    } else {
      sampleId++;
      if (sampleId > numSamples) {
    break;
      }
    }

    bool rc = false;
    
    if (copySamples) {
      rc = MP4CopySample(
             srcFile,
             srcTrackId,
             sampleId,
             dstFile,
             dstTrackId,
             sampleDuration);

    } else {
      rc = MP4ReferenceSample(
                  srcFile,
                  srcTrackId,
                  sampleId,
                  dstFile,
                  dstTrackId,
                  sampleDuration);
    }

    if (!rc) {
      MP4DeleteTrack(dstFile, dstTrackId);
      return MP4_INVALID_TRACK_ID;
    }
  }

  return dstTrackId;
}

// Given a source track in a source file, make an encrypted copy of 
// the track in the destination file, including sample encryption
extern "C" MP4TrackId MP4EncAndCopyTrack(MP4FileHandle srcFile, 
                     MP4TrackId srcTrackId,
                                         mp4v2_ismacrypParams *icPp,
                                         encryptFunc_t encfcnp,
                                         u_int32_t encfcnparam1,
                     MP4FileHandle dstFile,
                     bool applyEdits,
                     MP4TrackId dstHintTrackReferenceTrack
                                         )
{
  bool copySamples = true;    // LATER allow false => reference samples

  MP4TrackId dstTrackId =
     MP4EncAndCloneTrack(srcFile, srcTrackId,
                        icPp,
                        dstFile, dstHintTrackReferenceTrack);
  
  if (dstTrackId == MP4_INVALID_TRACK_ID) {
    return dstTrackId;
  }

  bool viaEdits =
    applyEdits && MP4GetTrackNumberOfEdits(srcFile, srcTrackId);

  MP4SampleId sampleId = 0;
  MP4SampleId numSamples = 
    MP4GetTrackNumberOfSamples(srcFile, srcTrackId);

  MP4Timestamp when = 0;
  MP4Duration editsDuration = 
    MP4GetTrackEditTotalDuration(srcFile, srcTrackId);

  while (true) {
    MP4Duration sampleDuration = MP4_INVALID_DURATION;

    if (viaEdits) {
      sampleId = MP4GetSampleIdFromEditTime(srcFile,
                        srcTrackId,
                        when,
                        NULL,
                        &sampleDuration);

      // in theory, this shouldn't happen
      if (sampleId == MP4_INVALID_SAMPLE_ID) {
    MP4DeleteTrack(dstFile, dstTrackId);
    return MP4_INVALID_TRACK_ID;
      }

      when += sampleDuration;

      if (when >= editsDuration) {
    break;
      }
    } else {
      sampleId++;
      if (sampleId > numSamples) {
    break;
      }
    }

    bool rc = false;

    if (copySamples) {
      // encrypt and copy
      rc = MP4EncAndCopySample(srcFile,
             srcTrackId,
             sampleId,
             encfcnp,
                         encfcnparam1,
             dstFile,
             dstTrackId,
             sampleDuration);

    } else {
      // not sure what these are - encrypt?
      rc = MP4ReferenceSample(srcFile,
                  srcTrackId,
                  sampleId,
                  dstFile,
                  dstTrackId,
                  sampleDuration);
    }

    if (!rc) {
      MP4DeleteTrack(dstFile, dstTrackId);
      return MP4_INVALID_TRACK_ID;
    }
  }

  return dstTrackId;
}

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

extern "C" u_int32_t MP4GetNumberOfTracks(
    MP4FileHandle hFile, 
    const char* type,
    u_int8_t subType)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->GetNumberOfTracks(type, subType);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return 0;
}

extern "C" MP4TrackId MP4FindTrackId(
    MP4FileHandle hFile, 
    u_int16_t index, 
    const char* type,
    u_int8_t subType)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->FindTrackId(index, type, subType);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }