mpegparser.cc

Linux下比较早的基于命令行的DVD播放器

        if (i!=1 && currentStartCode==STARTCODE_EXTENSION) {
            parseExtensionData(i);
        }
        if (currentStartCode==STARTCODE_USER_DATA) {
            parseUserData();
        }
    }
}

//------------------------------------------------------------------------------

void MPEGParser::parseExtensionData(unsigned i)
{
//     Log::debug("mpeg::MPEGParser::parseExtensionData\n");

    while(!isInterrupted() && currentStartCode==STARTCODE_EXTENSION) {
        unsigned extensionCode = readBits(4);
        if (i==0) {
            switch(extensionCode) {
              case EXTENSION_SEQUENCE_DISPLAY:
                parseSequenceDisplayExtension();
                break;
              case EXTENSION_SEQUENCE_SCALABLE:
                parseSequenceScalableExtension();
                break;
              default:
                Log::debug("mpeg::MPEGParser::parseExtensionData: Unhandled extension data when i=0: 0x%02x\n", extensionCode);
                nextStartCode();
                break;
            }
        }
        if (i==2) {
            switch(extensionCode) {
              case EXTENSION_QUANT_MATRIX:
                parseQuantMatrixExtension();
                break;
              case EXTENSION_COPYRIGHT:
                parseCopyrightExtension();
                break;
              case EXTENSION_PICTURE_DISPLAY:
                parsePictureDisplayExtension();
                break;
              case EXTENSION_PICTURE_SPATIAL_SCALABLE:
                parsePictureSpatialScalableExtension();
                break;
              case EXTENSION_PICTURE_TEMPORAL_SCALABLE:
                parsePictureTemporalScalableExtension();
                break;
              default:
                Log::debug("mpeg::MPEGParser::parseExtensionData: Unhandled extension data when i=2: 0x%02x\n", extensionCode);
                nextStartCode();
                break;
            }
        }
    }
}

//------------------------------------------------------------------------------

void MPEGParser::parseUserData()
{
//     Log::debug("mpeg::MPEGParser::parseUserData\n");
    nextStartCode();
}

//------------------------------------------------------------------------------

void MPEGParser::parseSequenceDisplayExtension()
{
//     Log::debug("mpeg::MPEGParser::parseSequenceDisplayExtension\n");

    readBits(3);               // video_format

    bool hasColourDescription = readBits(1)==1;
    if (hasColourDescription) {
        readBits(8);          // colour_primaries
        readBits(8);          // transfer_characteristicd
        readBits(8);          // matrix_coefficients
    }
    
    readBits(14);             // display_horizontal_size
    readBits(1);              // marker bit
    readBits(14);             // display_vertical_size

    nextStartCode();
}

//------------------------------------------------------------------------------

void MPEGParser::parseSequenceScalableExtension()
{
//     Log::debug("mpeg::MPEGParser::parseSequenceScalableExtension\n");

    unsigned scalableMode = readBits(2);
    Log::debug("  scalable_mode=%u\n", scalableMode);

    Log::debug("  layer_id=%u\n", readBits(4));

    if (scalableMode==0x01) {      // spatial scalability
        Log::debug("  lower_layer_prediction_horizontal_size=%u\n", readBits(14));
        readBits(1);          // marker bit
        Log::debug("  lower_layer_prediction_vertical_size=%u\n", readBits(14));
        Log::debug("  horizontal_subsampling_factor_m=%u\n", readBits(5));
        Log::debug("  horizontal_subsampling_factor_n=%u\n", readBits(5));
        Log::debug("  vertical_subsampling_factor_m=%u\n", readBits(5));
        Log::debug("  vertical_subsampling_factor_n=%u\n", readBits(5));
    } else if (scalableMode==0x03) {      // temporal scalability
        bool pictureMuxEnable = readBits(1)==1;
        Log::debug("  picture_mux_enable=%s\n", pictureMuxEnable ? "true" : "false");
        if (pictureMuxEnable) {
            Log::debug("  mux_to_progressive_sequence=%u\n", readBits(1));
        }
        Log::debug("  picture_mux_order=%u\n", readBits(3));
        Log::debug("  picture_mux_factor=%u\n", readBits(3));
    } else {
        Log::debug("Unhandled scalableMode: %u\n", scalableMode);
    }

    nextStartCode();
}

//------------------------------------------------------------------------------

