mp4.cpp

来自「6410BSP1」· C++ 代码 · 共 2,497 行 · 第 1/5 页

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

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

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

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

/* sample operations */

extern "C" bool MP4ReadSample(
    /* input parameters */
    MP4FileHandle hFile,
    MP4TrackId trackId, 
    MP4SampleId sampleId,
    /* output parameters */
    u_int8_t** ppBytes, 
    u_int32_t* pNumBytes, 
    MP4Timestamp* pStartTime, 
    MP4Duration* pDuration,
    MP4Duration* pRenderingOffset, 
    bool* pIsSyncSample)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            ((MP4File*)hFile)->ReadSample(
                trackId, 
                sampleId, 
                ppBytes, 
                pNumBytes, 
                pStartTime, 
                pDuration, 
                pRenderingOffset, 
                pIsSyncSample);
            return true;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    *pNumBytes = 0;
    return false;
}

extern "C" bool MP4ReadSampleFromTime(
    /* input parameters */
    MP4FileHandle hFile,
    MP4TrackId trackId, 
    MP4Timestamp when,
    /* output parameters */
    u_int8_t** ppBytes, 
    u_int32_t* pNumBytes, 
    MP4Timestamp* pStartTime, 
    MP4Duration* pDuration,
    MP4Duration* pRenderingOffset, 
    bool* pIsSyncSample)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            MP4SampleId sampleId = 
                ((MP4File*)hFile)->GetSampleIdFromTime(
                    trackId, when, false);

            ((MP4File*)hFile)->ReadSample(
                trackId, 
                sampleId, 
                ppBytes, 
                pNumBytes, 
                pStartTime, 
                pDuration, 
                pRenderingOffset, 
                pIsSyncSample);

            return true;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    *pNumBytes = 0;
    return false;
}

extern "C" bool MP4WriteSample(
    MP4FileHandle hFile,
    MP4TrackId trackId,
    const u_int8_t* pBytes, 
    u_int32_t numBytes,
    MP4Duration duration,
    MP4Duration renderingOffset, 
    bool isSyncSample)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            ((MP4File*)hFile)->WriteSample(
                trackId, 
                pBytes, 
                numBytes, 
                duration, 
                renderingOffset, 
                isSyncSample);
            return true;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return false;
}

extern "C" bool MP4CopySample(
    MP4FileHandle srcFile,
    MP4TrackId srcTrackId, 
    MP4SampleId srcSampleId,
    MP4FileHandle dstFile,
    MP4TrackId dstTrackId,
    MP4Duration dstSampleDuration)
{
    bool rc;
    u_int8_t* pBytes = NULL; 
    u_int32_t numBytes = 0;
    MP4Duration sampleDuration;
    MP4Duration renderingOffset;
    bool isSyncSample;

    // Note: we leave it up to the caller to ensure that the
    // source and destination tracks are compatible.
    // i.e. copying audio samples into a video track 
    // is unlikely to do anything useful

    rc = MP4ReadSample(
        srcFile,
        srcTrackId,
        srcSampleId,
        &pBytes,
        &numBytes,
        NULL,
        &sampleDuration,
        &renderingOffset,
        &isSyncSample);

    if (!rc) {
        return false;
    }

    if (dstFile == MP4_INVALID_FILE_HANDLE) {
        dstFile = srcFile;
    }
    if (dstTrackId == MP4_INVALID_TRACK_ID) {
        dstTrackId = srcTrackId;
    }
    if (dstSampleDuration != MP4_INVALID_DURATION) {
        sampleDuration = dstSampleDuration;
    }

    rc = MP4WriteSample(
        dstFile,
        dstTrackId,
        pBytes,
        numBytes,
        sampleDuration,
        renderingOffset,        
        isSyncSample);

    free(pBytes);

    return rc;
}

