parseMp4()

Mp4TrackInfo fl::parseMp4	(	fl::span< const fl::u8 >	data,
		fl::string *	error )

Definition at line 106 of file mp4_parser.cpp.hpp.

                                                                {
    Mp4TrackInfo info;
 
    if (data.size() < 8) {
        if (error) *error = "Data too small for MP4";
        return info;
    }
 
    // Find moov box at top level
    fl::size moovPos = findBox(data, 0, data.size(), "moov");
    if (moovPos == fl::size(-1)) {
        if (error) *error = "No moov box found";
        return info;
    }
 
    bool ok = true;
    fl::u32 moovSize = readU32BE(data, moovPos, ok);
    if (!ok) {
        if (error) *error = "Invalid moov box size";
        return info;
    }
    fl::size moovEnd = moovPos + moovSize;
    if (moovEnd > data.size()) moovEnd = data.size();
    fl::size moovBody = moovPos + 8;
 
    // Find trak box inside moov
    fl::size trakPos = findBox(data, moovBody, moovEnd, "trak");
    if (trakPos == fl::size(-1)) {
        if (error) *error = "No trak box found";
        return info;
    }
 
    fl::u32 trakSize = readU32BE(data, trakPos, ok);
    if (!ok) {
        if (error) *error = "Invalid trak box size";
        return info;
    }
    fl::size trakEnd = trakPos + trakSize;
    if (trakEnd > moovEnd) trakEnd = moovEnd;
    fl::size trakBody = trakPos + 8;
 
    // Find mdia box inside trak
    fl::size mdiaPos = findBox(data, trakBody, trakEnd, "mdia");
    if (mdiaPos == fl::size(-1)) {
        if (error) *error = "No mdia box found";
        return info;
    }
 
    fl::u32 mdiaSize = readU32BE(data, mdiaPos, ok);
    if (!ok) {
        if (error) *error = "Invalid mdia box size";
        return info;
    }
    fl::size mdiaEnd = mdiaPos + mdiaSize;
    if (mdiaEnd > trakEnd) mdiaEnd = trakEnd;
    fl::size mdiaBody = mdiaPos + 8;
 
    // Find minf box inside mdia
    fl::size minfPos = findBox(data, mdiaBody, mdiaEnd, "minf");
    if (minfPos == fl::size(-1)) {
        if (error) *error = "No minf box found";
        return info;
    }
 
    fl::u32 minfSize = readU32BE(data, minfPos, ok);
    if (!ok) {
        if (error) *error = "Invalid minf box size";
        return info;
    }
    fl::size minfEnd = minfPos + minfSize;
    if (minfEnd > mdiaEnd) minfEnd = mdiaEnd;
    fl::size minfBody = minfPos + 8;
 
    // Find stbl box inside minf
    fl::size stblPos = findBox(data, minfBody, minfEnd, "stbl");
    if (stblPos == fl::size(-1)) {
        if (error) *error = "No stbl box found";
        return info;
    }
 
    fl::u32 stblSize = readU32BE(data, stblPos, ok);
    if (!ok) {
        if (error) *error = "Invalid stbl box size";
        return info;
    }
    fl::size stblEnd = stblPos + stblSize;
    if (stblEnd > minfEnd) stblEnd = minfEnd;
    fl::size stblBody = stblPos + 8;
 
    // Find stsd box inside stbl
    fl::size stsdPos = findBox(data, stblBody, stblEnd, "stsd");
    if (stsdPos == fl::size(-1)) {
        if (error) *error = "No stsd box found";
        return info;
    }
 
    fl::u32 stsdSize = readU32BE(data, stsdPos, ok);
    if (!ok) {
        if (error) *error = "Invalid stsd box size";
        return info;
    }
    fl::size stsdEnd = stsdPos + stsdSize;
    if (stsdEnd > stblEnd) stsdEnd = stblEnd;
 
    // stsd is a full box: 8 byte header + 4 byte version/flags + 4 byte entry_count
    fl::size stsdBody = stsdPos + 8 + 4 + 4;
    if (stsdBody > stsdEnd) {
        if (error) *error = "stsd box too small";
        return info;
    }
 
    // Look for avc1 sample entry inside stsd
    fl::size avc1Pos = findBox(data, stsdBody, stsdEnd, "avc1");
    if (avc1Pos == fl::size(-1)) {
        if (error) *error = "No avc1 sample entry found (not H.264)";
        return info;
    }
 
    fl::u32 avc1Size = readU32BE(data, avc1Pos, ok);
    if (!ok) {
        if (error) *error = "Invalid avc1 box size";
        return info;
    }
    fl::size avc1End = avc1Pos + avc1Size;
    if (avc1End > stsdEnd) avc1End = stsdEnd;
 
    // avc1 sample entry layout:
    //   8 bytes: box header (size + "avc1")
    //   6 bytes: reserved
    //   2 bytes: data_reference_index
    //   2 bytes: pre_defined
    //   2 bytes: reserved
    //   12 bytes: pre_defined[3]
    //   2 bytes: width
    //   2 bytes: height
    //   ... then sub-boxes including avcC
    fl::size avc1Body = avc1Pos + 8 + 6 + 2 + 2 + 2 + 12;
    if (avc1Body + 4 > avc1End) {
        if (error) *error = "avc1 box too small for dimensions";
        return info;
    }
 
    info.width = readU16BE(data, avc1Body, ok);
    info.height = readU16BE(data, avc1Body + 2, ok);
    if (!ok) {
        if (error) *error = "Failed to read dimensions from avc1";
        return info;
    }
 
    // Skip to sub-boxes: avc1Body + 4 (width/height) + 4 (horiz res) + 4 (vert res) +
    //   4 (reserved) + 2 (frame_count) + 32 (compressor_name) + 2 (depth) + 2 (pre_defined)
    fl::size subBoxStart = avc1Body + 4 + 4 + 4 + 4 + 2 + 32 + 2 + 2;
 
    // Find avcC box inside avc1
    fl::size avcCPos = findBox(data, subBoxStart, avc1End, "avcC");
    if (avcCPos == fl::size(-1)) {
        if (error) *error = "No avcC box found inside avc1";
        return info;
    }
 
    fl::u32 avcCSize = readU32BE(data, avcCPos, ok);
    if (!ok) {
        if (error) *error = "Invalid avcC box size";
        return info;
    }
    fl::size avcCEnd = avcCPos + avcCSize;
    if (avcCEnd > avc1End) avcCEnd = avc1End;
 
    if (!parseAvcC(data, avcCPos, avcCEnd, info)) {
        if (error) *error = "Failed to parse avcC configuration record";
        return info;
    }
 
    info.isValid = true;
    return info;
}

References fl::Mp4TrackInfo::height, fl::Mp4TrackInfo::isValid, fl::span< T, Extent >::size(), and fl::Mp4TrackInfo::width.

Referenced by fl::H264::parseH264Info().

Here is the call graph for this function:

Here is the caller graph for this function: