自学教程：C++ AP4_DYNAMIC_CAST函数代码示例

/*----------------------------------------------------------------------|   AP4_File::AP4_File+---------------------------------------------------------------------*/AP4_File::AP4_File(AP4_ByteStream&  stream,                    AP4_AtomFactory& atom_factory,                   bool             moov_only) :    m_Movie(NULL),    m_FileType(NULL),    m_MetaData(NULL),    m_MoovIsBeforeMdat(true){    // parse top-level atoms    AP4_Atom*    atom;    AP4_Position stream_position;    bool         keep_parsing = true;    while (keep_parsing &&           AP4_SUCCEEDED(stream.Tell(stream_position)) &&            AP4_SUCCEEDED(atom_factory.CreateAtomFromStream(stream, atom))) {        AddChild(atom);        switch (atom->GetType()) {            case AP4_ATOM_TYPE_MOOV:                m_Movie = new AP4_Movie(AP4_DYNAMIC_CAST(AP4_MoovAtom, atom), stream, false);                if (moov_only) keep_parsing = false;                break;            case AP4_ATOM_TYPE_FTYP:                m_FileType = AP4_DYNAMIC_CAST(AP4_FtypAtom, atom);                break;            case AP4_ATOM_TYPE_MDAT:                // see if we are before the moov atom                if (m_Movie == NULL) m_MoovIsBeforeMdat = false;                break;        }    }}

/*----------------------------------------------------------------------|   AP4_TrakAtom::GetChunkOffsets+---------------------------------------------------------------------*/AP4_ResultAP4_TrakAtom::GetChunkOffsets(AP4_Array<AP4_UI64>& chunk_offsets){    AP4_Atom* atom;    if ((atom = FindChild("mdia/minf/stbl/stco"))) {        AP4_StcoAtom* stco = AP4_DYNAMIC_CAST(AP4_StcoAtom, atom);        if (stco == NULL) return AP4_ERROR_INTERNAL;        AP4_Cardinal    stco_chunk_count   = stco->GetChunkCount();        const AP4_UI32* stco_chunk_offsets = stco->GetChunkOffsets();        chunk_offsets.SetItemCount(stco_chunk_count);        for (unsigned int i=0; i<stco_chunk_count; i++) {            chunk_offsets[i] = stco_chunk_offsets[i];        }        return AP4_SUCCESS;    } else if ((atom = FindChild("mdia/minf/stbl/co64"))) {        AP4_Co64Atom* co64 = AP4_DYNAMIC_CAST(AP4_Co64Atom, atom);        if (co64 == NULL) return AP4_ERROR_INTERNAL;        AP4_Cardinal    co64_chunk_count   = co64->GetChunkCount();        const AP4_UI64* co64_chunk_offsets = co64->GetChunkOffsets();        chunk_offsets.SetItemCount(co64_chunk_count);        for (unsigned int i=0; i<co64_chunk_count; i++) {            chunk_offsets[i] = co64_chunk_offsets[i];        }        return AP4_SUCCESS;    } else {        return AP4_ERROR_INVALID_STATE;    }}

    virtual TrackHandler* CreateTrackHandler(AP4_TrakAtom* trak) {        // find the stsd atom        AP4_StsdAtom* stsd = AP4_DYNAMIC_CAST(AP4_StsdAtom, trak->FindChild("mdia/minf/stbl/stsd"));        // avoid tracks with no stsd atom (should not happen)        if (stsd == NULL) return NULL;        // we only look at the first sample description        AP4_SampleDescription* desc = stsd->GetSampleDescription(0);        AP4_MpegAudioSampleDescription* audio_desc =             AP4_DYNAMIC_CAST(AP4_MpegAudioSampleDescription, desc);        if (audio_desc && audio_desc->GetObjectTypeId()==AP4_OTI_MPEG2_AAC_AUDIO_LC) {            // patch the stsd            AP4_MpegAudioSampleDescription new_audio_desc(AP4_OTI_MPEG4_AUDIO,                                                          audio_desc->GetSampleRate(),                                                           audio_desc->GetSampleSize(),                                                          audio_desc->GetChannelCount(),                                                          &audio_desc->GetDecoderInfo(),                                                          audio_desc->GetBufferSize(),                                                          audio_desc->GetMaxBitrate(),                                                          audio_desc->GetAvgBitrate());            stsd->RemoveChild(stsd->GetChild(AP4_ATOM_TYPE_MP4A));            stsd->AddChild(new_audio_desc.ToAtom());            printf("audio sample description patched/n");        }        return NULL;    }

/*----------------------------------------------------------------------|   AP4_TrakAtom::AP4_TrakAtom+---------------------------------------------------------------------*/AP4_TrakAtom::AP4_TrakAtom(AP4_UI32         size,                           AP4_ByteStream&  stream,                           AP4_AtomFactory& atom_factory) :    AP4_ContainerAtom(AP4_ATOM_TYPE_TRAK, size, false, stream, atom_factory){    m_TkhdAtom = AP4_DYNAMIC_CAST(AP4_TkhdAtom, FindChild("tkhd"));    m_MdhdAtom = AP4_DYNAMIC_CAST(AP4_MdhdAtom, FindChild("mdia/mdhd"));}

/*----------------------------------------------------------------------|   AP4_OmaDcfAtomDecrypter::DecryptAtoms+---------------------------------------------------------------------*/AP4_ResultAP4_OmaDcfAtomDecrypter::DecryptAtoms(AP4_AtomParent&                  atoms,                                      AP4_Processor::ProgressListener* /*listener*/,                                      AP4_BlockCipherFactory*          block_cipher_factory,                                      AP4_ProtectionKeyMap&            key_map){    // default factory    if (block_cipher_factory == NULL) {        block_cipher_factory = &AP4_DefaultBlockCipherFactory::Instance;    }    unsigned int index = 1;    for (AP4_List<AP4_Atom>::Item* item = atoms.GetChildren().FirstItem();            item;            item = item->GetNext()) {        AP4_Atom* atom = item->GetData();        if (atom->GetType() != AP4_ATOM_TYPE_ODRM) continue;        // check that we have the key        const AP4_DataBuffer* key = key_map.GetKey(index++);        if (key == NULL) return AP4_ERROR_INVALID_PARAMETERS;        // check that we have all the atoms we need        AP4_ContainerAtom* odrm = AP4_DYNAMIC_CAST(AP4_ContainerAtom, atom);        if (odrm == NULL) continue; // not enough info        AP4_OdheAtom* odhe = AP4_DYNAMIC_CAST(AP4_OdheAtom, odrm->GetChild(AP4_ATOM_TYPE_ODHE));        if (odhe == NULL) continue; // not enough info        AP4_OddaAtom* odda = AP4_DYNAMIC_CAST(AP4_OddaAtom, odrm->GetChild(AP4_ATOM_TYPE_ODDA));;        if (odda == NULL) continue; // not enough info        AP4_OhdrAtom* ohdr = AP4_DYNAMIC_CAST(AP4_OhdrAtom, odhe->GetChild(AP4_ATOM_TYPE_OHDR));        if (ohdr == NULL) continue; // not enough info        // do nothing if the atom is not encrypted        if (ohdr->GetEncryptionMethod() == AP4_OMA_DCF_ENCRYPTION_METHOD_NULL) {            continue;        }        // create the byte stream        AP4_ByteStream* cipher_stream = NULL;        AP4_Result result = CreateDecryptingStream(*odrm,                            key->GetData(),                            key->GetDataSize(),                            block_cipher_factory,                            cipher_stream);        if (AP4_SUCCEEDED(result)) {            // replace the odda atom's payload with the decrypted stream            odda->SetEncryptedPayload(*cipher_stream, ohdr->GetPlaintextLength());            cipher_stream->Release();            // the atom will now be in the clear            ohdr->SetEncryptionMethod(AP4_OMA_DCF_ENCRYPTION_METHOD_NULL);            ohdr->SetPaddingScheme(AP4_OMA_DCF_PADDING_SCHEME_NONE);        }    }    return AP4_SUCCESS;}

/*----------------------------------------------------------------------|   AP4_CompactingProcessor::TrackHandler::ProcessTrack+---------------------------------------------------------------------*/AP4_ResultAP4_CompactingProcessor::TrackHandler::ProcessTrack(){    // find the stsz atom    AP4_ContainerAtom* stbl = AP4_DYNAMIC_CAST(AP4_ContainerAtom, m_TrakAtom->FindChild("mdia/minf/stbl"));    if (stbl == NULL) return AP4_SUCCESS;    AP4_StszAtom* stsz = AP4_DYNAMIC_CAST(AP4_StszAtom, stbl->GetChild(AP4_ATOM_TYPE_STSZ));    if (stsz == NULL) return AP4_SUCCESS;        // check if we can reduce the size of stsz by changing it to stz2    AP4_UI32 max_size = 0;    for (unsigned int i=1; i<=stsz->GetSampleCount(); i++) {        AP4_Size sample_size;        stsz->GetSampleSize(i, sample_size);        if (sample_size > max_size) {            max_size = sample_size;        }    }    AP4_UI08 field_size = 0;    if (max_size <= 0xFF) {        field_size = 1;    } else if (max_size <= 0xFFFF) {        field_size = 2;    }    if (m_Outer.m_Verbose) printf("Track %d: ", m_TrakAtom->GetId());    if (field_size == 0) {        if (m_Outer.m_Verbose) {            printf("no stz2 reduction possible/n");        }        return AP4_SUCCESS;    } else {        if (m_Outer.m_Verbose) {            unsigned int reduction = (4-field_size)*stsz->GetSampleCount();            printf("stz2 reduction = %d bytes/n", reduction);            m_Outer.m_SizeReduction += reduction;        }    }        // detach the original stsz atom so we can destroy it later    m_StszAtom = stsz;    stsz->Detach();        // create an stz2 atom and populate its entries    AP4_Stz2Atom* stz2 = new AP4_Stz2Atom(field_size);    for (unsigned int i=1; i<=m_StszAtom->GetSampleCount(); i++) {        AP4_Size sample_size;        m_StszAtom->GetSampleSize(i, sample_size);        stz2->AddEntry(sample_size);    }    stbl->AddChild(stz2);        return AP4_SUCCESS;}

/*----------------------------------------------------------------------|   AutoDetectAudioFragmentDuration+---------------------------------------------------------------------*/static unsigned int AutoDetectAudioFragmentDuration(AP4_ByteStream& stream, TrackCursor* cursor){    // remember where we are in the stream    AP4_Position where = 0;    stream.Tell(where);    AP4_LargeSize stream_size = 0;    stream.GetSize(stream_size);    AP4_LargeSize bytes_available = stream_size-where;        AP4_UI64  fragment_count = 0;    AP4_UI32  last_fragment_size = 0;    AP4_Atom* atom = NULL;    while (AP4_SUCCEEDED(AP4_DefaultAtomFactory::Instance.CreateAtomFromStream(stream, bytes_available, atom))) {        if (atom && atom->GetType() == AP4_ATOM_TYPE_MOOF) {            AP4_ContainerAtom* moof = AP4_DYNAMIC_CAST(AP4_ContainerAtom, atom);            AP4_TfhdAtom* tfhd = AP4_DYNAMIC_CAST(AP4_TfhdAtom, moof->FindChild("traf/tfhd"));            if (tfhd && tfhd->GetTrackId() == cursor->m_Track->GetId()) {                ++fragment_count;                AP4_TrunAtom* trun = AP4_DYNAMIC_CAST(AP4_TrunAtom, moof->FindChild("traf/trun"));                if (trun) {                    last_fragment_size = trun->GetEntries().ItemCount();                }            }        }        delete atom;        atom = NULL;    }        // restore the stream to its original position    stream.Seek(where);        // decide if we can infer an fragment size    if (fragment_count == 0 || cursor->m_Samples->GetSampleCount() == 0) {        return 0;    }    // don't count the last fragment if we have more than one    if (fragment_count > 1 && last_fragment_size) {        --fragment_count;    }    if (fragment_count <= 1 || cursor->m_Samples->GetSampleCount() < last_fragment_size) {        last_fragment_size = 0;    }    AP4_Sample sample;    AP4_UI64 total_duration = 0;    for (unsigned int i=0; i<cursor->m_Samples->GetSampleCount()-last_fragment_size; i++) {        cursor->m_Samples->GetSample(i, sample);        total_duration += sample.GetDuration();    }    return (unsigned int)AP4_ConvertTime(total_duration/fragment_count, cursor->m_Track->GetMediaTimeScale(), 1000);}

/*----------------------------------------------------------------------|   AP4_FragmentSampleTable::AP4_FragmentSampleTable+---------------------------------------------------------------------*/AP4_FragmentSampleTable::AP4_FragmentSampleTable(AP4_ContainerAtom* traf,        AP4_TrexAtom*      trex,        AP4_Cardinal       internal_track_id,        AP4_ByteStream*    sample_stream,        AP4_Position       moof_offset,        AP4_Position       mdat_payload_offset,        AP4_UI64           dts_origin)    :m_InternalTrackId(internal_track_id){    AP4_TfhdAtom* tfhd = AP4_DYNAMIC_CAST(AP4_TfhdAtom, traf->GetChild(AP4_ATOM_TYPE_TFHD));    if (tfhd == NULL) return;    // count all the samples and reserve space for them    unsigned int sample_count = 0;    for (AP4_List<AP4_Atom>::Item* item = traf->GetChildren().FirstItem();            item;            item = item->GetNext()) {        AP4_Atom* atom = item->GetData();        if (atom->GetType() == AP4_ATOM_TYPE_TRUN) {            AP4_TrunAtom* trun = AP4_DYNAMIC_CAST(AP4_TrunAtom, atom);            if (trun) sample_count += trun->GetEntries().ItemCount();        }    }    m_Samples.EnsureCapacity(sample_count);    // check if we have a timecode base    AP4_TfdtAtom* tfdt = AP4_DYNAMIC_CAST(AP4_TfdtAtom, traf->GetChild(AP4_ATOM_TYPE_TFDT));    if (tfdt) {        dts_origin = tfdt->GetBaseMediaDecodeTime();    }    // process all the trun atoms    for (AP4_List<AP4_Atom>::Item* item = traf->GetChildren().FirstItem();            item;            item = item->GetNext()) {        AP4_Atom* atom = item->GetData();        if (atom->GetType() == AP4_ATOM_TYPE_TRUN) {            AP4_TrunAtom* trun = AP4_DYNAMIC_CAST(AP4_TrunAtom, atom);            if (trun) {                AP4_Result result = AddTrun(trun,                                            tfhd,                                            trex,                                            sample_stream,                                            moof_offset,                                            mdat_payload_offset,                                            dts_origin);                if (AP4_FAILED(result)) return;            }        }    }}

AP4_ResultAP4_Processor::NormalizeTRAF(AP4_ContainerAtom *atom, AP4_UI32 start, AP4_UI32 end, AP4_UI32 &index){	for (; AP4_Atom* child = atom->GetChild(AP4_ATOM_TYPE_TRAF, index);) {		AP4_TrafAtom* traf = AP4_DYNAMIC_CAST(AP4_TrafAtom, child);		AP4_TfhdAtom* tfhd = AP4_DYNAMIC_CAST(AP4_TfhdAtom, traf->GetChild(AP4_ATOM_TYPE_TFHD));		while (start < end && m_TrackData[start].original_id != tfhd->GetTrackId())			;		tfhd->SetTrackId(m_TrackData[start].new_id);		traf->SetInternalTrackId(start);		++index;	}	return AP4_SUCCESS;}

/*----------------------------------------------------------------------|   AP4_HintTrackReader::AP4_HintTrackReader+---------------------------------------------------------------------*/AP4_HintTrackReader::AP4_HintTrackReader(AP4_Track& hint_track,                                          AP4_Movie& movie,                                         AP4_UI32   ssrc) :    m_HintTrack(hint_track),    m_MediaTrack(NULL),    m_MediaTimeScale(0),    m_RtpSampleData(NULL),    m_Ssrc(ssrc),    m_SampleIndex(0),    m_PacketIndex(0),    m_RtpSequenceStart(0),    m_RtpTimeStampStart(0),    m_RtpTimeScale(0){    // get the media track    AP4_TrakAtom* hint_trak_atom = hint_track.UseTrakAtom();    AP4_Atom* atom = hint_trak_atom->FindChild("tref/hint");    if (atom != NULL) {        AP4_UI32 media_track_id = AP4_DYNAMIC_CAST(AP4_TrefTypeAtom, atom)->GetTrackIds()[0];        m_MediaTrack = movie.GetTrack(media_track_id);        // get the media time scale        m_MediaTimeScale = m_MediaTrack->GetMediaTimeScale();    }    // initiate random generator    srand((int)time(NULL));    // rtp sequence start init TODO!!    m_RtpSequenceStart = (AP4_UI16)(rand()&0xFFFF);    // rtp timestamp start init TODO!!    m_RtpTimeStampStart = rand();    // rtp time scale    atom = hint_trak_atom->FindChild("mdia/minf/stbl/rtp /tims");    if (atom) {        AP4_TimsAtom* tims = AP4_DYNAMIC_CAST(AP4_TimsAtom, atom);        m_RtpTimeScale = tims->GetTimeScale();    }    // generate a random ssrc if = 0    if (m_Ssrc == 0) {        m_Ssrc = rand();    }    // get the first sample    GetRtpSample(0);}

  virtual AP4_Result ProcessMoof(AP4_ContainerAtom* moof,    AP4_Position       moof_offset,    AP4_Position       mdat_payload_offset)  {    if (m_Protected_desc)    {      //Setup the decryption      AP4_Result result;      AP4_CencSampleInfoTable *sample_table;      AP4_UI32 algorithm_id = 0;      delete m_Decrypter;      m_Decrypter = 0;      AP4_ContainerAtom *traf = AP4_DYNAMIC_CAST(AP4_ContainerAtom, moof->GetChild(AP4_ATOM_TYPE_TRAF, 0));      if (!m_Protected_desc || !traf)        return AP4_ERROR_INVALID_FORMAT;      if (AP4_FAILED(result = AP4_CencSampleInfoTable::Create(m_Protected_desc, traf, algorithm_id, *m_FragmentStream, moof_offset, sample_table)))        return result;      if (AP4_FAILED(result = AP4_CencSampleDecrypter::Create(sample_table, algorithm_id, 0, 0, 0, m_SingleSampleDecryptor, m_Decrypter)))        return result;    }    return AP4_LinearReader::ProcessMoof(moof, moof_offset, mdat_payload_offset);  }

/*----------------------------------------------------------------------|       AP4_File::AP4_File+---------------------------------------------------------------------*/AP4_File::AP4_File(AP4_ByteStream& stream, AP4_AtomFactory& atom_factory) :    m_Movie(NULL){    // get all atoms    AP4_Atom* atom;    while (AP4_SUCCEEDED(atom_factory.CreateAtomFromStream(stream, atom))) {        switch (atom->GetType()) {        case AP4_ATOM_TYPE_MOOV:            m_Movie = new AP4_Movie(dynamic_cast<AP4_MoovAtom*>(atom),                                    stream);            break;        case AP4_ATOM_TYPE_MOOF:            if (m_Movie) {                m_Movie->ProcessMoof(AP4_DYNAMIC_CAST(AP4_ContainerAtom, atom),                                     stream);            }            delete atom;            break;        case AP4_ATOM_TYPE_FTYP:            //m_Movie = new AP4_Movie(dynamic_cast<AP4_FtypAtom*>(atom),  stream);            m_FileType = dynamic_cast<AP4_FtypAtom*>(atom);        default:            m_OtherAtoms.Add(atom);        }    }}

  virtual bool GetVideoInformation(unsigned int &width, unsigned int &height) override  {    if (pictureId == pictureIdPrev)      return false;    pictureIdPrev = pictureId;    if (AP4_AvcSampleDescription *avc = AP4_DYNAMIC_CAST(AP4_AvcSampleDescription, sample_description))    {      AP4_Array<AP4_DataBuffer>& buffer = avc->GetPictureParameters();      AP4_AvcPictureParameterSet pps;      for (unsigned int i(0); i < buffer.ItemCount(); ++i)      {        if (AP4_SUCCEEDED(AP4_AvcFrameParser::ParsePPS(buffer[i].GetData(), buffer[i].GetDataSize(), pps)) && pps.pic_parameter_set_id == pictureId)        {          buffer = avc->GetSequenceParameters();          AP4_AvcSequenceParameterSet sps;          for (unsigned int i(0); i < buffer.ItemCount(); ++i)          {            if (AP4_SUCCEEDED(AP4_AvcFrameParser::ParseSPS(buffer[i].GetData(), buffer[i].GetDataSize(), sps)) && sps.seq_parameter_set_id == pps.seq_parameter_set_id)            {              sps.GetInfo(width, height);              return true;            }          }          break;        }      }    }    return false;  };

/*----------------------------------------------------------------------|   AP4_Mp4sSampleEntry::ToSampleDescription+---------------------------------------------------------------------*/AP4_SampleDescription*AP4_Mp4sSampleEntry::ToSampleDescription(){    // create a sample description    return new AP4_MpegSystemSampleDescription(        AP4_DYNAMIC_CAST(AP4_EsdsAtom, GetChild(AP4_ATOM_TYPE_ESDS)));}

/*----------------------------------------------------------------------|   AP4_Track::GetTrackLanguage+---------------------------------------------------------------------*/const char*AP4_Track::GetTrackLanguage(){    if (AP4_MdhdAtom* mdhd = AP4_DYNAMIC_CAST(AP4_MdhdAtom, m_TrakAtom->FindChild("mdia/mdhd"))) {        return mdhd->GetLanguage().GetChars();    }    return NULL;}

 MPEGCodecHandler(AP4_SampleDescription *sd)   :CodecHandler(sd) {   if (AP4_MpegSampleDescription *aac = AP4_DYNAMIC_CAST(AP4_MpegSampleDescription, sample_description))   {     extra_data_size = aac->GetDecoderInfo().GetDataSize();     extra_data = aac->GetDecoderInfo().GetData();   } }

/*----------------------------------------------------------------------|   AP4_MpegAudioSampleEntry::ToSampleDescription+---------------------------------------------------------------------*/AP4_SampleDescription*AP4_MpegAudioSampleEntry::ToSampleDescription(){    // find the esds atom    AP4_EsdsAtom* esds = AP4_DYNAMIC_CAST(AP4_EsdsAtom, GetChild(AP4_ATOM_TYPE_ESDS));    if (esds == NULL) {        // check if this is a quicktime style sample description        if (m_QtVersion > 0) {            esds = AP4_DYNAMIC_CAST(AP4_EsdsAtom, FindChild("wave/esds"));        }    }        // create a sample description    return new AP4_MpegAudioSampleDescription(GetSampleRate(),                                              GetSampleSize(),                                              GetChannelCount(),                                              esds);}

/*----------------------------------------------------------------------|   AP4_LinearReader::AdvanceFragment+---------------------------------------------------------------------*/AP4_ResultAP4_LinearReader::AdvanceFragment(){    AP4_Result result;         // go the the start of the next fragment    result = m_FragmentStream->Seek(m_NextFragmentPosition);    if (AP4_FAILED(result)) return result;    // read atoms until we find a moof    assert(m_HasFragments);    if (!m_FragmentStream) return AP4_ERROR_INVALID_STATE;    do {        AP4_Atom* atom = NULL;        result = AP4_DefaultAtomFactory::Instance.CreateAtomFromStream(*m_FragmentStream, atom);        if (AP4_SUCCEEDED(result)) {            if (atom->GetType() == AP4_ATOM_TYPE_MOOF) {                AP4_ContainerAtom* moof = AP4_DYNAMIC_CAST(AP4_ContainerAtom, atom);                if (moof) {                    // remember where we are in the stream                    AP4_Position position = 0;                    m_FragmentStream->Tell(position);                            // process the movie fragment                    result = ProcessMoof(moof, position-atom->GetSize(), position+8);                    if (AP4_FAILED(result)) return result;                    // compute where the next fragment will be                    AP4_UI32 size;                    AP4_UI32 type;                    m_FragmentStream->Tell(position);                    result = m_FragmentStream->ReadUI32(size);                    if (AP4_FAILED(result)) return AP4_SUCCESS; // can't read more                    result = m_FragmentStream->ReadUI32(type);                    if (AP4_FAILED(result)) return AP4_SUCCESS; // can't read more                    if (size == 0) {                        m_NextFragmentPosition = 0;                    } else if (size == 1) {                        AP4_UI64 size_64 = 0;                        result = m_FragmentStream->ReadUI64(size_64);                        if (AP4_FAILED(result)) return AP4_SUCCESS; // can't read more                        m_NextFragmentPosition = position+size_64;                    } else {                        m_NextFragmentPosition = position+size;                    }                    return AP4_SUCCESS;                } else {                    delete atom;                }            } else {                delete atom;            }                    }    } while (AP4_SUCCEEDED(result));            return AP4_ERROR_EOS;}

 HEVCCodecHandler(AP4_SampleDescription *sd)   :CodecHandler(sd) {   if (AP4_HevcSampleDescription *hevc = AP4_DYNAMIC_CAST(AP4_HevcSampleDescription, sample_description))   {     extra_data_size = hevc->GetRawBytes().GetDataSize();     extra_data = hevc->GetRawBytes().GetData();     naluLengthSize = hevc->GetNaluLengthSize();   } }

 AVCCodecHandler(AP4_SampleDescription *sd)   : CodecHandler(sd)   , countPictureSetIds(0) {   unsigned int width(0), height(0);   if (AP4_VideoSampleDescription *video_sample_description = AP4_DYNAMIC_CAST(AP4_VideoSampleDescription, sample_description))   {     width = video_sample_description->GetWidth();     height = video_sample_description->GetHeight();   }   if (AP4_AvcSampleDescription *avc = AP4_DYNAMIC_CAST(AP4_AvcSampleDescription, sample_description))   {     extra_data_size = avc->GetRawBytes().GetDataSize();     extra_data = avc->GetRawBytes().GetData();     countPictureSetIds = avc->GetPictureParameters().ItemCount();     if (countPictureSetIds > 1 || !width || !height)       naluLengthSize = avc->GetNaluLengthSize();   } }

/*----------------------------------------------------------------------|   AP4_HintTrackReader::GetSdpText+---------------------------------------------------------------------*/AP4_ResultAP4_HintTrackReader::GetSdpText(AP4_String& sdp_text){    AP4_Atom* sdp_atom = m_HintTrack.UseTrakAtom()->FindChild("udta/hnti/sdp ");    if (sdp_atom == NULL) return AP4_FAILURE;    // C cast is OK because we know the type of the atom    sdp_text = AP4_DYNAMIC_CAST(AP4_SdpAtom, sdp_atom)->GetSdpText();     return AP4_SUCCESS;}

 virtual bool GetAudioInformation(unsigned int &channels) {   AP4_AudioSampleDescription *mpeg = AP4_DYNAMIC_CAST(AP4_AudioSampleDescription, sample_description);   if (mpeg != nullptr && mpeg->GetChannelCount() != channels)   {     channels = mpeg->GetChannelCount();     return true;   }   return false; }

/*----------------------------------------------------------------------|   AP4_Avc1SampleEntry::ToSampleDescription+---------------------------------------------------------------------*/AP4_SampleDescription*AP4_Avc1SampleEntry::ToSampleDescription(){    return new AP4_AvcSampleDescription(        m_Width,        m_Height,        m_Depth,        m_CompressorName.GetChars(),        AP4_DYNAMIC_CAST(AP4_AvccAtom, GetChild(AP4_ATOM_TYPE_AVCC)));}

/*----------------------------------------------------------------------|   AP4_Track::AP4_Track+---------------------------------------------------------------------*/AP4_Track::AP4_Track(AP4_TrakAtom&   atom,                      AP4_ByteStream& sample_stream,                      AP4_UI32        movie_time_scale) :    m_TrakAtom(&atom),    m_TrakAtomIsOwned(false),    m_Type(TYPE_UNKNOWN),    m_SampleTable(NULL),    m_SampleTableIsOwned(true),    m_MovieTimeScale(movie_time_scale){    // find the handler type    AP4_Atom* sub = atom.FindChild("mdia/hdlr");    if (sub) {        AP4_HdlrAtom* hdlr = AP4_DYNAMIC_CAST(AP4_HdlrAtom, sub);        if (hdlr) {            AP4_UI32 type = hdlr->GetHandlerType();            if (type == AP4_HANDLER_TYPE_SOUN) {                m_Type = TYPE_AUDIO;            } else if (type == AP4_HANDLER_TYPE_VIDE) {                m_Type = TYPE_VIDEO;            } else if (type == AP4_HANDLER_TYPE_HINT) {                m_Type = TYPE_HINT;            } else if (type == AP4_HANDLER_TYPE_ODSM ||                       type == AP4_HANDLER_TYPE_SDSM) {                m_Type = TYPE_SYSTEM;            } else if (type == AP4_HANDLER_TYPE_TEXT ||                       type == AP4_HANDLER_TYPE_TX3G) {                m_Type = TYPE_TEXT;            } else if (type == AP4_HANDLER_TYPE_JPEG) {                m_Type = TYPE_JPEG;            } else if (type == AP4_HANDLER_TYPE_SUBT) {                m_Type = TYPE_SUBTITLES;            }        }    }    // create a facade for the stbl atom    AP4_ContainerAtom* stbl = AP4_DYNAMIC_CAST(AP4_ContainerAtom, atom.FindChild("mdia/minf/stbl"));    if (stbl) {        m_SampleTable = new AP4_AtomSampleTable(stbl, sample_stream);    }}

/*----------------------------------------------------------------------|   AP4_MpegVideoSampleEntry::ToSampleDescription+---------------------------------------------------------------------*/AP4_SampleDescription*AP4_MpegVideoSampleEntry::ToSampleDescription(){    // create a sample description    return new AP4_MpegVideoSampleDescription(        m_Width,        m_Height,        m_Depth,        m_CompressorName.GetChars(),        AP4_DYNAMIC_CAST(AP4_EsdsAtom, GetChild(AP4_ATOM_TYPE_ESDS)));}

/*----------------------------------------------------------------------|   AP4_Track::GetFlags+---------------------------------------------------------------------*/AP4_UI32AP4_Track::GetFlags(){    if (m_TrakAtom) {        AP4_TkhdAtom* tkhd = AP4_DYNAMIC_CAST(AP4_TkhdAtom, m_TrakAtom->FindChild("tkhd"));        if (tkhd) {            return tkhd->GetFlags();        }    }    return 0;}

/*----------------------------------------------------------------------|   AP4_StsdAtom::GetSampleEntry+---------------------------------------------------------------------*/AP4_SampleEntry*AP4_StsdAtom::GetSampleEntry(AP4_Ordinal index){    // check index    if (index >= m_Children.ItemCount()) return NULL;    // return the sample entry    AP4_Atom* entry;    m_Children.Get(index, entry);    return AP4_DYNAMIC_CAST(AP4_SampleEntry, entry);}