| /********** |
| This library is free software; you can redistribute it and/or modify it under |
| the terms of the GNU Lesser General Public License as published by the |
| Free Software Foundation; either version 3 of the License, or (at your |
| option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.) |
| |
| This library is distributed in the hope that it will be useful, but WITHOUT |
| ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
| FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for |
| more details. |
| |
| You should have received a copy of the GNU Lesser General Public License |
| along with this library; if not, write to the Free Software Foundation, Inc., |
| 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| **********/ |
| // "liveMedia" |
| // Copyright (c) 1996-2020 Live Networks, Inc. All rights reserved. |
| // A class for generating MPEG-2 Transport Stream from one or more input |
| // Elementary Stream data sources |
| // Implementation |
| |
| #include "MPEG2TransportStreamMultiplexor.hh" |
| |
| #define TRANSPORT_PACKET_SIZE 188 |
| |
| #define PAT_PERIOD_IF_UNTIMED 100 // # of packets between Program Association Tables (if not timed) |
| #define PMT_PERIOD_IF_UNTIMED 500 // # of packets between Program Map Tables (if not timed) |
| |
| void MPEG2TransportStreamMultiplexor |
| ::setTimedSegmentation(unsigned segmentationDuration, |
| onEndOfSegmentFunc* onEndOfSegmentFunc, |
| void* onEndOfSegmentClientData) { |
| fSegmentationDuration = segmentationDuration; |
| fOnEndOfSegmentFunc = onEndOfSegmentFunc; |
| fOnEndOfSegmentClientData = onEndOfSegmentClientData; |
| } |
| |
| MPEG2TransportStreamMultiplexor |
| ::MPEG2TransportStreamMultiplexor(UsageEnvironment& env) |
| : FramedSource(env), |
| fHaveVideoStreams(True/*by default*/), |
| fOutgoingPacketCounter(0), fProgramMapVersion(0xFF), |
| fPreviousInputProgramMapVersion(0xFF), fCurrentInputProgramMapVersion(0), |
| fPCR_PID(0), fCurrentPID(0), |
| fInputBuffer(NULL), fInputBufferSize(0), fInputBufferBytesUsed(0), |
| fIsFirstAdaptationField(True), fSegmentationDuration(0), fSegmentationIndication(1), |
| fCurrentSegmentDuration(0.0), fPreviousPTS(0.0), |
| fOnEndOfSegmentFunc(NULL), fOnEndOfSegmentClientData(NULL) { |
| for (unsigned i = 0; i < PID_TABLE_SIZE; ++i) { |
| fPIDState[i].counter = 0; |
| fPIDState[i].streamType = 0; |
| } |
| } |
| |
| MPEG2TransportStreamMultiplexor::~MPEG2TransportStreamMultiplexor() { |
| } |
| |
| Boolean MPEG2TransportStreamMultiplexor::isMPEG2TransportStreamMultiplexor() const { |
| return True; |
| } |
| |
| void MPEG2TransportStreamMultiplexor::doGetNextFrame() { |
| if (fInputBufferBytesUsed >= fInputBufferSize) { |
| // No more bytes are available from the current buffer. |
| // Arrange to read a new one. |
| awaitNewBuffer(fInputBuffer); |
| return; |
| } |
| |
| do { |
| // Periodically return a Program Association Table packet instead: |
| if ((segmentationIsTimed() && fSegmentationIndication == 1) |
| || (!segmentationIsTimed() && fOutgoingPacketCounter % PAT_PERIOD_IF_UNTIMED == 0)) { |
| ++fOutgoingPacketCounter; |
| deliverPATPacket(); |
| fSegmentationIndication = 2; // for next time |
| break; |
| } |
| ++fOutgoingPacketCounter; |
| |
| // Periodically (or when we see a new PID) return a Program Map Table instead: |
| Boolean programMapHasChanged = fCurrentInputProgramMapVersion != fPreviousInputProgramMapVersion; |
| if (programMapHasChanged |
| || (segmentationIsTimed() && fSegmentationIndication == 2) |
| || (!segmentationIsTimed() && fOutgoingPacketCounter % PMT_PERIOD_IF_UNTIMED == 0)) { |
| if (programMapHasChanged) { // reset values for next time: |
| fPreviousInputProgramMapVersion = fCurrentInputProgramMapVersion; |
| } |
| deliverPMTPacket(programMapHasChanged); |
| fSegmentationIndication = 0; // for next time |
| break; |
| } |
| |
| // Normal case: Deliver (or continue delivering) the recently-read data: |
| deliverDataToClient(fCurrentPID, fInputBuffer, fInputBufferSize, |
| fInputBufferBytesUsed); |
| } while (0); |
| |
| // NEED TO SET fPresentationTime, durationInMicroseconds ##### |
| // Complete the delivery to the client: |
| if ((fOutgoingPacketCounter%10) == 0) { |
| // To avoid excessive recursion (and stack overflow) caused by excessively large input frames, |
| // occasionally return to the event loop to do this: |
| nextTask() = envir().taskScheduler().scheduleDelayedTask(0, (TaskFunc*)FramedSource::afterGetting, this); |
| } else { |
| afterGetting(this); |
| } |
| } |
| |
| void MPEG2TransportStreamMultiplexor |
| ::handleNewBuffer(unsigned char* buffer, unsigned bufferSize, |
| int mpegVersion, MPEG1or2Demux::SCR scr, int16_t PID) { |
| if (bufferSize < 4) return; |
| fInputBuffer = buffer; |
| fInputBufferSize = bufferSize; |
| fInputBufferBytesUsed = 0; |
| |
| u_int8_t stream_id = fInputBuffer[3]; |
| // Use "stream_id" directly as our PID. |
| // Also, figure out the Program Map 'stream type' from this. |
| if (stream_id == 0xBE) { // padding_stream; ignore |
| fInputBufferSize = 0; |
| } else if (stream_id == 0xBC) { // program_stream_map |
| setProgramStreamMap(fInputBufferSize); |
| fInputBufferSize = 0; // then, ignore the buffer |
| } else { |
| if (PID == -1) |
| fCurrentPID = stream_id; |
| else |
| fCurrentPID = PID; |
| |
| // Set the stream's type: |
| u_int8_t& streamType = fPIDState[fCurrentPID].streamType; // alias |
| |
| if (streamType == 0) { |
| // Instead, set the stream's type to default values, based on whether |
| // the stream is audio or video, and whether it's MPEG-1 or MPEG-2: |
| if ((stream_id&0xF0) == 0xE0) { // video |
| streamType = mpegVersion == 1 ? 1 : mpegVersion == 2 ? 2 : mpegVersion == 4 ? 0x10 : |
| mpegVersion == 5/*H.264*/ ? 0x1B : 0x24/*assume H.265*/; |
| } else if ((stream_id&0xE0) == 0xC0) { // audio |
| streamType = mpegVersion == 1 ? 3 : mpegVersion == 2 ? 4 : mpegVersion == 3 ? 6 : 0xF; |
| } else if (stream_id == 0xBD) { // private_stream1 (usually AC-3 or Opus) |
| streamType = 0x06; // for DVB or Opus; for ATSC, use 0x81 |
| } else { // something else |
| streamType = 0x81; // private |
| } |
| } |
| |
| if (fPCR_PID == 0) { // set it to this stream, if it's appropriate: |
| if ((!fHaveVideoStreams && (streamType == 3 || streamType == 4 || streamType == 6 || streamType == 0xF))/* audio stream */ || |
| (streamType == 1 || streamType == 2 || streamType == 0x10 || streamType == 0x1B || streamType == 0x24)/* video stream */) { |
| fPCR_PID = fCurrentPID; // use this stream's SCR for PCR |
| } |
| } |
| if (fCurrentPID == fPCR_PID) { |
| // Record the input's current SCR timestamp, for use as our PCR: |
| fPCR = scr; |
| } |
| } |
| |
| // Now that we have new input data, retry the last delivery to the client: |
| doGetNextFrame(); |
| } |
| |
| void MPEG2TransportStreamMultiplexor |
| ::deliverDataToClient(u_int16_t pid, unsigned char* buffer, unsigned bufferSize, |
| unsigned& startPositionInBuffer) { |
| // Construct a new Transport packet, and deliver it to the client: |
| if (fMaxSize < TRANSPORT_PACKET_SIZE) { |
| fFrameSize = 0; // the client hasn't given us enough space; deliver nothing |
| fNumTruncatedBytes = TRANSPORT_PACKET_SIZE; |
| } else { |
| fFrameSize = TRANSPORT_PACKET_SIZE; |
| Boolean willAddPCR = pid == fPCR_PID && startPositionInBuffer == 0 |
| && !(fPCR.highBit == 0 && fPCR.remainingBits == 0 && fPCR.extension == 0); |
| unsigned const numBytesAvailable = bufferSize - startPositionInBuffer; |
| unsigned numHeaderBytes = 4; // by default |
| unsigned numPCRBytes = 0; // by default |
| unsigned numPaddingBytes = 0; // by default |
| unsigned numDataBytes; |
| u_int8_t adaptation_field_control; |
| if (willAddPCR) { |
| adaptation_field_control = 0x30; |
| numHeaderBytes += 2; // for the "adaptation_field_length" and flags |
| numPCRBytes = 6; |
| if (numBytesAvailable >= TRANSPORT_PACKET_SIZE - numHeaderBytes - numPCRBytes) { |
| numDataBytes = TRANSPORT_PACKET_SIZE - numHeaderBytes - numPCRBytes; |
| } else { |
| numDataBytes = numBytesAvailable; |
| numPaddingBytes |
| = TRANSPORT_PACKET_SIZE - numHeaderBytes - numPCRBytes - numDataBytes; |
| } |
| } else if (numBytesAvailable >= TRANSPORT_PACKET_SIZE - numHeaderBytes) { |
| // This is the common case |
| adaptation_field_control = 0x10; |
| numDataBytes = TRANSPORT_PACKET_SIZE - numHeaderBytes; |
| } else { |
| adaptation_field_control = 0x30; |
| ++numHeaderBytes; // for the "adaptation_field_length" |
| // ASSERT: numBytesAvailable <= TRANSPORT_PACKET_SIZE - numHeaderBytes |
| numDataBytes = numBytesAvailable; |
| if (numDataBytes < TRANSPORT_PACKET_SIZE - numHeaderBytes) { |
| ++numHeaderBytes; // for the adaptation field flags |
| numPaddingBytes = TRANSPORT_PACKET_SIZE - numHeaderBytes - numDataBytes; |
| } |
| } |
| // ASSERT: numHeaderBytes+numPCRBytes+numPaddingBytes+numDataBytes |
| // == TRANSPORT_PACKET_SIZE |
| |
| // Fill in the header of the Transport Stream packet: |
| unsigned char* header = fTo; |
| *header++ = 0x47; // sync_byte |
| *header++ = ((startPositionInBuffer == 0) ? 0x40 : 0x00)|(pid>>8); |
| // transport_error_indicator, payload_unit_start_indicator, transport_priority, |
| // first 5 bits of PID |
| *header++ = pid; |
| // last 8 bits of PID |
| unsigned& continuity_counter = fPIDState[pid].counter; // alias |
| *header++ = adaptation_field_control|(continuity_counter&0x0F); |
| // transport_scrambling_control, adaptation_field_control, continuity_counter |
| ++continuity_counter; |
| if (adaptation_field_control == 0x30) { |
| // Add an adaptation field: |
| u_int8_t adaptation_field_length |
| = (numHeaderBytes == 5) ? 0 : 1 + numPCRBytes + numPaddingBytes; |
| *header++ = adaptation_field_length; |
| if (numHeaderBytes > 5) { |
| u_int8_t flags = willAddPCR ? 0x10 : 0x00; |
| if (fIsFirstAdaptationField) { |
| flags |= 0x80; // discontinuity_indicator |
| fIsFirstAdaptationField = False; |
| } |
| *header++ = flags; |
| if (willAddPCR) { |
| u_int32_t pcrHigh32Bits = (fPCR.highBit<<31) | (fPCR.remainingBits>>1); |
| u_int8_t pcrLowBit = fPCR.remainingBits&1; |
| u_int8_t extHighBit = (fPCR.extension&0x100)>>8; |
| *header++ = pcrHigh32Bits>>24; |
| *header++ = pcrHigh32Bits>>16; |
| *header++ = pcrHigh32Bits>>8; |
| *header++ = pcrHigh32Bits; |
| *header++ = (pcrLowBit<<7)|0x7E|extHighBit; |
| *header++ = (u_int8_t)fPCR.extension; // low 8 bits of extension |
| |
| if (fSegmentationDuration > 0) { |
| // Use the PCR to compute the duration of the segment so far, to check whether |
| // segmentation needs to occur now: |
| double pts = fPCR.highBit ? 0x80000000/45000.0 : 0.0; |
| pts += fPCR.remainingBits/90000.0; |
| pts += fPCR.extension/27000000.0; |
| |
| double lastSubSegmentDuration = fPreviousPTS == 0.0 ? 0.0 : pts - fPreviousPTS; |
| fCurrentSegmentDuration += lastSubSegmentDuration; |
| |
| // Check whether we need to segment the stream now: |
| if (fCurrentSegmentDuration > (double)fSegmentationDuration |
| || fCurrentSegmentDuration + lastSubSegmentDuration > (double)fSegmentationDuration) { |
| // It's time to segment the stream. |
| if (fOnEndOfSegmentFunc != NULL) { |
| (*fOnEndOfSegmentFunc)(fOnEndOfSegmentClientData, fCurrentSegmentDuration); |
| } |
| |
| fCurrentSegmentDuration = 0.0; // for next time |
| fSegmentationIndication = 1; // output a PAT next |
| } |
| |
| fPreviousPTS = pts; // for next time |
| } |
| } |
| } |
| } |
| |
| // Add any padding bytes: |
| for (unsigned i = 0; i < numPaddingBytes; ++i) *header++ = 0xFF; |
| |
| // Finally, add the data bytes: |
| memmove(header, &buffer[startPositionInBuffer], numDataBytes); |
| startPositionInBuffer += numDataBytes; |
| } |
| } |
| |
| #define PAT_PID 0 |
| #ifndef OUR_PROGRAM_NUMBER |
| #define OUR_PROGRAM_NUMBER 1 |
| #endif |
| #define OUR_PROGRAM_MAP_PID 0x1000 |
| |
| void MPEG2TransportStreamMultiplexor::deliverPATPacket() { |
| // First, create a new buffer for the PAT packet: |
| unsigned const patSize = TRANSPORT_PACKET_SIZE - 4; // allow for the 4-byte header |
| unsigned char* patBuffer = new unsigned char[patSize]; |
| |
| // and fill it in: |
| unsigned char* pat = patBuffer; |
| *pat++ = 0; // pointer_field |
| *pat++ = 0; // table_id |
| *pat++ = 0xB0; // section_syntax_indicator; 0; reserved, section_length (high) |
| *pat++ = 13; // section_length (low) |
| *pat++ = 0; *pat++ = 1; // transport_stream_id |
| *pat++ = 0xC1; // reserved; version_number; current_next_indicator |
| *pat++ = 0; // section_number |
| *pat++ = 0; // last_section_number |
| *pat++ = OUR_PROGRAM_NUMBER>>8; *pat++ = OUR_PROGRAM_NUMBER; // program_number |
| *pat++ = 0xE0|(OUR_PROGRAM_MAP_PID>>8); // reserved; program_map_PID (high) |
| *pat++ = OUR_PROGRAM_MAP_PID&0xFF; // program_map_PID (low) |
| |
| // Compute the CRC from the bytes we currently have (not including "pointer_field"): |
| u_int32_t crc = calculateCRC(patBuffer+1, pat - (patBuffer+1)); |
| *pat++ = crc>>24; *pat++ = crc>>16; *pat++ = crc>>8; *pat++ = crc; |
| |
| // Fill in the rest of the packet with padding bytes: |
| while (pat < &patBuffer[patSize]) *pat++ = 0xFF; |
| |
| // Deliver the packet: |
| unsigned startPosition = 0; |
| deliverDataToClient(PAT_PID, patBuffer, patSize, startPosition); |
| |
| // Finally, remove the new buffer: |
| delete[] patBuffer; |
| } |
| |
| void MPEG2TransportStreamMultiplexor::deliverPMTPacket(Boolean hasChanged) { |
| if (hasChanged) ++fProgramMapVersion; |
| |
| // First, create a new buffer for the PMT packet: |
| unsigned const pmtSize = TRANSPORT_PACKET_SIZE - 4; // allow for the 4-byte header |
| unsigned char* pmtBuffer = new unsigned char[pmtSize]; |
| |
| // and fill it in: |
| unsigned char* pmt = pmtBuffer; |
| *pmt++ = 0; // pointer_field |
| *pmt++ = 2; // table_id |
| *pmt++ = 0xB0; // section_syntax_indicator; 0; reserved, section_length (high) |
| unsigned char* section_lengthPtr = pmt; // save for later |
| *pmt++ = 0; // section_length (low) (fill in later) |
| *pmt++ = OUR_PROGRAM_NUMBER>>8; *pmt++ = OUR_PROGRAM_NUMBER; // program_number |
| *pmt++ = 0xC1|((fProgramMapVersion&0x1F)<<1); // reserved; version_number; current_next_indicator |
| *pmt++ = 0; // section_number |
| *pmt++ = 0; // last_section_number |
| *pmt++ = 0xE0|(fPCR_PID>>8); // reserved; PCR_PID (high) |
| *pmt++ = fPCR_PID; // PCR_PID (low) |
| *pmt++ = 0xF0; // reserved; program_info_length (high) |
| *pmt++ = 0; // program_info_length (low) |
| for (int pid = 0; pid < PID_TABLE_SIZE; ++pid) { |
| if (fPIDState[pid].streamType != 0) { |
| // This PID gets recorded in the table |
| *pmt++ = fPIDState[pid].streamType; |
| *pmt++ = 0xE0|(pid>>8); // reserved; elementary_pid (high) |
| *pmt++ = pid; // elementary_pid (low) |
| *pmt++ = 0xF0; // reserved; ES_info_length (high) |
| *pmt++ = 0; // ES_info_length (low) |
| } |
| } |
| unsigned section_length = pmt - (section_lengthPtr+1) + 4 /*for CRC*/; |
| *section_lengthPtr = section_length; |
| |
| // Compute the CRC from the bytes we currently have (not including "pointer_field"): |
| u_int32_t crc = calculateCRC(pmtBuffer+1, pmt - (pmtBuffer+1)); |
| *pmt++ = crc>>24; *pmt++ = crc>>16; *pmt++ = crc>>8; *pmt++ = crc; |
| |
| // Fill in the rest of the packet with padding bytes: |
| while (pmt < &pmtBuffer[pmtSize]) *pmt++ = 0xFF; |
| |
| // Deliver the packet: |
| unsigned startPosition = 0; |
| deliverDataToClient(OUR_PROGRAM_MAP_PID, pmtBuffer, pmtSize, startPosition); |
| |
| // Finally, remove the new buffer: |
| delete[] pmtBuffer; |
| } |
| |
| void MPEG2TransportStreamMultiplexor::setProgramStreamMap(unsigned frameSize) { |
| if (frameSize <= 16) return; // program_stream_map is too small to be useful |
| if (frameSize > 0xFF) return; // program_stream_map is too large |
| |
| u_int16_t program_stream_map_length = (fInputBuffer[4]<<8) | fInputBuffer[5]; |
| if ((u_int16_t)frameSize > 6+program_stream_map_length) { |
| frameSize = 6+program_stream_map_length; |
| } |
| |
| u_int8_t versionByte = fInputBuffer[6]; |
| if ((versionByte&0x80) == 0) return; // "current_next_indicator" is not set |
| fCurrentInputProgramMapVersion = versionByte&0x1F; |
| |
| u_int16_t program_stream_info_length = (fInputBuffer[8]<<8) | fInputBuffer[9]; |
| unsigned offset = 10 + program_stream_info_length; // skip over 'descriptors' |
| |
| u_int16_t elementary_stream_map_length |
| = (fInputBuffer[offset]<<8) | fInputBuffer[offset+1]; |
| offset += 2; |
| frameSize -= 4; // sizeof CRC_32 |
| if (frameSize > offset + elementary_stream_map_length) { |
| frameSize = offset + elementary_stream_map_length; |
| } |
| |
| while (offset + 4 <= frameSize) { |
| u_int8_t stream_type = fInputBuffer[offset]; |
| u_int8_t elementary_stream_id = fInputBuffer[offset+1]; |
| |
| fPIDState[elementary_stream_id].streamType = stream_type; |
| |
| u_int16_t elementary_stream_info_length |
| = (fInputBuffer[offset+2]<<8) | fInputBuffer[offset+3]; |
| offset += 4 + elementary_stream_info_length; |
| } |
| } |
| |
| static u_int32_t const CRC32[256] = { |
| 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, |
| 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, |
| 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, |
| 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, |
| 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, |
| 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, |
| 0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, |
| 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, |
| 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, |
| 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, |
| 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, |
| 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, |
| 0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, |
| 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, |
| 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, |
| 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, |
| 0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, |
| 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, |
| 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, |
| 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, |
| 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, |
| 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, |
| 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, |
| 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, |
| 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, |
| 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, |
| 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, |
| 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, |
| 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, |
| 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, |
| 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, |
| 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, |
| 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, |
| 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, |
| 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, |
| 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, |
| 0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, |
| 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, |
| 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, |
| 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, |
| 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, |
| 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, |
| 0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, |
| 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, |
| 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, |
| 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, |
| 0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, |
| 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, |
| 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, |
| 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, |
| 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, |
| 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, |
| 0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, |
| 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, |
| 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, |
| 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, |
| 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, |
| 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, |
| 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, |
| 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, |
| 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, |
| 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, |
| 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, |
| 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4 |
| }; |
| |
| u_int32_t calculateCRC(u_int8_t const* data, unsigned dataLength, u_int32_t initialValue) { |
| u_int32_t crc = initialValue; |
| |
| while (dataLength-- > 0) { |
| crc = (crc<<8) ^ CRC32[(crc>>24) ^ (u_int32_t)(*data++)]; |
| } |
| |
| return crc; |
| } |