void MPEGParser::parseQuantMatrixExtension()
{
//     Log::debug("mpeg::MPEGParser::parseQuantMatrixExtension\n");

    quantMatrix.loadIntraQMX = readBits(1);
    if (quantMatrix.loadIntraQMX) {
        for(size_t i = 0; i<sizeof(quantMatrix.intraQMX); ++i) {
            quantMatrix.intraQMX[i] = readBits(8);
        }
    }

    quantMatrix.loadNonIntraQMX = readBits(1);
    if (quantMatrix.loadNonIntraQMX) {
        for(size_t i = 0; i<sizeof(quantMatrix.nonIntraQMX); ++i) {
            quantMatrix.nonIntraQMX[i] = readBits(8);
        }
    }

    quantMatrix.loadChromaIntraQMX = readBits(1);
    if (quantMatrix.loadChromaIntraQMX) {
        for(size_t i = 0; i<sizeof(quantMatrix.chromaIntraQMX); ++i) {
            quantMatrix.chromaIntraQMX[i] = readBits(8);
        }
    }

    quantMatrix.loadChromaNonIntraQMX = readBits(1);
    if (quantMatrix.loadChromaNonIntraQMX) {
        for(size_t i = 0; i<sizeof(quantMatrix.chromaNonIntraQMX); ++i) {
            quantMatrix.chromaNonIntraQMX[i] = readBits(8);
        }
    }

    if (!isInterrupted()) {
        listener.quantMatrix(quantMatrix);
    }

    nextStartCode();
}

//------------------------------------------------------------------------------

void MPEGParser::parseCopyrightExtension()
{
    Log::debug("mpeg::MPEGParser::parseCopyrightExtension\n");

    Log::debug("  copyright_flag=%u\n", readBits(1));
    Log::debug("  copyright_identifier=%u\n", readBits(8));
    Log::debug("  original_or_copy=%u\n", readBits(1));

    readBits(7);             // reserved
    readBits(1);             // marker bit

    Log::debug("  copyright_number_1=%u\n", readBits(20));

    readBits(1);             // marker bit

    Log::debug("  copyright_number_2=%u\n", readBits(22));

    readBits(1);             // marker bit

    Log::debug("  copyright_number_3=%u\n", readBits(22));

    nextStartCode();
}

//------------------------------------------------------------------------------

void MPEGParser::parsePictureDisplayExtension()
{
    Log::debug("mpeg::MPEGParser::parsePictureDisplayExtension!!!!!!!!!!!!!!!!!!\n");
    
    unsigned numberOfFrameCentreOffsets = 0;
    if (sequenceHeader.progressive) {
        if (pictureHeader.repeatFirstField) {
            if (pictureHeader.topFieldFirst) {
                numberOfFrameCentreOffsets = 3;
            } else {
                numberOfFrameCentreOffsets = 2;
            } 
        } else {
            numberOfFrameCentreOffsets = 1;
        }
    } else {
        if (pictureHeader.pictureStructure == PictureHeader::PICTURE_TOP ||
            pictureHeader.pictureStructure == PictureHeader::PICTURE_BOTTOM)
        {
            numberOfFrameCentreOffsets = 1;
        } else {
            if (pictureHeader.repeatFirstField) {
                numberOfFrameCentreOffsets = 3;
            } else {
                numberOfFrameCentreOffsets = 2;
            }
        }
    }

    for(unsigned i = 0; i<numberOfFrameCentreOffsets; ++i) {
        Log::debug("  frame_centre_horizontal_offset[%u]=%u\n", i, readBits(16));
        readBits(1);          // marker bit
        Log::debug("  frame_centre_vertical_offset[%u]=%u\n", i, readBits(16));
        readBits(1);          // marker bit
    }

    nextStartCode();
}

//------------------------------------------------------------------------------

void MPEGParser::parsePictureSpatialScalableExtension()
{
    Log::debug("mpeg::MPEGParser::parsePictureSpaticalScalableExtension\n");
    
    Log::debug("  lower_layer_temporal_reference=%u\n", readBits(10));
    readBits(1);          // marker bit
    Log::debug("  lower_layer_horizontal_offset=%u\n", readBits(15));
    readBits(1);          // marker bit
    Log::debug("  lower_layer_vertical_offset=%u\n", readBits(15));
    Log::debug("  spatial_temporal_weight_code_table_index=%u\n", readBits(2));
    Log::debug("  lower_layer_progressive_frame=%u\n", readBits(1));
    Log::debug("  lower_layer_deinterlaced_field_select=%u\n", readBits(1));

    nextStartCode();
}

//------------------------------------------------------------------------------

void MPEGParser::parsePictureTemporalScalableExtension()
{
    Log::debug("mpeg::MPEGParser::parsePictureTemporalScalableExtension\n");

    Log::debug("  reference_select_code=%u\n", readBits(2));
    Log::debug("  forward_temporal_reference=%u\n", readBits(10));
    readBits(1);          // marker bit
    Log::debug("  backward_temporal_reference=%u\n", readBits(10));

    nextStartCode();
}

//------------------------------------------------------------------------------

void MPEGParser::parseGOPHeader()
{
//     Log::debug("mpeg::MPEGParser::parseGOPHeader\n");

    gopHeader.timeCode.dropFrame = readBits(1)==1;
    gopHeader.timeCode.hours = readBits(5);
    gopHeader.timeCode.minutes = readBits(6);
    readBits(1);         // marker bit
    gopHeader.timeCode.seconds = readBits(6);
    gopHeader.timeCode.pictures = readBits(6);

    if (!isInterrupted()) {
        listener.groupOfPictures(gopHeader);
    }

    nextStartCode();
}

//------------------------------------------------------------------------------

