// vaporization is split in two phases - this is phase 1 // PS packs are read into rbuf until a sequence header is found. // All video packs are unpacketized and the contained video ES // GOP copied to vibuf. In the same course the private stream 1 // and MPEG audio packs are inspected and the number of packs // not to be copied are counted. This is to forecast the video // vaporization factor in case the user specified a PS shrink factor. // returns GOP length in bytes int k9vamps::vap_phase1 (void) { uchar *ptr, *viptr = vibuf; int seq_length, id, data_length, opt_length, seqhdr; for (seq_length = 0; !lock (seq_length + SECT_SIZE); seq_length += SECT_SIZE) { ptr = rptr + seq_length; if (check_pack (ptr)) { ptr += 14; id = ptr [3]; } else { ptr += 14; id = 0; } // avoid duplicate counts for sequence headers if (seq_length) total_packs++; switch (id) { case 0xe0: // video seqhdr = check_video_packet (ptr); if (seq_length) { video_packs++; if (seqhdr) { sequence_headers++; vilen = viptr - vibuf; return seq_length; } } // copy contained video ES fragment to vibuf data_length = ptr [4] << 8; data_length |= ptr [5]; opt_length = 3 + ptr [8]; data_length -= opt_length; if ((viptr - vibuf) + data_length > vbuf_size - 3) { // reallocate video buffers int i = viptr - vibuf; // grow by another VBUF_SIZE bytes vbuf_size += VBUF_SIZE; uchar *tmp; tmp =new uchar[vbuf_size]; memcpy(tmp,vibuf,vbuf_size-VBUF_SIZE); delete[] vibuf; vibuf = tmp; // vibuf = (uchar*)realloc (vibuf, vbuf_size); tmp=new uchar[vbuf_size]; memcpy(tmp,vobuf,vbuf_size-VBUF_SIZE); delete[] vobuf; vobuf=tmp; // vobuf = (uchar*)realloc (vobuf, vbuf_size); if (vibuf == NULL || vobuf == NULL) fatal ("Reallocation of video buffers failed"); viptr = vibuf + i; } //fprintf (stderr, "data_length=%d\n", data_length); memcpy (viptr, ptr + 6 + opt_length, data_length); viptr += data_length; break; case 0xbd: // private 1: audio/subpicture aux_packs++; if (!new_private_1_type (ptr)) skipped_aux_packs++; break; case 0xc0: case 0xc1: case 0xc2: case 0xc3: case 0xc4: case 0xc5: case 0xc6: case 0xc7: // MPEG audio aux_packs++; if (!new_mpeg_audio_id (id)) skipped_aux_packs++; break; case 0xbb: // system header/private 2: PCI/DSI nav_packs++; break; case 0xbe: // padding skipped_aux_packs++; data_length = ptr [4] << 8; data_length |= ptr [5]; if (14 + data_length != SECT_SIZE - 6) fatal (QString("Bad padding packet length at %1: %2").arg(rtell (ptr)).arg(data_length)); break; default: // fatal("Encountered stream ID %02x at %llu, " // "probably bad MPEG2 program stream", id, rtell (ptr)); break; } } eof = 1; return seq_length; }
int main( int argc, char** argv, char** envp ) { std::vector< std::string > all_strings; std::vector< steemit::protocol::fixed_string_16 > all_fixed_string_16s; std::vector< std::vector< uint32_t > > sim_index; std::cout << "setting up LUT's" << std::endl; for( int len=0; len<=16; len++ ) { int b_max = 1 << len; size_t begin_offset = all_strings.size(); std::vector< uint32_t > hops; for( int b=0; b<b_max; b++ ) { uint32_t ub = uint32_t(b); if( popcount(ub) <= 3 ) hops.push_back( ub ); } for( int b=0; b<b_max; b++ ) { all_strings.emplace_back(len, '\0'); for( int i=0,m=1; i<len; i++,m+=m ) { all_strings.back()[len-i-1] = ((b&m)==0) ? 'a' : 'b'; } sim_index.emplace_back(); for( const uint32_t& h : hops ) { sim_index.back().push_back(begin_offset + (b^h)); } } } /* for( size_t i=0; i<all_strings.size(); i++ ) { std::cout << all_strings[i] << std::endl; for( const uint32_t& j : sim_index[i] ) std::cout << " " << all_strings[j] << std::endl; } */ std::cout << "checking conversions, size(), comparison operators" << std::endl; for( size_t i=0; i<all_strings.size(); i++ ) { const std::string& s = all_strings[i]; steemit::protocol::fixed_string_16 fs(s); std::string sfs = fs; if( s != fs ) { std::cout << "problem on " << s << std::endl; ++errors; } if( fs.size() != s.size() ) { std::cout << "problem on " << s << std::endl; ++errors; } check_variant( s, fs ); check_pack( s, fs ); for( const uint32_t& j : sim_index[i] ) { const std::string& t = all_strings[j]; steemit::protocol::fixed_string_16 ft(t); check( s, t, (s< t) == (fs< ft) ); check( s, t, (s<=t) == (fs<=ft) ); check( s, t, (s> t) == (fs> ft) ); check( s, t, (s>=t) == (fs>=ft) ); check( s, t, (s==t) == (fs==ft) ); check( s, t, (s!=t) == (fs!=ft) ); } } std::cout << "test_fixed_string_16 found " << errors << " errors" << std::endl; int result = (errors == 0) ? 0 : 1; errors = 0; all_strings = std::vector< std::string >(); std::vector< steemit::protocol::fixed_string_24 > all_fixed_string_24s; sim_index = std::vector< std::vector< uint32_t > >(); std::cout << "setting up LUT's" << std::endl; for( int len=0; len<=16; len++ ) { int b_max = 1 << len; size_t begin_offset = all_strings.size(); std::vector< uint32_t > hops; for( int b=0; b<b_max; b++ ) { uint32_t ub = uint32_t(b); if( popcount(ub) <= 3 ) hops.push_back( ub ); } for( int b=0; b<b_max; b++ ) { all_strings.emplace_back(len, '\0'); for( int i=0,m=1; i<len; i++,m+=m ) { all_strings.back()[len-i-1] = ((b&m)==0) ? 'a' : 'b'; } sim_index.emplace_back(); for( const uint32_t& h : hops ) { sim_index.back().push_back(begin_offset + (b^h)); } } } std::cout << "checking conversions, size(), comparison operators" << std::endl; for( size_t i=0; i<all_strings.size(); i++ ) { const std::string& s = all_strings[i]; steemit::protocol::fixed_string_24 fs(s); std::string sfs = fs; if( s != fs ) { std::cout << "problem on " << s << std::endl; ++errors; } if( fs.size() != s.size() ) { std::cout << "problem on " << s << std::endl; ++errors; } check_variant( s, fs ); check_pack( s, fs ); for( const uint32_t& j : sim_index[i] ) { const std::string& t = all_strings[j]; steemit::protocol::fixed_string_24 ft(t); check( s, t, (s< t) == (fs< ft) ); check( s, t, (s<=t) == (fs<=ft) ); check( s, t, (s> t) == (fs> ft) ); check( s, t, (s>=t) == (fs>=ft) ); check( s, t, (s==t) == (fs==ft) ); check( s, t, (s!=t) == (fs!=ft) ); } } std::cout << "test_fixed_string_24 found " << errors << " errors" << std::endl; result |= (errors == 0) ? 0 : 1; errors = 0; all_strings = std::vector< std::string >(); std::vector< steemit::protocol::fixed_string_32 > all_fixed_string_32s; sim_index = std::vector< std::vector< uint32_t > >(); std::cout << "setting up LUT's" << std::endl; for( int len=0; len<=16; len++ ) { int b_max = 1 << len; size_t begin_offset = all_strings.size(); std::vector< uint32_t > hops; for( int b=0; b<b_max; b++ ) { uint32_t ub = uint32_t(b); if( popcount(ub) <= 3 ) hops.push_back( ub ); } for( int b=0; b<b_max; b++ ) { all_strings.emplace_back(len, '\0'); for( int i=0,m=1; i<len; i++,m+=m ) { all_strings.back()[len-i-1] = ((b&m)==0) ? 'a' : 'b'; } sim_index.emplace_back(); for( const uint32_t& h : hops ) { sim_index.back().push_back(begin_offset + (b^h)); } } } std::cout << "checking conversions, size(), comparison operators" << std::endl; for( size_t i=0; i<all_strings.size(); i++ ) { const std::string& s = all_strings[i]; steemit::protocol::fixed_string_32 fs(s); std::string sfs = fs; if( s != fs ) { std::cout << "problem on " << s << std::endl; ++errors; } if( fs.size() != s.size() ) { std::cout << "problem on " << s << std::endl; ++errors; } check_variant( s, fs ); check_pack( s, fs ); for( const uint32_t& j : sim_index[i] ) { const std::string& t = all_strings[j]; steemit::protocol::fixed_string_32 ft(t); check( s, t, (s< t) == (fs< ft) ); check( s, t, (s<=t) == (fs<=ft) ); check( s, t, (s> t) == (fs> ft) ); check( s, t, (s>=t) == (fs>=ft) ); check( s, t, (s==t) == (fs==ft) ); check( s, t, (s!=t) == (fs!=ft) ); } } std::cout << "test_fixed_string_32 found " << errors << " errors" << std::endl; result |= (errors == 0) ? 0 : 1; return result; }
// process beginning of program stream up to // - but not including - first sequence header // this PS leader is NOT shrunk since the PS may not // necessarily begin at a GOP boundary (although it should?) // nevertheless the unwanted private stream 1 and MPEG audio // packs are skipped since some players could get confused otherwise void k9vamps::vap_leader () { uchar *ptr; int id, data_length; while (!lock (SECT_SIZE)) { ptr = rptr; if (check_pack (ptr)) { ptr += 14; id = ptr [3]; } else { ptr +=14; id = 0; } switch (id) { case 0xe0: // video if (check_video_packet (ptr)) // sequence header return; copy (SECT_SIZE); if (m_dvdbackup) m_dvdbackup->getOutput(k9DVDBackupInterface::VIDEO,0,ptr,SECT_SIZE); break; case 0xbd: // private 1: audio/subpicture copy_private_1 (ptr); break; case 0xc0: case 0xc1: case 0xc2: case 0xc3: case 0xc4: case 0xc5: case 0xc6: case 0xc7: // MPEG audio copy_mpeg_audio (ptr); break; case 0xbb: // system header/private 2: PCI/DSI copy (SECT_SIZE); if (m_dvdbackup) m_dvdbackup->getOutput(k9DVDBackupInterface::NAV,0,ptr,SECT_SIZE); break; case 0xbe: // padding data_length = ptr [4] << 8; data_length |= ptr [5]; if (14 + data_length != SECT_SIZE - 6) fatal (QString("Bad padding packet length at %1: %2").arg(rtell (ptr)).arg(data_length)); //JMP:à vérifier skip (SECT_SIZE); break; default: // fatal("Encountered stream ID %02x at %llu, " // "probably bad MPEG2 program stream", id, rtell (ptr)); copy (SECT_SIZE); } if (wptr == wbuf + WBUF_SIZE) flush (); } eof = 1; flush (); return; }
// Test program int main(void) { // Mapping the sending data address with application's data structure struct pack_data* data_send = (struct pack_data*)send_data; struct pack_data* data_recv = (struct pack_data*)recv_data; enum pack_recv_type_list check_result; // Command data U8 data[] = {'F'}; // Initialize the files for communication FILE* fd; fd = fopen(FILE_FOR_SEND, "w"); fclose(fd); fd = fopen(FILE_FOR_RECV, "w"); fclose(fd); U8 dest_addr; // Initialize protocol master_init_pack(100, 7000, send_bytes); // Bind a callback function to handle the interrupt signal // Press key 'Ctrl + C' will send a interrupt signal to the program signal(SIGINT, print_pack_count_info); // Master send package first data_send->cmd = 'E'; memcpy(data_send->cmd_data, data, sizeof(data)); master_send_pack(101, sizeof(data)+sizeof(struct pack_data)); // The loop will be broken when a interrupt signal received while (!get_signal_interrupt) { dest_addr = get_master_send_addr_last(); // When ack timeout, master will resend the last package and return // the resend times, if the warning value is reached, show messages if (master_check_ack_delay() > MASTER_MAX_RETRY_TIMES) { printf("The slave %d seems offline.\n", dest_addr); } // See if a package is arrived if (pack_recv()) { // Check validity of the received package check_result = check_pack(); if (check_result == PACK_RECV_NEW) { // Print the package printf("<Master Recv> dest: %d, src: %d, seqno: %d, len: %d, cmd: %c, data: %c\n", ((struct pack_header*)recv_buf)->dest, ((struct pack_header*)recv_buf)->src, ((struct pack_header*)recv_buf)->seqno, ((struct pack_header*)recv_buf)->len, data_recv->cmd, data_recv->cmd_data[0]); } if (dest_addr == 101) { dest_addr = 102; } else { dest_addr = 101; } // Master send package to salve data_send->cmd = 'E'; memcpy(data_send->cmd_data, data, sizeof(data)); master_send_pack(dest_addr, sizeof(data)+sizeof(struct pack_data)); } Sleep(2000); } return 0; }