inline void
invoke_reuse_helper(Encoder encoder, Decoder decoder)
{
std::vector<uint8_t> payload(encoder->payload_size());
std::vector<uint8_t> data_in = random_vector(encoder->block_size());
sak::mutable_storage storage_in = sak::storage(data_in);
encoder->set_symbols(storage_in);
// Set the encoder non-systematic
if(kodo::is_systematic_encoder(encoder))
kodo::set_systematic_off(encoder);
while( !decoder->is_complete() )
{
uint32_t payload_used = encoder->encode( &payload[0] );
EXPECT_TRUE(payload_used <= encoder->payload_size());
decoder->decode( &payload[0] );
}
std::vector<uint8_t> data_out(decoder->block_size(), '\0');
decoder->copy_symbols(sak::storage(data_out));
EXPECT_TRUE(std::equal(data_out.begin(),
data_out.end(),
data_in.begin()));
}
int x265_encoder_encode(x265_encoder *enc, x265_nal **pp_nal, uint32_t *pi_nal, x265_picture *pic_in, x265_picture *pic_out)
{
if (!enc)
return -1;
Encoder *encoder = static_cast<Encoder*>(enc);
int numEncoded;
// While flushing, we cannot return 0 until the entire stream is flushed
do
{
numEncoded = encoder->encode(pic_in, pic_out);
}
while (numEncoded == 0 && !pic_in && encoder->m_numDelayedPic);
// do not allow reuse of these buffers for more than one picture. The
// encoder now owns these analysisData buffers.
if (pic_in)
{
pic_in->analysisData.intraData = NULL;
pic_in->analysisData.interData = NULL;
}
if (pp_nal && numEncoded > 0)
{
*pp_nal = &encoder->m_nalList.m_nal[0];
if (pi_nal) *pi_nal = encoder->m_nalList.m_numNal;
}
else if (pi_nal)
*pi_nal = 0;
return numEncoded;
}
/**
* Writes a description of the graph to the given stream, using the Dot
* language.
* The method allows for both directed graphs and non-directed graphs, the
* latter are required for drawing purposes (since Dot will not produce the
* arrow heads and the splines terminate before reaching the nodes).
* @param str The stream to write to
* @param sType Either "graph" or "digraph"
* @param sEdge The edge connector ("--" or "->")
* @param bWriteCall true to write call information, false otherwise
*/
void GraphWidget::write(QTextStream& str, const QString& sType,
const QString& sEdge, bool bWriteCall)
{
QFont font;
QDictIterator<GraphNode> itr(m_dictNodes);
GraphEdge* pEdge;
Encoder enc;
font = Config().getFont(KScopeConfig::Graph);
// Header
str << sType << " G {\n";
// Graph attributes
str << "\tgraph [rankdir=" << Config().getGraphOrientation() << ", "
<< "kscope_zoom=" << m_dZoom
<< "];\n";
// Default node attributes
str << "\tnode [shape=box, height=\"0.01\", style=filled, "
<< "fillcolor=\"" << Config().getColor(KScopeConfig::GraphNode).name()
<< "\", "
<< "fontcolor=\"" << Config().getColor(KScopeConfig::GraphText).name()
<< "\", "
<< "fontname=\"" << font.family() << "\", "
<< "fontsize=" << QString::number(font.pointSize())
<< "];\n";
// Iterate over all nodes
for (; itr.current(); ++itr) {
// Write a node
str << "\t" << itr.current()->getFunc() << ";\n";
// Iterate over all edges leaving this node
QDictIterator<GraphEdge> itrEdge(itr.current()->getOutEdges());
for (; itrEdge.current(); ++itrEdge) {
pEdge = itrEdge.current();
str << "\t" << pEdge->getHead()->getFunc() << sEdge
<< pEdge->getTail()->getFunc();
// Write call information
if (bWriteCall) {
str << " ["
<< "kscope_file=\"" << pEdge->getFile() << "\","
<< "kscope_line=" << pEdge->getLine() << ","
<< "kscope_text=\"" << enc.encode(pEdge->getText()) << "\""
<< "]";
}
str << ";\n";
}
}
// Close the graph
str << "}\n";
}
/**
* \brief Encode to XDQP stream
*/
void encode(Encoder& e, Reporter& reporter) {
try {
// TODO consider gzip compression at this top level, and using a std::ostringstream to collate values (optional setting at aggregate level)
// no need to encode resultTypeRef as that's handled in the start() or clone() function
// do need to encode count though
e.encode((int)interimValues.size());
for (auto ivi = interimValues.begin();ivi != interimValues.end();++ivi) {
ivi->second->encode(e,reporter);
}
} catch (std::exception& ex) {
reporter.error(("Exception in encode(): " + std::string(ex.what())).c_str());
}
}
/**
* Recursively writes tree items to a file.
* Given an item, the method writes this item and all of its siblings.
* Child items are written recursively.
* @param pItem The first item to write
* @param str An initialised text stream to use for writing
* @param enc An encoder for free-text strings
*/
void TreeWidget::saveItems(QListViewItem* pItem, QTextStream& str, Encoder& enc)
{
// Iterate over all items in this level
for (; pItem != NULL; pItem = pItem->nextSibling()) {
// Write function parameters
str << pItem->text(0) << " [ "
<< "kscope_file=\"" << pItem->text(1) << "\", "
<< "kscope_line=" << pItem->text(2) << ", "
<< "kscope_text=\"" << enc.encode(pItem->text(3)) << "\""
<< "]" << endl;
// Write child items
str << "{" << endl;
saveItems(pItem->firstChild(), str, enc);
str << "}" << endl;
}
}
/**
* Does the real encoding of the instructions
*/
void Assembler::encode(string outputFile){
ofstream output(outputFile);
string binInst;
for(size_t i=0;i<instructions.size();i++){
string inst = instructions[i];
for(size_t j=0;j<dictionary.size();j++){
Encoder e = dictionary[j];
if(e.match(inst)){
binInst=e.encode(inst,i,labels);
output<<binInst<<endl;
binInstructions.push_back(binInst);
}
}
}
output.close();
// cout<<"Output succesfully written to "<< endl << outputFile;
}
int main(int argc, char ** argv)
{
// Get the command arguments
Command command(argc, argv);
// Check no. of mandatory arguments (2)
if(command.size() < 2)
{
cerr << "sample: Must specify 2 filenames: data, scaled data"
<< endl;
return 1;
}
table<double> data;
ifstream fin(command.arg(0).c_str(), ios::in);
fin >> data;
fin.close();
Encoder * encoder;
if(command.find("-s") != command.end())
{
double a = 0.0;
if(command.find("-a") != command.end())
command.get("-a", a);
double b = 0.0;
if(command.find("-b") != command.end())
command.get("-b", b);
encoder = new Scaler(data, a, b);
}
else
{
encoder = new Standardiser(data);
}
encoder->encode(data);
ofstream fout(command.arg(1).c_str(), ios::out);
fout << data << endl;
fout.close();
return 0;
}
void Item::encode(Encoder& encoder) const
{
encoder.encode(typeID_);
encoder.encode(groupID_);
encoder.encode(categoryID_);
{
AttributesMap::const_iterator i, end = attributes_.end();
encoder.encode(attributes_.size());
for (i = attributes_.begin(); i != end; i++)
i->second->encode(encoder);
}
{
EffectsList::const_iterator i, end = effects_.end();
encoder.encode(effects_.size());
for (i = effects_.begin(); i != end; i++)
encoder.encode((*i)->getEffectID());
}
}
void encode_decode_chunkwise(bool encode, const Codec *codec,
const QByteArray &infile_buffer, QFile &outfile)
{
Encoder *enc = 0;
Decoder *dec = 0;
QByteArray indata(inbufsize);
QByteArray outdata(outbufsize);
// we're going to need this below:
#define write_full_outdata_then_reset do { \
kdDebug( verbose ) << " flushing output buffer." << endl; \
if ( writing ) { \
Q_LONG outlen = outfile.writeBlock( outdata.data(), \
outdata.size() ); \
if ( outlen != (int)outdata.size() ) \
exit(OUTFILE_WRITE_ERR); \
} \
oit = outdata.begin(); \
} while ( false )
#define report_status(x,y) do { \
kdDebug( verbose ) << " " #x "() returned " #y " after processing " \
<< iit - indata.begin() << " bytes of input.\n" \
<< " output iterator now at position " \
<< oit - outdata.begin() << " of " \
<< outdata.size() << endl; \
} while ( false )
#define report_finish_status(y) do { \
kdDebug( verbose ) << " finish() returned " #y "\n" \
<< " output iterator now at position " \
<< oit - outdata.begin() << " of " \
<< outdata.size() << endl; \
} while ( false )
// Initialize the output iterators:
QByteArray::Iterator oit = outdata.begin();
QByteArray::Iterator oend = outdata.end();
// Get an encoder. This one you have to delete!
if(encode)
{
enc = codec->makeEncoder(withCRLF);
assert(enc);
}
else
{
dec = codec->makeDecoder(withCRLF);
assert(dec);
}
//
// Loop over input chunks:
//
uint offset = 0;
while(offset < infile_buffer.size())
{
uint reallyRead = QMIN(indata.size(), infile_buffer.size() - offset);
indata.duplicate(infile_buffer.begin() + offset, reallyRead);
offset += reallyRead;
kdDebug(verbose) << " read " << reallyRead << " bytes (max: "
<< indata.size() << ") from input." << endl;
// setup input iterators:
QByteArray::ConstIterator iit = indata.begin();
QByteArray::ConstIterator iend = indata.begin() + reallyRead;
if(encode)
{
//
// Loop over encode() calls:
//
while(!enc->encode(iit, iend, oit, oend))
{
report_status(encode, false);
if(oit == oend)
// output buffer full:
write_full_outdata_then_reset;
}
report_status(encode, true);
}
else
{
//
// Loop over decode() calls:
//
while(!dec->decode(iit, iend, oit, oend))
{
report_status(decode, false);
if(oit == oend)
// output buffer full:
write_full_outdata_then_reset;
}
report_status(decode, true);
}
} // end loop over input chunks
//
// Now finish the encoding/decoding:
// (same loops as above, just s/encode|decode/finish())
//
if(withFinish)
if(encode)
{
while(!enc->finish(oit, oend))
{
report_finish_status(false);
if(oit == oend)
write_full_outdata_then_reset;
}
report_finish_status(true);
}
else
{
while(!dec->finish(oit, oend))
{
report_finish_status(false);
if(oit == oend)
write_full_outdata_then_reset;
}
report_finish_status(true);
}
//
// Write out last (partial) output chunk:
//
if(writing)
{
Q_LONG outlen = outfile.writeBlock(outdata.data(),
oit - outdata.begin());
if(outlen != oit - outdata.begin())
exit(OUTFILE_WRITE_ERR);
}
//
// Delete en/decoder:
//
if(encode)
delete enc;
else
delete dec;
}
uint8_t oplug_mpegff(const char *name, ADM_OUT_FORMAT type)
{
AVDMGenericVideoStream *_incoming;
//EncoderFFMPEGMpeg1 *encoder;
Encoder *encoder;
ADMMpegMuxer *muxer=NULL;
FILE *file=NULL;
uint8_t audioBuffer[48000];
uint32_t audioLen=0;
uint32_t _w,_h,_fps1000,_page,total;
AVDMGenericAudioStream *audio;
uint32_t len,flags;
uint32_t size;
ADM_MUXER_TYPE mux;
uint32_t audio_encoding=0;
uint32_t real_framenum=0;
uint8_t ret=0;
uint32_t sample_target=0;
uint32_t total_sample=0;
ADMBitstream bitstream(0);
uint32_t audioSum=0;
twoPass=new char[strlen(name)+6];
twoFake=new char[strlen(name)+6];
strcpy(twoPass,name);
strcat(twoPass,".stat");
/* orig: strcat(twoFake,".fake"); */
strcpy(twoFake,name);
strcat(twoFake,".fake");
_incoming = getLastVideoFilter (frameStart,frameEnd-frameStart);
_w=_incoming->getInfo()->width;
_h=_incoming->getInfo()->height;
_fps1000=_incoming->getInfo()->fps1000;
_page=_w*_h;
_page+=_page>>1;
total=_incoming->getInfo()->nb_frames;
if(!total) return 0;
switch(type)
{
default:
ADM_assert(0);
case ADM_ES:
// Else open file (if possible)
mux=MUXER_NONE;
break;
case ADM_TS:
if(!currentaudiostream)
{
GUI_Error_HIG(_("There is no audio track"), NULL);
return 0;
}
audio=mpt_getAudioStream();
mux=MUXER_TS;
break;
case ADM_PS:
{
if(!currentaudiostream)
{
GUI_Error_HIG(_("There is no audio track"), NULL);
return 0;
}
audio=mpt_getAudioStream();
// Have to check the type
// If it is mpeg2 we use DVD-PS
// If it is mpeg1 we use VCD-PS
// Later check if it is SVCD
if(!audio)
{
GUI_Error_HIG(_("Audio track is not suitable"), NULL);
return 0;
}
// Check
WAVHeader *hdr=audio->getInfo();
audio_encoding=hdr->encoding;
if(current_codec==CodecXVCD ||current_codec==CodecVCD)
{
if(hdr->frequency!=44100 || hdr->encoding != WAV_MP2)
{
GUI_Error_HIG(("Incompatible audio"),_( "For VCD, audio must be 44.1 kHz MP2."));
deleteAudioFilter(audio);
return 0;
}
mux=MUXER_VCD;
printf("X*CD: Using VCD PS\n");
}else
{
aviInfo info;
video_body->getVideoInfo(&info);
if(hdr->frequency==44100 && _w==480&&hdr->encoding == WAV_MP2 ) // SVCD ?
{
mux=MUXER_SVCD;
printf("X*VCD: Using SVCD PS\n");
}
else
{
// mpeg2, we do only DVD right now
if(hdr->frequency!=48000 ||
(hdr->encoding != WAV_MP2 && hdr->encoding!=WAV_AC3 && hdr->encoding!=WAV_LPCM))
{
deleteAudioFilter(audio);
GUI_Error_HIG(_("Incompatible audio"), _("For DVD, audio must be 48 kHz MP2, AC3 or LPCM."));
return 0 ;
}
mux=MUXER_DVD;
printf("X*VCD: Using DVD PS\n");
}
}
}
}
// Create muxer
switch(current_codec)
{
case CodecXVCD:
encoder=new EncoderFFMPEGMpeg1(FF_MPEG1,&ffmpeg1Codec);
printf("\n Using ffmpeg mpeg1 encoder\n");
break;
case CodecXSVCD:
encoder=new EncoderFFMPEGMpeg1(FF_MPEG2,&ffmpeg2SVCDCodec);
printf("\n Using ffmpeg mpeg2 encoder\n");
break;
case CodecXDVD:
encoder=new EncoderFFMPEGMpeg1(FF_MPEG2,&ffmpeg2DVDCodec);
printf("\n Using ffmpeg mpeg2 encoder (DVD)\n");
break;
case CodecDVD:
encoder=new EncoderMpeg2enc(MPEG2ENC_DVD,&DVDCodec);
printf("\n Using mpeg2enc encoder (DVD)\n");
break;
case CodecRequant:
if(!isMpeg12Compatible(avifileinfo->fcc))
{
GUI_Error_HIG("Incompatible Input","The input file must be mpeg2 to be able to use requant!");
return 0; // Fixme, do some cleanup
}
encoder=new EncoderRequant(&RequantCodec);
printf("\n Using mpeg2 requant\n");
break;
break;
case CodecSVCD:
encoder=new EncoderMpeg2enc(MPEG2ENC_SVCD,&SVCDCodec);
printf("\n Using mpeg2enc encoder (SVCD)\n");
break;
case CodecVCD:
encoder=new EncoderMpeg2enc(MPEG2ENC_VCD,&VCDCodec);
printf("\n Using mpeg2enc encoder (VCD)\n");
break;
default:
ADM_assert(0);
}
encoder->setLogFile(twoPass,total);
if(!encoder->configure(_incoming))
{
delete encoder;
return 0;
}
_buffer=new uint8_t[_page]; // Might overflow if _page only
_outbuffer=new uint8_t[_page];
ADM_assert( _buffer);
ADM_assert( _outbuffer);
DIA_encoding *encoding;
encoding =new DIA_encoding(_fps1000);
switch(current_codec)
{
case CodecVCD:
encoding->setCodec("libmpeg2enc VCD");
break;
case CodecSVCD:
encoding->setCodec("libmpeg2enc SVCD");
break;
case CodecDVD:
encoding->setCodec("libmpeg2enc DVD");
break;
case CodecXVCD:
encoding->setCodec("FFmpeg Mpeg1 VBR");
break;
case CodecXSVCD:
encoding->setCodec("FFmpeg Mpeg2 SVCD VBR");
break;
case CodecXDVD:
encoding->setCodec("FFmpeg Mpeg2 DVD VBR");
break;
case CodecRequant:
encoding->setCodec("Mpeg Requantizer");
break;
default:
ADM_assert(0);
}
switch(mux)
{
case MUXER_NONE:encoding->setContainer("Mpeg ES");break;
case MUXER_TS: encoding->setContainer("Mpeg TS");break;
case MUXER_VCD: encoding->setContainer("Mpeg VCD");break;
case MUXER_SVCD:encoding->setContainer("Mpeg SVCD");break;
case MUXER_DVD: encoding->setContainer("Mpeg DVD");break;
default:
ADM_assert(0);
}
// pass 1
if(encoder->isDualPass())
{
FILE *fd;
uint8_t reuse=0;
fd=fopen(twoPass,"rt");
if(fd)
{
if(GUI_Question(_("Reuse log file ?")))
{
reuse=1;
}
fclose(fd);
}
if(!reuse)
{
encoding->setPhasis ("Pass 1/2");
encoder->startPass1();
bitstream.data=_buffer;
bitstream.bufferSize=_page;
for(uint32_t i=0;i<total;i++)
{
bitstream.cleanup(i);
if(!encoder->encode( i, &bitstream))//&len,(uint8_t *) _buffer,&flags))
{
GUI_Error_HIG(_("Error in pass 1"), NULL);
}
encoding->setFrame(i,bitstream.len,bitstream.out_quantizer,total);
if(!encoding->isAlive())
{
goto finishvcdff;
}
}
}
encoder->startPass2();
encoding->reset();
}
switch(type)
{
case ADM_PS:
muxer=new mplexMuxer;
break;
case ADM_TS:
muxer=new tsMuxer;
break;
case ADM_ES:
break;
default:
ADM_assert(0);
}
if(muxer)
{
if(!muxer->open(name,0,mux,avifileinfo,audio->getInfo()))
{
delete muxer;
muxer=NULL;
deleteAudioFilter(audio);
printf("Muxer init failed\n");
return 0 ;
}
double sample_time;
sample_time=total;
sample_time*=1000;
sample_time/=_fps1000; // target_time in second
sample_time*=audio->getInfo()->frequency;
sample_target=(uint32_t)floor(sample_time);
}
else
{
file=fopen(name,"wb");
if(!file)
{
GUI_Error_HIG(_("File error"), _("Cannot open \"%s\" for writing."), name);
return 0 ;
}
}
if(encoder->isDualPass())
encoding->setPhasis ("Pass 2/2");
else
encoding->setPhasis ("Encoding");
// Set info for audio if any
if(muxer)
{
if(!audioProcessMode())
encoding->setAudioCodec("Copy");
else
encoding->setAudioCodec(getStrFromAudioCodec(audio->getInfo()->encoding));
}
//**********************************************************
// In that case we do multithreadedwriting (yes!)
//**********************************************************
if(mux==MUXER_DVD || mux==MUXER_SVCD || mux==MUXER_VCD)
{
pthread_t audioThread,videoThread,muxerThread;
muxerMT context;
//
bitstream.data=_outbuffer;
bitstream.bufferSize=_page;
//
memset(&context,0,sizeof(context));
context.videoEncoder=encoder;
context.audioEncoder=audio;
context.muxer=(mplexMuxer *)muxer;
context.nbVideoFrame=total;
context.audioTargetSample=sample_target;
context.audioBuffer=audioBuffer;
context.bitstream=&bitstream;
context.opaque=(void *)encoding;
// start audio thread
ADM_assert(!pthread_create(&audioThread,NULL,(THRINP)defaultAudioSlave,&context));
ADM_assert(!pthread_create(&videoThread,NULL,(THRINP)defaultVideoSlave,&context));
while(1)
{
accessMutex.lock();
if(!encoding->isAlive())
{
context.audioAbort=1;
context.videoAbort=1;
printf("[mpegFF]Waiting for slaves\n");
accessMutex.unlock();
while(1)
{
accessMutex.lock();
if(context.audioDone && context.videoDone)
{
printf("[mpegFF]Both audio & video done\n");
if(context.audioDone==1 && context.videoDone==1) ret=1;
else ret=0;
accessMutex.unlock();
goto finishvcdff;
}
accessMutex.unlock();
ADM_usleep(50000);
}
}
if(context.audioDone==2 || context.videoDone==2 ) //ERROR
{
context.audioAbort=1;
context.videoAbort=1;
}
if(context.audioDone && context.videoDone)
{
printf("[mpegFF]Both audio & video done\n");
if(context.audioDone==1 && context.videoDone==1) ret=1;
else ret=0;
accessMutex.unlock();
goto finishvcdff;
}
accessMutex.unlock();
ADM_usleep(1000*1000);
}
}
//**********************************************************
// NOT MULTITHREADED
//**********************************************************
bitstream.data=_outbuffer;
for(uint32_t i=0;i<total;i++)
{
// get frame
bitstream.cleanup(i);
if(!encoder->encode( i,&bitstream))// &len,(uint8_t *) _outbuffer,&flags))
{
GUI_Error_HIG(_("Error in pass 2"), NULL);
goto finishvcdff;
}
if(!bitstream.len) continue;
if(file)
{
fwrite(_outbuffer,bitstream.len,1,file);
}
else
{
uint32_t samples;
//printf("%lu %lu\n",i,dts);
muxer->writeVideoPacket(&bitstream);
real_framenum++;
// _muxer->writeVideoPacket(len,_buffer_out,
//i-MPEG_PREFILL,_codec->getCodedPictureNumber());
if(total_sample<sample_target)
{
while(muxer->needAudio() && total_sample<sample_target)
{
if(!audio->getPacket(audioBuffer, &audioLen, &samples))
{
break;
}
if(audioLen)
{
muxer->writeAudioPacket(audioLen,audioBuffer);
total_sample+=samples;
audioSum+=audioLen;
}
}
}
}
encoding->setFrame(i,bitstream.len,bitstream.out_quantizer,total);
encoding->setAudioSize(audioSum);
if(!encoding->isAlive ())
{
ret=0;
goto finishvcdff;
}
}
ret=1;
finishvcdff:
printf("[MPEGFF] Finishing..\n");
delete encoding;
end();
if(file)
{
fclose(file);
file=NULL;
}
else
{
if(muxer)
{
muxer->close();
delete muxer;
muxer=NULL;
}
}
delete encoder;
return ret;
}
const void encode(Encoder& e, Reporter& reporter) const override {
String groupStr(groupByValue.c_str());
e.encode(groupStr);
e.encode(total);
e.encode(count);
}