extern "C" bool MP4EncAndCopySample(
    MP4FileHandle srcFile,
    MP4TrackId srcTrackId, 
    MP4SampleId srcSampleId,
        encryptFunc_t encfcnp,
        u_int32_t encfcnparam1,
    MP4FileHandle dstFile,
    MP4TrackId dstTrackId,
    MP4Duration dstSampleDuration)
{
    bool rc;
    u_int8_t* pBytes = NULL; 
    u_int32_t numBytes = 0;
    u_int8_t* encSampleData = NULL;
    u_int32_t encSampleLength = 0;
    MP4Duration sampleDuration;
    MP4Duration renderingOffset;
    bool isSyncSample;

    // Note: we leave it up to the caller to ensure that the
    // source and destination tracks are compatible.
    // i.e. copying audio samples into a video track 
    // is unlikely to do anything useful

    rc = MP4ReadSample(
        srcFile,
        srcTrackId,
        srcSampleId,
        &pBytes,
        &numBytes,
        NULL,
        &sampleDuration,
        &renderingOffset,
        &isSyncSample);

    if (!rc) {
        return false;
    }

    if (dstFile == MP4_INVALID_FILE_HANDLE) {
        dstFile = srcFile;
    }
    if (dstTrackId == MP4_INVALID_TRACK_ID) {
        dstTrackId = srcTrackId;
    }
    if (dstSampleDuration != MP4_INVALID_DURATION) {
        sampleDuration = dstSampleDuration;
    }

        //if (ismacrypEncryptSampleAddHeader(ismaCryptSId, numBytes, pBytes,
        //                        &encSampleLength, &encSampleData) != 0) {
        if (encfcnp(encfcnparam1, numBytes, pBytes,
                &encSampleLength, &encSampleData) != 0) {
        fprintf(stderr,
            "Can't encrypt the sample and add its header %u\n",
            srcSampleId);
    }    

    rc = MP4WriteSample(
        dstFile,
                dstTrackId,
                encSampleData,
                encSampleLength,
                sampleDuration,
                renderingOffset,
                isSyncSample);
        
    free(pBytes);

    if (encSampleData != NULL) {
              free(encSampleData);
        }
    
    return rc;
}

extern "C" bool MP4ReferenceSample(
    MP4FileHandle srcFile,
    MP4TrackId srcTrackId, 
    MP4SampleId srcSampleId,
    MP4FileHandle dstFile,
    MP4TrackId dstTrackId,
    MP4Duration dstSampleDuration)
{
    // LATER Not yet implemented
    return false;
}

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

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

extern "C" MP4SampleId MP4GetSampleIdFromTime(
    MP4FileHandle hFile,
    MP4TrackId trackId, 
    MP4Timestamp when, 
    bool wantSyncSample)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->GetSampleIdFromTime(
                trackId, when, wantSyncSample);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return MP4_INVALID_SAMPLE_ID;
}

extern "C" MP4Timestamp MP4GetSampleTime(
    MP4FileHandle hFile,
    MP4TrackId trackId, 
    MP4SampleId sampleId)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->GetSampleTime(
                trackId, sampleId);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return MP4_INVALID_TIMESTAMP;
}

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

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

extern "C" bool MP4SetSampleRenderingOffset(
    MP4FileHandle hFile,
    MP4TrackId trackId, 
    MP4SampleId sampleId,
    MP4Duration renderingOffset)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            ((MP4File*)hFile)->SetSampleRenderingOffset(
                trackId, sampleId, renderingOffset);
            return true;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return false;
}

extern "C" int8_t MP4GetSampleSync(
    MP4FileHandle hFile,
    MP4TrackId trackId, 
    MP4SampleId sampleId)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->GetSampleSync(
                trackId, sampleId);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return -1;
}


extern "C" u_int64_t MP4ConvertFromMovieDuration(
    MP4FileHandle hFile,
    MP4Duration duration,
    u_int32_t timeScale)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->ConvertFromMovieDuration(
                duration, timeScale);
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
//            PRINT_ERROR(e);
//            delete e;
        }
    }
    return (u_int64_t)MP4_INVALID_DURATION;
}

extern "C" u_int64_t MP4ConvertFromTrackTimestamp(
    MP4FileHandle hFile,
    MP4TrackId trackId, 
    MP4Timestamp timeStamp,
    u_int32_t timeScale)
{
    if (MP4_IS_VALID_FILE_HANDLE(hFile)) {
        __try {
            return ((MP4File*)hFile)->ConvertFromTrackTimestamp(
                trackId, ti