atsc_core_streamer_isobmff.h

Go to the documentation of this file.

/*******************************************************************************
  * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
  *
  * This file is part of a DTVKit Software Component
  * You are permitted to copy, modify or distribute this file subject to the terms
  * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
  *
  * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
  * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
  *
  * If you or your organisation is not a member of DTVKit then you have access
  * to this source code outside of the terms of the licence agreement
  * and you are expected to delete this and any associated files immediately.
  * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
  *******************************************************************************/
 
#pragma once
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define MAX_TREX 4
 
#define MAX_TRAK 4
 
#define MAX_SEGMENT_SIZE 130
 
#define MAX_ES_SIZE_BIG 1024*1000 * 4
 
#define MAX_ES_SIZE_SMALL 1024*1000 * 1
 
typedef enum
{
    eHandlerTypeVideo = 0,      
    eHandlerTypeAudio = 1,      
    eHandlerTypeHint = 2,       
    eHandlerTypeCaption = 3,    
    eHandlerTypeUnknown = 4,    
} eHandlerType_t;
 
typedef enum
{
    eMp4BoxTypeTRAK = 0,    
    eMp4BoxTypeTRHD,        
    eMp4BoxTypeSTSD,        
    eMp4BoxTypeSTTS,        
    eMp4BoxTypeSTSC,        
    eMp4BoxTypeSTSZ,        
    eMp4BoxTypeSTCO,        
    eMp4BoxTypeCTTS,        
    eMp4BoxTypeMDAT,        
    eMp4BoxTypeFTYP,        
    eMp4BoxTypeMVHD,        
    eMp4BoxTypeTKHD,        
    eMp4BoxTypeMDHD,        
    eMp4BoxTypeVMHD,        
    eMp4BoxTypeSMHD,        
    eMp4BoxTypeHMHD,        
    eMp4BoxTypeNMHD,        
    eMp4BoxTypeHDLR,        
    eMp4BoxTypeMEHD,        
    eMp4BoxTypeTREP,        
    eMp4BoxTypeTREX,        
    eMp4BoxTypeMVEX,        
    eMp4BoxTypeSTBL,        
    eMp4BoxTypeMINF,        
    eMp4BoxTypeMDIA,        
    eMp4BoxTypeMOOV,        
    eMp4BoxTypeTFHD,        
    eMp4BoxTypeTFDT,        
    eMp4BoxTypeTRUN,        
    eMp4BoxTypeSIDX,        
    eMp4BoxTypeSTYP,        
    eMp4BoxTypeTRAF,        
    eMp4BoxTypeMOOF,        
    eMp4BoxTypeMFHD,        
    eMp4BoxTypeMMPU,        
    eMp4BoxTypeBTRT,        
    eMp4BoxTypeHINT,        
    eMp4BoxTypeDINF,        
    eMp4BoxTypeDREF,        
    eMp4BoxTypeMMTH,        
    eMp4BoxTypeTREF,        
    eMp4BoxTypePSSH,        
    eMp4BoxTypeSENC,        
    eMp4BoxTypeEND,         
}eMp4BoxType_t;
 
typedef struct FindHdlrResult_s{
    bool bIs;               
    int32_t iHdlrType;      
    int32_t iTrackId;       
    int32_t iSampleSize;    
}sFindHdlrResult_t;
 
namespace Isobmff
{
    typedef struct SampleEntry_s
    {
        uint8_t sBoxType[4];            
        int32_t iDataReferenceIndex;    
    }sSampleEntry_t;
 
    typedef struct HevcConfigurationRecord_s
    {
        uint8_t sCodecType[4];                      
        uint8_t cConfigurationVersion;              
        uint8_t cGeneralProfileSpace;               
        uint8_t cGeneralTierFlag;                   
        uint8_t cGeneralProfileIdc;                 
        uint32_t iGeneralProfileCompatibilityFlags; 
        uint64_t lGeneralConstraintIndicatorFlags;  
        uint8_t cGeneralLevelIdc;                   
        uint16_t iMinSpatialSegmentationIdc;        
        uint8_t cParallelismType;                   
        uint8_t cChromaFormat;                      
        uint8_t cBitDepthLumaMinus8;                
        uint8_t cBitDepthChromaMinus8;              
        uint32_t iAvgFrameRate;                     
        uint8_t cConstantFrameRate;                 
        uint8_t cNumTemporalLayers;                 
        uint8_t cTemporalIdNested;                  
        uint8_t cLengthSizeMinusOne;                
        uint8_t cNumOfArrays;                       
        uint8_t sArrayCompleteness[5];              
        uint8_t sNALUnitType[5];                    
        uint8_t sNumNalus[5];                       
        uint16_t sNalUnitLength[5][5];              
        uint8_t sNalUnit[5][5][1024];               
    }sHevcConfigurationRecord_t;
 
