hydrar/mistserver
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fixed Connector, Selection mechanism still missing

Browse source
This commit is contained in:
Erik Zandvliet 2012-06-11 20:51:07 +02:00 • committed by Thulinma
parent 102231103c
commit 45df1b72df
3 changed files with 168 additions and 347 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
lib/ts_packet.h
View file

@ -48,6 +48,15 @@ namespace TS {
char Buffer[188];///< The actual data char Buffer[188];///< The actual data
};//TS::Packet class };//TS::Packet class
static inline std::string GetAudioHeader( int FrameLen ) {
char StandardHeader[7] = {0xFF,0xF1,0x4C,0x80,0x00,0x1F,0xFC};
FrameLen += 7;
StandardHeader[3] = ( StandardHeader[3] & 0xFC ) + ( ( FrameLen & 0x00001800 ) >> 11 );
StandardHeader[4] = ( ( FrameLen & 0x000007F8 ) >> 3 );
StandardHeader[5] = ( StandardHeader[5] & 0x3F ) + ( ( FrameLen & 0x00000007 ) << 5 );
return std::string(StandardHeader,7);
}
static char PAT[188] = { static char PAT[188] = {
0x47,0x40,0x00,0x10, 0x00,0x00,0xB0,0x0D, 0x00,0x01,0xC1,0x00, 0x00,0x00,0x01,0xF0, 0x47,0x40,0x00,0x10, 0x00,0x00,0xB0,0x0D, 0x00,0x01,0xC1,0x00, 0x00,0x00,0x01,0xF0,
0x00,0x2A,0xB1,0x04, 0xB2,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF, 0x00,0x2A,0xB1,0x04, 0xB2,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF, 0xFF,0xFF,0xFF,0xFF,

425
src/conn_ts.cpp
View file

@ -19,296 +19,28 @@
#include <sys/epoll.h> #include <sys/epoll.h>
#include "../lib/socket.h" #include "../lib/socket.h"
#include "../lib/dtsc.h" #include "../lib/dtsc.h"
#include "../lib/ts_packet.h"
/// A simple class to create a single Transport Packet
class Transport_Packet {
public:
Transport_Packet( bool PacketStart = false, int PID = 0x100 );
void SetPayload( char * Payload, int PayloadLen, int Offset = 13 );
void SetPesHeader( int Offset = 4, int MsgLen = 0xFFFF, int Current = 0, int Previous = 0 );
void Write( );
void Write( Socket::Connection conn );
void SetContinuityCounter( int Counter );
void SetMessageLength( int MsgLen );
void SetAdaptationField( double TimeStamp = 0 );
void CreatePAT( int ContinuityCounter );
void CreatePMT( int ContinuityCounter );
private:
int PID;///< PID of this packet
char Buffer[188];///< The actual data
};//Transport Packet
/// Get the current time in milliseconds
/// \return Current time in milliseconds
unsigned int getNowMS() {
timeval t;
gettimeofday(&t, 0);
return t.tv_sec + t.tv_usec/1000;
}
/// The constructor
/// \param PacketStart Start of a new sequence
/// \param PID The PID for this packet
Transport_Packet::Transport_Packet( bool PacketStart, int PID ) {
(*this).PID = PID;
Buffer[0] = (char)0x47;
Buffer[1] = ( PacketStart ? (char)0x40 : 0 ) + (( PID & 0xFF00 ) >> 8 );
Buffer[2] = ( PID & 0x00FF );
Buffer[3] = (char)0x10;
}
/// Sets the length of the message
/// \param MsgLen the new length of the message
void Transport_Packet::SetMessageLength( int MsgLen ) {
Buffer[8] = ( MsgLen & 0xFF00 ) >> 8;
Buffer[9] = ( MsgLen & 0xFF );
}
/// Sets the Continuity Counter of a packet
/// \param Counter The new Continuity Counter
void Transport_Packet::SetContinuityCounter( int Counter ) {
Buffer[3] = ( Buffer[3] & 0xF0 ) + ( Counter & 0x0F );
}
/// Writes a PES header with length and PTS/DTS
/// \param Offset Offset of the PES header in the packet
/// \param MsgLen Length of the PES data
/// \param Current The PTS of this PES packet
/// \param Previous The DTS of this PES packet
void Transport_Packet::SetPesHeader( int Offset, int MsgLen, int Current, int Previous ) {
Current = Current * 27000;
Previous = Previous * 27000;
Buffer[Offset] = (char)0x00;
Buffer[Offset+1] = (char)0x00;
Buffer[Offset+2] = (char)0x01;
Buffer[Offset+3] = (char)0xE0;
Buffer[Offset+4] = ( MsgLen & 0xFF00 ) >> 8;
Buffer[Offset+5] = ( MsgLen & 0x00FF );
Buffer[Offset+6] = (char)0x80;
Buffer[Offset+7] = (char)0xC0;
Buffer[Offset+8] = (char)0x0A;
Buffer[Offset+9] = (char)0x30 + ( (Current & 0xC0000000 ) >> 29 ) + (char)0x01;
Buffer[Offset+10] = ( ( ( Current & 0x3FFF8000 ) >> 14 ) & 0xFF00 ) >> 8;
Buffer[Offset+11] = ( ( ( Current & 0x3FFF8000 ) >> 14 ) & 0x00FF ) + (char)0x01;
Buffer[Offset+12] = ( ( ( Current & 0x00007FFF ) << 1 ) & 0xFF00 ) >> 8;
Buffer[Offset+13] = ( ( ( Current & 0x00007FFF ) << 1 ) & 0x00FF ) + (char)0x01;
Buffer[Offset+14] = (char)0x10 + ( (Previous & 0xC0000000 ) >> 29 ) + (char)0x01;
Buffer[Offset+15] = ( ( ( Previous & 0x3FFF8000 ) >> 14 ) & 0xFF00 ) >> 8;
Buffer[Offset+16] = ( ( ( Previous & 0x3FFF8000 ) >> 14 ) & 0x00FF ) + (char)0x01;
Buffer[Offset+17] = ( ( ( Previous & 0x00007FFF ) << 1 ) & 0xFF00 ) >> 8;
Buffer[Offset+18] = ( ( ( Previous & 0x00007FFF ) << 1 ) & 0x00FF ) + (char)0x01;
}
/// Creates an adapatation field
/// \param TimeStamp the current PCR
void Transport_Packet::SetAdaptationField( double TimeStamp ) {
TimeStamp = TimeStamp * 27000;
int Extension = (int)TimeStamp % 300;
int Base = (int)TimeStamp / 300;
Buffer[3] = ( Buffer[3] & 0x0F ) + 0x30;
Buffer[4] = (char)0x07;
Buffer[5] = (char)0x10;
Buffer[6] = ( ( Base >> 1 ) & 0xFF000000 ) >> 24;
Buffer[7] = ( ( Base >> 1 ) & 0x00FF0000 ) >> 16;
Buffer[8] = ( ( Base >> 1 ) & 0x0000FF00 ) >> 8;
Buffer[9] = ( ( Base >> 1 ) & 0x000000FF );
Buffer[10] = ( ( Extension & 0x0100) >> 8 ) + ( ( Base & 0x00000001 ) << 7 ) + (char)0x7E;
Buffer[11] = ( Extension & 0x00FF);
}
/// Writes data into the payload of our packet
/// The data to be written is of lenght min( PayLoadLen, 188 - Offset )
/// \param Payload The data to write
/// \param PayLoadLen The length of the data
/// \param Offset The offset in the packet payload
void Transport_Packet::SetPayload( char * Payload, int PayloadLen, int Offset ) {
memcpy( &Buffer[Offset], Payload, std::min( PayloadLen, 188-Offset ) );
}
/// Creates a default PAT packet
/// Sets up the complete packet
/// \param ContinuityCounter The Continuity Counter for this packet
void Transport_Packet::CreatePAT( int ContinuityCounter ) {
Buffer[3] = (char)0x10 + ContinuityCounter;
Buffer[4] = (char)0x00;
Buffer[5] = (char)0x00;
Buffer[6] = (char)0xB0;
Buffer[7] = (char)0x0D;
Buffer[8] = (char)0x00;
Buffer[9] = (char)0x01;
Buffer[10] = (char)0xC1;
Buffer[11] = (char)0x00;
Buffer[12] = (char)0x00;
Buffer[13] = (char)0x00;
Buffer[14] = (char)0x01;
Buffer[15] = (char)0xF0;
Buffer[16] = (char)0x00;
Buffer[17] = (char)0x2A;
Buffer[18] = (char)0xB1;
Buffer[19] = (char)0x04;
Buffer[20] = (char)0xB2;
for(int i = 21; i < 188; i++ ) {
Buffer[i] = (char)0xFF;
}
}
/// Creates a default PMT packet
/// Sets up the complete packet
/// \param ContinuityCounter The Continuity Counter for this packet
void Transport_Packet::CreatePMT( int ContinuityCounter ) {
Buffer[3] = (char)0x10 + ContinuityCounter;
Buffer[4] = (char)0x00;
Buffer[5] = (char)0x02;
Buffer[6] = (char)0xB0;
Buffer[7] = (char)0x17;
Buffer[8] = (char)0x00;
Buffer[9] = (char)0x01;
Buffer[10] = (char)0xC1;
Buffer[11] = (char)0x00;
Buffer[12] = (char)0x00;
Buffer[13] = (char)0xE1;
Buffer[14] = (char)0x00;
Buffer[15] = (char)0xF0;
Buffer[16] = (char)0x00;
Buffer[17] = (char)0x1B;
Buffer[18] = (char)0xE1;
Buffer[19] = (char)0x00;
Buffer[20] = (char)0xF0;
Buffer[21] = (char)0x00;
Buffer[22] = (char)0x03;
Buffer[23] = (char)0xE1;
Buffer[24] = (char)0x01;
Buffer[25] = (char)0xF0;
Buffer[26] = (char)0x00;
Buffer[27] = (char)0x4E;
Buffer[28] = (char)0x59;
Buffer[29] = (char)0x3D;
Buffer[30] = (char)0x1E;
for(int i = 31; i < 188; i++ ) {
Buffer[i] = (char)0xFF;
}
}
/// Sends a default PAT
/// \param conn The connection with the client
void SendPAT( Socket::Connection conn ) {
static int ContinuityCounter = 0;
Transport_Packet TS;
TS = Transport_Packet( true, 0 );
TS.CreatePAT( ContinuityCounter );
TS.Write( conn );
ContinuityCounter = ( ContinuityCounter + 1 ) & 0x0F;
}
/// Sends a default PMT
/// \param conn The connection with the client
void SendPMT( Socket::Connection conn ) {
static int ContinuityCounter = 0;
Transport_Packet TS;
TS = Transport_Packet( true, 0x1000 );
TS.CreatePMT( ContinuityCounter );
TS.Write( conn );
ContinuityCounter = ( ContinuityCounter + 1 ) & 0x0F;
}
/// Wraps one or more NALU packets into transport packets
/// \param tag The FLV Tag
std::vector<Transport_Packet> WrapNalus( DTSC::DTMI Tag ) {
static int ContinuityCounter = 0;
static int Previous_Tag = 0;
static int First_PCR = getNowMS();
static int Previous_PCR = 0;
static char LeadIn[4] = { (char)0x00, (char)0x00, (char)0x00, (char)0x001 };
int Current_PCR;
int Current_Tag;
std::string Data = Tag.getContentP("data")->StrValue();
int Offset = 0;
Transport_Packet TS;
int Sent = 0;
int PacketAmount = ceil( ( ( Data.size() - (188 - 35 ) ) / 184 ) + 1 );//Minus first packet, + round up and first packet.
std::vector<Transport_Packet> Result;
TS = Transport_Packet( true, 0x100 );
TS.SetContinuityCounter( ContinuityCounter );
ContinuityCounter = ( ( ContinuityCounter + 1 ) & 0x0F );
Current_PCR = getNowMS();
Current_Tag = Tag.getContentP("time")->NumValue();
if( true ) { //Current_PCR - Previous_PCR >= 1 ) {
TS.SetAdaptationField( Current_PCR - First_PCR );
Offset = 8;
Previous_PCR = Current_PCR;
}
TS.SetPesHeader( 4 + Offset, Data.size() , Current_Tag, Previous_Tag );
Previous_Tag = Current_Tag;
TS.SetPayload( LeadIn, 4, 23 + Offset );
TS.SetPayload( &Data[16], 157 - Offset, 27 + Offset );
Sent = 157 - Offset;
Result.push_back( TS );
while( Sent + 176 < Data.size() ) {
// for( int i = 0; i < (PacketAmount - 1); i++ ) {
TS = Transport_Packet( false, 0x100 );
TS.SetContinuityCounter( ContinuityCounter );
ContinuityCounter = ( ( ContinuityCounter + 1 ) & 0x0F );
Current_PCR = getNowMS();
Offset = 0;
if( true ) { //Current_PCR - Previous_PCR >= 1 ) {
TS.SetAdaptationField( Current_PCR - First_PCR );
Offset = 8;
Previous_PCR = Current_PCR;
}
TS.SetPayload( &Data[16 + Sent], 184 - Offset, 4 + Offset );
Sent += 184 - Offset;
Result.push_back( TS );
}
if( Sent < ( Data.size() ) ) {
Current_PCR = getNowMS();
Offset = 0;
if( true ) { //now - Previous_PCR >= 5 ) {
TS.SetAdaptationField( Current_PCR - First_PCR );
Offset = 8;
Previous_PCR = Current_PCR;
}
std::cerr << "Wrapping packet: last packet length\n";
std::cerr << "\tTotal:\t\t" << Data.size() << "\n";
std::cerr << "\tSent:\t\t" << Sent << "\n";
int To_Send = ( Data.size() ) - Sent;
std::cerr << "\tTo Send:\t" << To_Send << "\n";
std::cerr << "\tStuffing:\t" << 176 - To_Send << "\n";
char Stuffing = (char)0xFF;
for( int i = 0; i < ( 176 - To_Send ); i++ ) {
TS.SetPayload( &Stuffing, 1, 4 + Offset + i );
}
TS.SetPayload( &Data[16 + Sent], 176 - To_Send , 4 + Offset + ( 176 - To_Send ) );
Result.push_back( TS );
}
return Result;
}
/// Writes a packet to STDOUT
void Transport_Packet::Write( ) {
for( int i = 0; i < 188; i++ ) { std::cout << Buffer[i]; }
}
/// Writes a packet onto a connection
/// \param conn The connection with the client
void Transport_Packet::Write( Socket::Connection conn ) {
// conn.write( Buffer, 188 );
for( int i = 0; i < 188; i++ ) { std::cout << Buffer[i]; }
}
/// The main function of the connector /// The main function of the connector
/// \param conn A connection with the client /// \param conn A connection with the client
int TS_Handler( Socket::Connection conn ) { int TS_Handler( Socket::Connection conn ) {
DTSC::Stream stream; std::string ToPack;
// FLV::Tag tag;///< Temporary tag buffer for incoming video data. std::string DTMIData;
TS::Packet PackData;
DTSC::Stream DTSCStream;
int PacketNumber = 0;
uint64_t TimeStamp = 0;
int ThisNaluSize;
char VideoCounter = 0;
char AudioCounter = 0;
bool WritePesHeader;
bool IsKeyFrame;
bool FirstKeyFrame = true;
bool FirstIDRInKeyFrame;
bool inited = false; bool inited = false;
bool firstvideo = true; Socket::Connection ss;
Socket::Connection ss(-1);
int zet = 0;
while(conn.connected()) {// && !FLV::Parse_Error) { while(conn.connected()) {// && !FLV::Parse_Error) {
if( !inited ) { if( !inited ) {
ss = Socket::Connection("/tmp/shared_socket_fifa"); ss = Socket::Connection("/tmp/shared_socket_fifa");
@ -335,21 +67,118 @@ int TS_Handler( Socket::Connection conn ) {
case 0: break;//not ready yet case 0: break;//not ready yet
default: default:
ss.spool(); ss.spool();
if ( stream.parsePacket( conn.Received() ) ) { if ( DTSCStream.parsePacket( conn.Received() ) ) {
if( stream.lastType() == DTSC::VIDEO ) { if( DTSCStream.lastType() == DTSC::VIDEO ) {
fprintf(stderr, "Video contains NALU\n" ); DTMIData = DTSCStream.lastData();
SendPAT( conn ); if( DTSCStream.getPacket(0).getContent("keyframe").NumValue() ) {
SendPMT( conn ); IsKeyFrame = true;
std::vector<Transport_Packet> AllNalus = WrapNalus( stream.getPacket(0) ); FirstIDRInKeyFrame = true;
for( int i = 0; i < AllNalus.size( ); i++ ) { } else {
AllNalus[i].Write( conn ); IsKeyFrame = false;
FirstKeyFrame = false;
}
TimeStamp = (DTSCStream.getPacket(0).getContent("time").NumValue() * 27000 );
int TSType;
bool FirstPic = true;
while( DTMIData.size() ) {
ThisNaluSize = (DTMIData[0] << 24) + (DTMIData[1] << 16) +
(DTMIData[2] << 8) + DTMIData[3];
DTMIData.erase(0,4);//Erase the first four characters;
TSType = (int)DTMIData[0];
if( TSType == 0x25 ) {
if( FirstPic ) {
ToPack.append(TS::PPS,24);
ToPack.append(TS::SPS,8);
FirstPic = false;
}
if( IsKeyFrame ) {
if( !FirstKeyFrame && FirstIDRInKeyFrame ) {
ToPack.append(TS::NalHeader,4);
FirstIDRInKeyFrame = false;
} else {
ToPack.append(TS::ShortNalHeader,3);
}
}
} else if ( TSType == 0x21 ) {
if( FirstPic ) {
ToPack.append(TS::NalHeader,4);
FirstPic = false;
} else {
ToPack.append(TS::ShortNalHeader,3);
}
} else {
ToPack.append(TS::NalHeader,4);
} }
std::cerr << "Item: " << ++zet << "\n"; ToPack.append(DTMIData,0,ThisNaluSize);
DTMIData.erase(0,ThisNaluSize);
}
WritePesHeader = true;
while( ToPack.size() ) {
if ( ( PacketNumber % 42 ) == 0 ) {
PackData.DefaultPAT();
PackData.ToString();
} else if ( ( PacketNumber % 42 ) == 1 ) {
PackData.DefaultPMT();
PackData.ToString();
} else {
PackData.Clear();
PackData.PID( 0x100 );
PackData.ContinuityCounter( VideoCounter );
VideoCounter ++;
if( WritePesHeader ) {
PackData.UnitStart( 1 );
if( IsKeyFrame ) {
PackData.RandomAccess( 1 );
PackData.PCR( TimeStamp );
} else {
PackData.AdaptationField( 0x01 );
}
PackData.AddStuffing( 184 - (20+ToPack.size()) );
PackData.PESVideoLeadIn( ToPack.size() );
WritePesHeader = false;
} else {
PackData.AdaptationField( 0x01 );
PackData.AddStuffing( 184 - (ToPack.size()) );
}
PackData.FillFree( ToPack );
PackData.ToString();
}
PacketNumber ++;
}
} }
if( stream.lastType() == DTSC::AUDIO ) { if( DTSCStream.lastType() == DTSC::AUDIO ) {
// if( ( tag.data[ 11 ] == 0xAF ) && ( tag.data[ 12 ] == 0x01 ) ) { WritePesHeader = true;
fprintf(stderr, "Audio Contains Raw AAC\n"); DTMIData = DTSCStream.lastData();
// } ToPack = TS::GetAudioHeader( DTMIData.size() );
ToPack += DTMIData;
TimeStamp = DTSCStream.getPacket(0).getContent("time").NumValue() * 900;
while( ToPack.size() ) {
if ( ( PacketNumber % 42 ) == 0 ) {
PackData.DefaultPAT();
PackData.ToString();
} else if ( ( PacketNumber % 42 ) == 1 ) {
PackData.DefaultPMT();
PackData.ToString();
} else {
PackData.Clear();
PackData.PID( 0x101 );
PackData.ContinuityCounter( AudioCounter );
AudioCounter ++;
if( WritePesHeader ) {
PackData.UnitStart( 1 );
PackData.RandomAccess( 1 );
PackData.AddStuffing( 184 - (14 + ToPack.size()) );
PackData.PESAudioLeadIn( ToPack.size(), TimeStamp );
WritePesHeader = false;
} else {
PackData.AdaptationField( 0x01 );
PackData.AddStuffing( 184 - (ToPack.size()) );
}
PackData.FillFree( ToPack );
PackData.ToString();
}
PacketNumber ++;
}
} }
} }
break; break;

81
src/converters/dtsc2ts.cpp
View file

@ -10,30 +10,21 @@
#include "../../lib/ts_packet.h" //TS support #include "../../lib/ts_packet.h" //TS support
#include "../../lib/dtsc.h" //DTSC support #include "../../lib/dtsc.h" //DTSC support
std::string GetAudioHeader( int FrameLen ) {
char StandardHeader[7] = {0xFF,0xF1,0x4C,0x80,0x00,0x1F,0xFC};
FrameLen += 7;
StandardHeader[3] = ( StandardHeader[3] & 0xFC ) + ( ( FrameLen & 0x00001800 ) >> 11 );
StandardHeader[4] = ( ( FrameLen & 0x000007F8 ) >> 3 );
StandardHeader[5] = ( StandardHeader[5] & 0x3F ) + ( ( FrameLen & 0x00000007 ) << 5 );
return std::string(StandardHeader,7);
}
int main( ) { int main( ) {
char charBuffer[1024*10]; char charBuffer[1024*10];
unsigned int charCount; unsigned int charCount;
std::string StrData; std::string StrData;
TS::Packet PackData;
std::string ToPack; std::string ToPack;
DTSC::Stream DTSCStream;
int TSPackNum = 0;
std::string DTMIData; std::string DTMIData;
bool WritePesHeader; TS::Packet PackData;
bool IsKeyFrame; DTSC::Stream DTSCStream;
int PacketNumber = 0;
uint64_t TimeStamp = 0; uint64_t TimeStamp = 0;
int ThisNaluSize; int ThisNaluSize;
int VidContinuity = 0; char VideoCounter = 0;
int AudioContinuity = 0; char AudioCounter = 0;
bool WritePesHeader;
bool IsKeyFrame;
bool FirstKeyFrame = true; bool FirstKeyFrame = true;
bool FirstIDRInKeyFrame; bool FirstIDRInKeyFrame;
while( std::cin.good() ) { while( std::cin.good() ) {
@ -54,7 +45,8 @@ int main( ) {
int TSType; int TSType;
bool FirstPic = true; bool FirstPic = true;
while( DTMIData.size() ) { while( DTMIData.size() ) {
ThisNaluSize = (DTMIData[0] << 24) + (DTMIData[1] << 16) + (DTMIData[2] << 8) + DTMIData[3]; ThisNaluSize = (DTMIData[0] << 24) + (DTMIData[1] << 16) +
(DTMIData[2] << 8) + DTMIData[3];
DTMIData.erase(0,4);//Erase the first four characters; DTMIData.erase(0,4);//Erase the first four characters;
TSType = (int)DTMIData[0]; TSType = (int)DTMIData[0];
if( TSType == 0x25 ) { if( TSType == 0x25 ) {
@ -86,21 +78,17 @@ int main( ) {
} }
WritePesHeader = true; WritePesHeader = true;
while( ToPack.size() ) { while( ToPack.size() ) {
if ( ( TSPackNum % 210 ) == 0 ) { if ( ( PacketNumber % 42 ) == 0 ) {
PackData.FFMpegHeader();
PackData.ToString();
}
if ( ( TSPackNum % 42 ) == 0 ) {
PackData.DefaultPAT(); PackData.DefaultPAT();
PackData.ToString(); PackData.ToString();
} else if ( ( TSPackNum % 42 ) == 1 ) { } else if ( ( PacketNumber % 42 ) == 1 ) {
PackData.DefaultPMT(); PackData.DefaultPMT();
PackData.ToString(); PackData.ToString();
} else { } else {
PackData.Clear(); PackData.Clear();
PackData.PID( 0x100 ); PackData.PID( 0x100 );
PackData.ContinuityCounter( VidContinuity ); PackData.ContinuityCounter( VideoCounter );
VidContinuity ++; VideoCounter ++;
if( WritePesHeader ) { if( WritePesHeader ) {
PackData.UnitStart( 1 ); PackData.UnitStart( 1 );
if( IsKeyFrame ) { if( IsKeyFrame ) {
@ -114,36 +102,31 @@ int main( ) {
WritePesHeader = false; WritePesHeader = false;
} else { } else {
PackData.AdaptationField( 0x01 ); PackData.AdaptationField( 0x01 );
PackData.AddStuffing( 184 - (ToPack.size()) ); PackData.AddStuffing( 184 - (ToPack.size()) );
} }
PackData.FillFree( ToPack ); PackData.FillFree( ToPack );
PackData.ToString(); PackData.ToString();
} }
TSPackNum++; PacketNumber ++;
} }
} else if( DTSCStream.lastType() == DTSC::AUDIO ) { } else if( DTSCStream.lastType() == DTSC::AUDIO ) {
WritePesHeader = true; WritePesHeader = true;
DTMIData = DTSCStream.lastData(); DTMIData = DTSCStream.lastData();
ToPack = GetAudioHeader( DTMIData.size() ); ToPack = TS::GetAudioHeader( DTMIData.size() );
ToPack += DTMIData; ToPack += DTMIData;
TimeStamp = DTSCStream.getPacket(0).getContent("time").NumValue() * 900; TimeStamp = DTSCStream.getPacket(0).getContent("time").NumValue() * 900;
PackData.Clear(); while( ToPack.size() ) {
while( ToPack.size() ) { if ( ( PacketNumber % 42 ) == 0 ) {
if ( ( TSPackNum % 210 ) == 0 ) {
PackData.FFMpegHeader();
PackData.ToString();
}
if ( ( TSPackNum % 42 ) == 0 ) {
PackData.DefaultPAT(); PackData.DefaultPAT();
PackData.ToString(); PackData.ToString();
} else if ( ( TSPackNum % 42 ) == 1 ) { } else if ( ( PacketNumber % 42 ) == 1 ) {
PackData.DefaultPMT(); PackData.DefaultPMT();
PackData.ToString(); PackData.ToString();
} else { } else {
PackData.Clear(); PackData.Clear();
PackData.PID( 0x101 ); PackData.PID( 0x101 );
PackData.ContinuityCounter( AudioContinuity ); PackData.ContinuityCounter( AudioCounter );
AudioContinuity ++; AudioCounter ++;
if( WritePesHeader ) { if( WritePesHeader ) {
PackData.UnitStart( 1 ); PackData.UnitStart( 1 );
PackData.RandomAccess( 1 ); PackData.RandomAccess( 1 );
@ -152,14 +135,14 @@ int main( ) {
WritePesHeader = false; WritePesHeader = false;
} else { } else {
PackData.AdaptationField( 0x01 ); PackData.AdaptationField( 0x01 );
PackData.AddStuffing( 184 - (ToPack.size()) ); PackData.AddStuffing( 184 - (ToPack.size()) );
} }
PackData.FillFree( ToPack ); PackData.FillFree( ToPack );
PackData.ToString(); PackData.ToString();
} }
TSPackNum++; PacketNumber ++;
} }
} }
} }
} }
return 0; return 0;