h264parser.cpp

Go to the documentation of this file.

 
#include <cassert>
 
extern "C" {
#include <libavcodec/avcodec.h>
}
 
#include "h264parser.h"
#include "logger.h"
#include "misc.h"
 
/*****************************************************************************
 * cH264Parser class
 ****************************************************************************/
 
static void PrintStreamData(const uint8_t *data, int size)
{
    LOGDEBUG("Stream: %02x %02x %02x %02x %02x %02x %02x %02x %02x "
             "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x "
             "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x size %d",
             data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8],
             data[9], data[10], data[11], data[12], data[13], data[14], data[15], data[16], data[17],
             data[18], data[19], data[20], data[21], data[22], data[23], data[24], data[25], data[26],
             data[27], data[28], data[29], data[30], data[31], data[32], data[33], data[34], size);
}
 
bool isValidStartCode(const uint8_t *data, int offset)
{
    return ReadBytes(&data[offset], 3) == 0x000001;
}
 
static int NalUnitType(const uint8_t *data, int i)
{
    return data[i + 3] & 0x1F;
}
 
cH264Parser::cH264Parser(AVPacket *avpkt)
    : m_pAvpkt(avpkt)
{
    int i;
 
    // part 1: collect the nalu types in the packet
    for (i = 0; i < m_pAvpkt->size - 3; i++) {
        if (!isValidStartCode(m_pAvpkt->data, i))
            continue;
 
        switch (NalUnitType(m_pAvpkt->data, i)) {
            case 1:
                m_nalutype |= NALU_TYPE_NON_IDR;
                break;
            case 5:
                m_nalutype |= NALU_TYPE_IDR;
                break;
            case 6:
                m_nalutype |= NALU_TYPE_SEI;
                break;
            case 7:
                m_nalutype |= NALU_TYPE_SPS;
                break;
            case 8:
                m_nalutype |= NALU_TYPE_PPS;
                break;
            case 9:
                m_nalutype |= NALU_TYPE_AUD;
                break;
            default:
                break;
        }
    }
 
    // part 2: parse h264 SPS and get width and height
    m_pStart = NULL;
    for (i = 0; i < m_pAvpkt->size - 4; i++) {
        if (!isValidStartCode(m_pAvpkt->data, i))
            continue;
 
        if (NalUnitType(m_pAvpkt->data, i) == 7) {
            m_pStart = &m_pAvpkt->data[i + 4];
            m_nLength = m_pAvpkt->size - i - 4;
            break;
        }
    }
 
    // no SPS available
    if (!m_pStart) {
        LOGERROR("H264Parser: %s: No m_pStart %p Pkt %p i %d", __FUNCTION__, m_pStart, m_pAvpkt, i);
        PrintStreamData(m_pAvpkt->data, m_pAvpkt->size);
        return;
    }
 
    m_nCurrentBit = 0;
    int frameCropLeftOffset = 0;
    int frameCropRightOffset = 0;
    int frameCropTopOffset = 0;
    int frameCropBottomOffset = 0;
    int chromaFormatIdc = 0;
    int separateColorPlaneFlag = 0;
 
    int profileIdc = ReadBits(8);
    ReadBits(16);
    ReadExponentialGolombCode();
 
    if (profileIdc == 100 || profileIdc == 110 ||
        profileIdc == 122 || profileIdc == 244 ||
        profileIdc == 44 || profileIdc == 83 ||
        profileIdc == 86 || profileIdc == 118) {
 
        chromaFormatIdc = ReadExponentialGolombCode();
        if (chromaFormatIdc == 3)
            separateColorPlaneFlag = ReadBit();
        ReadExponentialGolombCode();
        ReadExponentialGolombCode();
        ReadBit();
        int seqScalingMatrixPresentFlag = ReadBit();
        if (seqScalingMatrixPresentFlag) {
            for (int i = 0; i < 8; i++) {
                int seqScalingListPresentFlag = ReadBit();
                if (seqScalingListPresentFlag) {
                    int sizeOfScalingList = (i < 6) ? 16 : 64;
                    int lastScale = 8;
                    int nextScale = 8;
                    for (int j = 0; j < sizeOfScalingList; j++) {
                        if (nextScale != 0) {
                            int delta_scale = ReadSE();
                            nextScale = (lastScale + delta_scale + 256) % 256;
                        }
                        lastScale = (nextScale == 0) ? lastScale : nextScale;
                    }
                }
            }
        }
    }
    ReadExponentialGolombCode();
    int picOrderCntType = ReadExponentialGolombCode();
    if (picOrderCntType == 0) {
        ReadExponentialGolombCode();
    } else if (picOrderCntType == 1) {
        ReadBit();
        ReadSE();
        ReadSE();
        int numRefFramesInPicOrderCntCycle = ReadExponentialGolombCode();
        for (int i = 0; i < numRefFramesInPicOrderCntCycle; i++ ) {
            ReadSE();
        }
    }
    ReadExponentialGolombCode();
    ReadBit();
    int picWidthInMbsMinusOne = ReadExponentialGolombCode();
    int picHeightInMapUnitsMinusOne = ReadExponentialGolombCode();
    int frameMbsOnlyFlag = ReadBit();
    if (!frameMbsOnlyFlag) {
        m_mbaff = ReadBit();
    }
 
    ReadBit();
    int frameCroppingFlag = ReadBit();
    if (frameCroppingFlag) {
        frameCropLeftOffset = ReadExponentialGolombCode();
        frameCropRightOffset = ReadExponentialGolombCode();
        frameCropTopOffset = ReadExponentialGolombCode();
        frameCropBottomOffset = ReadExponentialGolombCode();
    }
 
    int subWidthC = 0;
    int subHeightC = 0;
 
    if (chromaFormatIdc == 0 && separateColorPlaneFlag == 0) { // monochrome
        subWidthC = subHeightC = 2;
    } else if (chromaFormatIdc == 1 && separateColorPlaneFlag == 0) { // 4:2:0
        subWidthC = subHeightC = 2;
    } else if (chromaFormatIdc == 2 && separateColorPlaneFlag == 0) { // 4:2:2
        subWidthC = 2;
        subHeightC = 1;
    } else if (chromaFormatIdc == 3) { // 4:4:4
        if (separateColorPlaneFlag == 0) {
            subWidthC = subHeightC = 1;
        } else if (separateColorPlaneFlag == 1) {
            subWidthC = subHeightC = 0;
        }
    }
 
    m_width = ((picWidthInMbsMinusOne + 1) * 16) -
        subWidthC * (frameCropRightOffset + frameCropLeftOffset);
 
    m_height = ((2 - frameMbsOnlyFlag)* (picHeightInMapUnitsMinusOne +1) * 16) -
        subHeightC * ((frameCropBottomOffset * 2) + (frameCropTopOffset * 2));
 
    LOGDEBUG2(L_CODEC, "H264Parser: %s %s%s%s%s%s%s width %d height %d", __FUNCTION__,
        m_nalutype & NALU_TYPE_AUD     ? "AUD " : "",
        m_nalutype & NALU_TYPE_SPS     ? "SPS " : "",
        m_nalutype & NALU_TYPE_PPS     ? "PPS " : "",
        m_nalutype & NALU_TYPE_SEI     ? "SEI " : "",
        m_nalutype & NALU_TYPE_IDR     ? "IDR " : "",
        m_nalutype & NALU_TYPE_NON_IDR ? "NON-IDR " : "",
        m_width, m_height);
}
 
/*
 * Does the parser frame include an I-Frame?
 */
bool cH264Parser::IsIFrame(void)
{
    return (m_nalutype & NALU_TYPE_IDR) ||
          ((m_nalutype & NALU_TYPE_NON_IDR) && (m_nalutype & (NALU_TYPE_PPS | NALU_TYPE_SPS)));
}
 
/*
 * helper functions to parse resolution from stream
 */
unsigned int cH264Parser::ReadBit()
{
    assert(m_nCurrentBit <= m_nLength * 8);
    int nIndex = m_nCurrentBit / 8;
    int nOffset = m_nCurrentBit % 8 + 1;
 
    m_nCurrentBit++;
    return (m_pStart[nIndex] >> (8-nOffset)) & 0x01;
}
 
unsigned int cH264Parser::ReadBits(int n)
{
    int r = 0;
 
    for (int i = 0; i < n; i++) {
        r |= ( ReadBit() << ( n - i - 1 ) );
    }
    return r;
}
 
unsigned int cH264Parser::ReadExponentialGolombCode()
{
    int r = 0;
    int i = 0;
 
    while((ReadBit() == 0) && (i < 32)) {
        i++;
    }
 
    r = ReadBits(i);
    r += (1 << i) - 1;
    return r;
}
 
unsigned int cH264Parser::ReadSE()
{
    int r = ReadExponentialGolombCode();
 
    if (r & 0x01) {
        r = (r+1)/2;
    } else {
        r = -(r/2);
    }
    return r;
}