    typedef struct UnVideoProperty_s
    {
        sHevcConfigurationRecord_t stHEVCPROPERTY;  
    }sUnVideoProperty_t;
 
    typedef struct VideoSampleEntry_s
    {
        sSampleEntry_t stEntry;             
        uint16_t iWidth;                    
        uint16_t iHeight;                   
        uint32_t iHorResolution;            
        uint32_t iVerResolution;            
        uint8_t sCompressorname[32];        
        sUnVideoProperty_t stVIDEOPROPERTY; 
    }sVideoSampleEntry_t;
 
    typedef struct AudioSampleEntry_s
    {
        sSampleEntry_t stEntry;             
        uint16_t iChannelCount;             
        uint16_t iSampleSize;               
        uint32_t  iSampleRate;              
        int32_t iAudioObjectType;           
        int32_t iSamplingFrequencyIndex;    
        int32_t iChannelConfiguration;      
    }sAudioSampleEntry_t;
 
    typedef struct UnSampleEntry_s
    {
        sAudioSampleEntry_t stASAMPLEENTRY; 
        sVideoSampleEntry_t stVSAMPLENTRY;  
    }sUnSampleEntry_t;
 
    typedef struct MvhdH_s
    {
        int32_t iVersion;           
        int32_t iFlag;              
        uint64_t lCreationTime;     
        uint64_t lModificationTime; 
        uint32_t iTimescale;        
        uint64_t lDuration;         
        uint32_t iRate;             
        uint16_t iVolume;           
        uint16_t iReserved;         
        uint32_t sReserved2[2];     
        uint32_t sMatrix[9];        
        uint32_t sPreDefined[6];    
        uint32_t iNextTrackID;      
        uint8_t sMvhdData[1024];    
    }sMvhdH_t;
 
    typedef struct SttsH_s
    {
        uint8_t cVersion;               
        uint32_t iFlag;                 
        uint32_t iEntryCount;           
        uint32_t sSampleCount[1024];    
        uint32_t sSampleDelta[1024];    
    }sStsH_t;
 
    typedef struct StcoH_s
    {
        uint8_t cVersion;               
        uint32_t iFlag;                 
        uint32_t iEntryCount;           
        uint32_t sChunkOffset[1024];    
    }sStcoH_t;
 
    typedef struct StscH_s
    {
        uint8_t cVersion;                       
        uint32_t iFlag;                         
        uint32_t iEntryCount;                   
        uint32_t sFirstChunk[1024];             
        uint32_t sSamplePerChunk[1024];         
        uint32_t sSampleDescriptionIndex[1024]; 
    }sStscH_t;
 
    typedef struct StszH_s
    {
        uint8_t cVersion;           
        uint32_t iFlag;             
        uint32_t iSampleSize;       
        uint32_t iSampleCount;      
        uint32_t iEntrySize[16];    
    }sStszH_t;
 
    typedef struct StsdH_s
    {
        uint8_t cVersion;                   
        uint32_t iFlag;                     
        uint32_t iEntryCount;               
        int32_t iHandlerType;               
        sUnSampleEntry_t sSampleEntry[4];   
    }sStsdH_t;
 
    typedef struct StblH_s
    {
        sStsdH_t stStsd;    
        sStszH_t stStsz;    
        sStscH_t stStsc;    
        sStcoH_t stStco;    
        sStsH_t stStts;     
    }sStblH_t;
 
    typedef struct VmhdH_s
    {
        uint8_t cVersion;       
        uint32_t iFlag;         
        uint16_t iGraphicsMode; 
        uint16_t sOpColor[3];   
    }sVmhdH_t;
 