void MPEGParser::parsePictureHeader()
{
//     Log::debug("mpeg::MPEGParser::parsePictureHeader\n");

    pictureHeader.temporalReference = readBits(10);
    pictureHeader.codingType = codingTypes[readBits(3)];
    pictureHeader.vbvDelay = readBits(16);

    if (pictureHeader.codingType==PictureHeader::CODING_P || 
        pictureHeader.codingType==PictureHeader::CODING_B)
    {
        readBits(1);          // full_pel_forward_vector
        readBits(3);          // forward_f_code
    }
    if (pictureHeader.codingType==PictureHeader::CODING_B) {
        readBits(1);          // full_pel_backward_vector
        readBits(3);          // backward_f_code
    }

    if (readBits(1)) {        // extra_bit_picture
        readBits(8);          // extra_information_picture
    }

    nextStartCode();

    if (currentStartCode!=STARTCODE_EXTENSION) {
        Log::debug("mpeg::MPEGParser::parsePictureHeader: no extension startcode found: 0x%02x\n", 
                   currentStartCode);
        return;
    }
    
    unsigned extensionCode = readBits(4);
    if (extensionCode!=EXTENSION_PICTURE_CODING) {
        Log::debug("mpeg::MPEGParser::parsePictureHeader: not a picture coding  extension found: 0x%02x\n", 
                   extensionCode);
        nextStartCode();
        return;
    }

    pictureHeader.fCode[0][0] = readBits(4);
    pictureHeader.fCode[0][1] = readBits(4);
    pictureHeader.fCode[1][0] = readBits(4);
    pictureHeader.fCode[1][1] = readBits(4);

    pictureHeader.intraDCPrecision = readBits(2) + 8;
    pictureHeader.pictureStructure = pictureStructures[readBits(2)];
    
    pictureHeader.topFieldFirst = readBits(1)==1;
    pictureHeader.onlyFramePredAndDCT = readBits(1)==1;
    pictureHeader.hasConcealmentMotionVectors = readBits(1)==1;

    pictureHeader.quantiserScaleType = readBits(1)==1;
    pictureHeader.intraVLCFormat = readBits(1)==1;

    pictureHeader.alternateScan = readBits(1)==1;
    pictureHeader.repeatFirstField = readBits(1)==1;
    readBits(1);              // chrome_420_type
    pictureHeader.progressiveFrame = readBits(1)==1;
    pictureHeader.compositeDisplay = readBits(1)==1;
    
    if (pictureHeader.compositeDisplay) {
        pictureHeader.vAxis = readBits(1);
        pictureHeader.fieldSequence = readBits(3);
        pictureHeader.subCarrierNOK = readBits(1)==1;
        pictureHeader.burstAmplitude = readBits(7);
        pictureHeader.subCarrierPhase = readBits(7);
    }

    if (!isInterrupted()) {
        listener.picture(pictureHeader);
    }
    
    nextStartCode();
}
    
//------------------------------------------------------------------------------

void MPEGParser::parsePictureData()
{
//     Log::debug("mpeg::MPEGParser::parsePictureData\n");

    do {
        parseSlice();
    } while(!isInterrupted() && 
            currentStartCode>=STARTCODE_SLICE_MIN &&
            currentStartCode<=STARTCODE_SLICE_MAX);
    if (!isInterrupted()) {
        listener.endPicture();
    }
}

//------------------------------------------------------------------------------

void MPEGParser::parseSlice()
{
    static const unsigned char startCode[3] = { 0x00, 0x00, 0x01 };

//     Log::debug("mpeg::MPEGParser::parseSlice: 0x%02x\n", currentStartCode);

    sliceBuffer[0] = 0;
    sliceBuffer[1] = 0;
    sliceBuffer[2] = 1;
    sliceBuffer[3] = currentStartCode;

    size_t sliceOffset = 4;
    size_t matchLength = 0;
    while(matchLength<3 && !isInterrupted()) {
        if (currentByte<dataLength) {
            const unsigned char* dataStart = data + currentByte;
            const unsigned char* currentData = dataStart;
            const unsigned char* dataEnd = data + dataLength;
            
            do {
                unsigned char b = *currentData++;
                
                if (b == startCode[matchLength]) {
                    ++matchLength;
                } else if (matchLength!=2 || b!=0) {
                    matchLength = 0;
                }
            } while(matchLength<sizeof(startCode) && currentData<dataEnd);
            
            size_t length = currentData - dataStart;
            assert( (sliceOffset+length)<=sliceBufferSize);
            memcpy(sliceBuffer + sliceOffset, dataStart, length);
            
            currentByte += length;
            sliceOffset += length;

        } else {
            nextPacket();
        }
    }
    
    if (!isInterrupted()) {
        // The current record
        if (sliceOffset>171772) {
            Log::debug("mpeg::MPEGParser::parseSlice: sliceOffset=%u\n", sliceOffset);
        }

        listener.slice(sliceBuffer, sliceOffset-3);
    }
    
    currentStartCode = readByte();
}

//------------------------------------------------------------------------------