    typedef struct MinfH_s
    {
        sVmhdH_t stVmhd;            
        sStblH_t stStbl;            
        uint8_t sMinfData[1024];    
    }sMinfH_t;
 
    typedef struct HdlrH_s
    {
        uint8_t cVersion;           
        uint32_t iFlag;             
        uint8_t sHandlerType[4];    
        int32_t iNameLen;           
        uint8_t sName[260];         
    }sHdlrH_t;
 
    typedef struct MdhdH_s
    {
        uint8_t cVersion;           
        uint32_t iFlag;             
        uint64_t lCreationTime;     
        uint64_t lModificationTime; 
        uint32_t iTimescale;        
        uint64_t lDuration;         
        uint8_t sLanguage[3];       
    }sMdhdH_t;
 
    typedef struct MdiaH_s
    {
        sMdhdH_t stMdhd;            
        sHdlrH_t stHdlr;            
        sMinfH_t stMinf;            
        uint8_t sMdiaData[1024];    
    }sMdiaH_t;
 
    typedef struct MehdH_s
    {
        uint64_t lFragmentDuration; 
        uint8_t cVersion;           
        uint32_t iFlag;             
    }sMehdH_t;
 
 
    typedef struct TkhdH_s
    {
        uint8_t cVersion;           
        uint32_t iFlag;             
        uint64_t lCreationTime;     
        uint64_t lModificationTime; 
        uint32_t iTrackID;          
        uint32_t iReserved;         
        uint64_t lDuration;         
        uint32_t sReserved2[2];     
        uint16_t iLayer;            
        uint16_t iAlternateGroup;   
        uint16_t iVolume;           
        uint16_t iReserved3;        
        uint32_t sMatrix[9];        
        uint32_t iWidth;            
        uint32_t iHeight;           
    }sTkhdH_t;
 
    typedef struct TrakH_s
    {
        sTkhdH_t stTkhd;            
        sMdiaH_t stMdia;            
        uint8_t sTrakData[4096];    
    }sTrakH_t;
 
    typedef struct TrunH_s
    {
        uint8_t cVersion;                               
        uint32_t iFlag;                                 
        uint32_t iSampleCount;                          
        bool bDataOffset;                               
        uint32_t iDataOffset;                           
        bool bFirstSampleFlags;                         
        uint32_t iFirstSampleFlags;                     
        bool bSampleDuration;                           
        uint32_t sSampleDuration[1024];                 
        bool bSampleSize;                               
        uint32_t sSampleSize[1024];                     
        bool bSampleFlags;                              
        uint32_t sSampleFlags[1024];                    
        bool bSampleCompositionTimeOffset;              
        uint32_t uiSampleCompositionTimeOffset[1024];   
        int32_t iSampleCompositionTimeOffset[1024];     
    }sTrunH_t;
 
    typedef struct TfhdH_s
    {
        int32_t iVersion;                   
        int32_t iFlag;                      
        uint32_t iTrackID;                  
        bool bBaseDataOffset;               
        uint64_t lBaseDataOffset;           
        bool bSampleDescriptionIndex;       
        uint32_t iSampleDescriptionIndex;   
        bool bDefaultSampleDuration;        
        uint32_t iDefaultSampleDuration;    
        bool bDefaultSampleSize;            
        uint32_t iDefaultSampleSize;        
        bool bDefaultSampleFlags;           
        uint32_t iDefaultSampleFlags;       
        bool bDurationIsEmpty;              
        bool bDefaultBaseIsMoof;            
        uint8_t sTfhdData[256];             
    }sTfhdH_t;
 
    typedef struct TfdtH_s
    {
        uint8_t cVersion;               
        uint32_t iFlag;                 
        uint64_t lBaseMediaDecodeTime;  
        uint8_t sTfdtData[256];         
    }sTfdtH_t;
 
    typedef struct TrafH_s
    {
        sTfhdH_t stTfhd;            
        sTfdtH_t stTfdt;            
        sTrunH_t stTrun;            
        uint8_t sTrafData[4096];    
    }sTrafH_t;
 
    typedef struct PsshH_s
    {
        uint32_t iVersion;          
        uint32_t iFlag;             
        uint32_t sSystemId[16];     
        uint32_t iKidCount;         
        uint8_t skid[16][16];       
        uint32_t iEcmLength;        
        uint8_t sEcmMessage[10240]; 
    }sPsshH_t;
 
    typedef struct MfhdH_s
    {
        uint32_t iSequenceNumber;   
        uint8_t sMfhdData[256];     
        uint8_t cVersion;           
        uint32_t iFlag;             
    }sMfhdH_t;
 
    typedef struct MoofH_s
    {
        sPsshH_t stPssh;            
        sMfhdH_t stMfhd;            
        sTrafH_t sTraf[MAX_TRAK];   
        int32_t iTrafNum;           
    }sMoofH_t;
 
    typedef struct SidxH_s
    {
        uint32_t iReferenceId;                  
        uint32_t iTimeScale;                    
        uint64_t lEarliestPresentationTime;     
        uint64_t lFirstOffset;                  
        uint16_t iReferenceCount;               
        uint8_t cReferenceType;                 
        uint32_t iReferencedSize;               
        uint32_t iSubsegmentDuration;           
        uint8_t cStartsWithSAP;                 
        uint8_t cSAPType;                       
        uint32_t iSAPDeltaTime;                 
    }sSidxH_t;
 
    typedef struct TrepH_s
    {
        uint32_t iTrackId;      
        uint8_t sTrepData[256]; 
    }sTrepH_t;
 
    typedef struct TrexH_s
    {
        uint32_t iVersion;                             
        uint32_t iFlag;                                
        uint32_t iTrackID;                             
        uint32_t iDefaultSampleDescriptionIndex;       
        uint32_t iDefaultSampleDuration;               
        uint32_t iDefaultSampleSize;                   
        uint32_t iDefaultSampleFlags;                  
        uint8_t sTrexData[1024];                       
    }sTrexH_t;
 
    typedef struct MmpuH_s
    {
        uint8_t cVersion;                  
        uint8_t cIsComplete;               
        uint8_t cIsAdcPresent;             
        uint8_t cReserved;                 
        uint32_t iMpuSequenceNumber;       
        uint32_t iAssetIdScheme;           
        uint32_t iAssetIdLength;           
        uint8_t sAssetIdValue[256];        
    }sMmpuH_t;
 
    typedef struct FtypH_s
    {
        uint8_t sMajorBrand[4];                     
        uint32_t iMinorVersion;                     
        uint32_t iCompatibleNum;                    
        uint8_t sCompatibleBrands[16][4];           
    }sFtypH_t;
 
    typedef struct MvexH_s
    {
        sMehdH_t stMehd;                    
        sTrexH_t sTrex[MAX_TREX];           
        sTrepH_t stTrep;                    
        uint8_t cTrexNum;                   
    }sMvexH_t;
 
    typedef struct MoovH_s
    {
        sMvhdH_t stMvhd;    
        sTrakH_t sTrak[4];  
        sMvexH_t stMvex;    
        int32_t iTrakNum;   
    }sMoovH_t;
 
    typedef struct MP4_s{
        sFtypH_t stFtyp;    
        sMoovH_t stMoov;    
        sMoofH_t stMoof;    
        sMmpuH_t stMmpu;    
    }sMp4_t;
 
    class CMDAT_H
    {
    public:
        CMDAT_H(int32_t esSize) {
 
            pData = (uint8_t*)malloc(sizeof(uint8_t) * esSize);
 
            cEsMaxSize = esSize;
            Init();
        }
 
        ~CMDAT_H() {
 
            free(pData);
 
        }
 
        void Init( void ) {
 
            memset(pData, 0x00, sizeof(uint8_t) * cEsMaxSize);
 
 
            for (int32_t i = 0; i < MAX_SEGMENT_SIZE; i++)
            {
                iDataSize[i] = 0;
                iDataPts[i] = 0;
            }
            cDataCount = 0;
        }
 
        uint8_t* pData;                         
        uint32_t iDataSize[MAX_SEGMENT_SIZE];   
        uint32_t iDataPts[MAX_SEGMENT_SIZE];    
        uint8_t cDataCount;                     
        uint8_t cEsMaxSize;                     
    };
};