NEOIP_NAMESPACE_BEGIN
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// from/to_file function
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/** \brief Build a ndiag_cacheport_t from a file_path_t to a .torrent file
*
* - just a wrapper on top of from_bencode and file_sio_t
* - it has no error report except that any error return a null ndiag_cacheport_t
*/
ndiag_cacheport_t ndiag_cacheport_helper_t::from_file(const file_path_t &file_path) throw()
{
datum_t resumedata_datum;
ndiag_cacheport_t ndiag_cacheport;
// read the whole file
file_err_t file_err;
file_err = file_sio_t::readall(file_path, resumedata_datum);
if( file_err.failed() ) return ndiag_cacheport_t();
// try to unserialized the ndiag_cacheport
bytearray_t bytearray( resumedata_datum );
try{
bytearray >> ndiag_cacheport;
}catch(serial_except_t &e){
return ndiag_cacheport_t();
}
// return the ndiag_cacheport_t
return ndiag_cacheport;
}
/** \brief Parse flv_tagtype_t::META
*/
flv_err_t flv2xml_apps_t::parse_tagtype_meta(const flv_taghd_t &flv_taghd
, const datum_t &tag_data) throw()
{
bytearray_t bytearray(tag_data);
dvar_t type_dvar;
dvar_t data_dvar;
flv_err_t flv_err;
// sanity check - flv_taghd_t MUST be a flv_tagtype_t::META
DBG_ASSERT( flv_taghd.type() == flv_tagtype_t::META);
// get the event_type
flv_err = amf0_parse_t::amf_to_dvar(bytearray, type_dvar);
if( flv_err.failed() ) return flv_err;
// get the event_data associated with the event_type
flv_err = amf0_parse_t::amf_to_dvar(bytearray, data_dvar);
if( flv_err.failed() ) return flv_err;
// if flv_tagtype_t::META MUST NOT be displayed, return now
if( !output_tag_meta ) return flv_err_t::OK;
// display the event
display_taghd_beg(flv_taghd);
KLOG_STDOUT("<metadata type=\"" << type_dvar.str().get() << "\">\n");
KLOG_STDOUT(dvar_helper_t::to_xml(data_dvar));
KLOG_STDOUT("</metadata>\n");
display_taghd_end(flv_taghd);
// return no error
return flv_err_t::OK;
}
void KAudioPlayStream::fillData( Arts::DataPacket<Arts::mcopbyte> *packet )
{
//kdDebug( 400 ) << k_funcinfo << "packet->size=" << packet->size << endl;
if ( d->_polling )
{
QByteArray bytearray( packet->size );
bytearray.setRawData( ( char* )packet->contents, packet->size );
bytearray.fill( 0 );
emit requestData( bytearray );
bytearray.resetRawData( ( char* )packet->contents, packet->size );
//for ( int i=0; i<10; i++ )
// kdDebug() << packet->contents[ i ] << " : " << bytearray.data()[ i ] << endl;
} else {
/// TODO: Implement a queue and fetching from it...
}
}
bool KRecExport_MP3::process() {
//kdDebug( 60005 ) << k_funcinfo << running << endl;
if ( _file ) {
if ( running() ) {
QByteArray bytearray( 4096 );
emit getData( bytearray );
int mp3bytes = lame_encode_buffer_interleaved( gfp,
reinterpret_cast<short int *>( bytearray.data() ),
bytearray.size() >> 2, mp3buf, sizeof( mp3buf ) );
if ( mp3bytes > 0 )
_file->writeBlock( reinterpret_cast<char *>( mp3buf ), mp3bytes );
if ( mp3bytes < 0 && ! error_occurred ) {
int code = ( mp3bytes < -6 ) ? 0 : -mp3bytes;
KMessageBox::detailedError( 0, i18n( "MP3 encoding error." ),
i18n( lame_error[ code ] ) );
error_occurred = true;
}
QTimer::singleShot( 10, this, SLOT( process() ) );
}
return true;
} else return false;
/*!
* Store contact
*/
CArrayFixFlat<TUid>* CNsmlContactsDataStoreExtensionPrivate::ImportContactsL( const TDesC8 &contactbufbase )
{
_DBG_FILE("CNsmlContactsDataStoreExtensionPrivate::ImportContactsL: BEGIN");
DBG_DUMP((void*)contactbufbase.Ptr(), contactbufbase.Length(),
_S8("CNsmlContactsDataStoreExtensionPrivate::ImportContactsL: To DB :"));
TBool ret( ETrue );
CArrayFixFlat<TUid>* contactItems = new(ELeave) CArrayFixFlat<TUid>(4);
QBuffer contactsbuf;
contactsbuf.open(QBuffer::ReadWrite);
QByteArray bytearray((char*)contactbufbase.Ptr());
contactsbuf.write(bytearray);
contactsbuf.seek(0);
mReader->setDevice(&contactsbuf);
if (mReader->startReading() && mReader->waitForFinished())
{
DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::Buffer Count: %d"), mReader->results().count() );
QList<QContact> contacts;
if ( mImporter->importDocuments( mReader->results() ) )
{
contacts = mImporter->contacts();
QMap<int, QContactManager::Error> errorMap;
ret = mContactManager->saveContacts( &contacts, &errorMap );
DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::Import Status: %d"), ret );
}
if( ret )
{
foreach (QContact contact, contacts )
{
TUint contactid = contact.id().localId();
DBG_ARGS(_S("CNsmlContactsDataStoreExtensionPrivate::Contact ID: %d"), contactid );
contactItems->AppendL( TUid::Uid( contactid ) );
}
}
/** \brief Parse flv_tagtype_t::AUDIO
*/
flv_err_t flv2xml_apps_t::parse_tagtype_audio(const flv_taghd_t &flv_taghd
, const datum_t &tag_data) throw()
{
flv_taghd_audio_t taghd_audio;
// sanity check - flv_taghd_t MUST be a flv_tagtype_t::AUDIO
DBG_ASSERT( flv_taghd.type() == flv_tagtype_t::AUDIO );
// parse the flv_taghd_audio_t from the tag_data
try {
bytearray_t bytearray(tag_data);
bytearray >> taghd_audio;
}catch(const serial_except_t &e){
std::string reason = "failed to parse flv_taghd_t " +flv_taghd.to_string()+" due to "+e.what();
return flv_err_t(flv_err_t::ERROR, reason);
}
// log to debug
KLOG_DBG("taghd_audio=" << taghd_audio);
// if flv_tagtype_t::AUDIO MUST NOT be displayed, return now
if( !output_tag_audio ) return flv_err_t::OK;
// output the xml result
display_taghd_beg(flv_taghd);
KLOG_STDOUT("<taghd_audio>\n");
KLOG_STDOUT("<soundtype>" << taghd_audio.soundtype() << "</soundtype>\n");
KLOG_STDOUT("<soundsize>" << taghd_audio.soundsize() << "</soundsize>\n");
KLOG_STDOUT("<soundrate>" << taghd_audio.soundrate() << "</soundrate>\n");
KLOG_STDOUT("<soundformat>" << taghd_audio.soundformat() << "</soundformat>\n");
#if 0 // modification to output the data too
KLOG_STDOUT("<data>\n");
KLOG_STDOUT(tag_data << "\n");
KLOG_STDOUT("</data>\n");
#endif
KLOG_STDOUT("</taghd_audio>\n");
display_taghd_end(flv_taghd);
// return no error
return flv_err_t::OK;
}
HRESULT CHandler::GetProperty(quint32 index, PROPID propID, QVariant *value)
{
QVariant prop;
const CItemEx &item = *m_Items[index];
switch (propID) {
case kpidPath:
prop = NItemName::GetOSName2(item.Name);
break;
case kpidIsFolder:
prop = item.IsDirectory();
break;
case kpidSize:
prop = item.UnPackSize;
break;
case kpidPackedSize:
prop = item.PackSize;
break;
case kpidLastWriteTime: {
prop = fromDosTime(QByteArray((char *)&item.Time, 4));
break;
}
case kpidAttributes:
prop = item.GetWinAttributes();
break;
case kpidEncrypted:
prop = item.IsEncrypted();
break;
case kpidComment: {
prop = QString::fromLocal8Bit(bytearray(item.Comment)); // item.GetCodePage()
break;
}
case kpidCRC:
if (item.IsThereCrc())
prop = item.FileCRC;
break;
case kpidMethod: {
quint16 methodId = item.CompressionMethod;
QString method;
if (item.IsEncrypted()) {
if (methodId == NFileHeader::NCompressionMethod::kWzAES) {
method = kAESMethod;
CWzAesExtraField aesField;
if (item.CentralExtra.GetWzAesField(aesField)) {
method += "-";
method += QString::number((aesField.Strength + 1) * 64);
method += " ";
methodId = aesField.Method;
}
} else {
if (item.IsStrongEncrypted()) {
CStrongCryptoField f;
bool finded = false;
if (item.CentralExtra.GetStrongCryptoField(f)) {
for (int i = 0; i < sizeof(g_StrongCryptoPairs) / sizeof(g_StrongCryptoPairs[0]); i++) {
const CStrongCryptoPair &pair = g_StrongCryptoPairs[i];
if (f.AlgId == pair.Id) {
method += pair.Name;
finded = true;
break;
}
}
}
if (!finded)
method += kStrongCryptoMethod;
} else
method += kZipCryptoMethod;
method += " ";
}
}
if (methodId < kNumMethods)
method += kMethods[methodId];
else if (methodId == NFileHeader::NCompressionMethod::kWzPPMd)
method += kPPMdMethod;
else {
method += QString::number(methodId);
}
prop = method;
break;
}
case kpidHostOS:
prop = QLatin1String((item.MadeByVersion.HostOS < kNumHostOSes) ?
(kHostOS[item.MadeByVersion.HostOS]) : kUnknownOS);
break;
}
*value = prop;
return S_OK;
// COM_TRY_END
}
/** \brief callback notified by \ref flv_parse_t when to notify an event
*/
bool flv_parse_testclass_t::neoip_flv_parse_cb(void *cb_userptr, flv_parse_t &cb_flv_parse
, const flv_parse_event_t &parse_event) throw()
{
// log to debug
KLOG_ERR("enter event=" << parse_event);
// if flv_parse_event_t is fatal, report an error
if( parse_event.is_fatal() ){
neoip_nunit_testclass_deinit();
nunit_ftor(NUNIT_RES_ERROR);
return false;
}
// compute the amount of unparsed data in flv_parse->buffer()
DBG_ASSERT( flv_parse->buffer().size() >= parse_event.byte_length() );
size_t unparsed_len = flv_parse->buffer().size() - parse_event.byte_length();
// if unparsed_len == 0 and no more data to read, leave asap
// - do a -4 because it should point to the flv_taghd_t::type and
// not the flv_taghd_t::prevtag_size which is an uint32_t
// - this flv_taghd_t::prevtag_size crap is as well in
// flv_parse_helper_t::kframe_boffset_from(), in the flv_parse_t nunit
// and neoip-flvfilter
// - i dont like it, seems like a bug in the flv_parse_t architechture
// - it is spreaded everywhere, likely a misunderstanding of the flv format
if( unparsed_len <= sizeof(uint32_t) && file_size == read_size ){
neoip_nunit_testclass_deinit();
nunit_ftor(NUNIT_RES_OK);
return false;
}
// if this parse_event_t is a tag flv_tagtype_t::META, display the AMF it contains
if( parse_event.is_tag() ){
datum_t tag_data;
flv_taghd_t flv_taghd = parse_event.get_tag(&tag_data);
if( flv_taghd.type() == flv_tagtype_t::META ){
flv_err_t flv_err;
bytearray_t bytearray(tag_data);
dvar_t event_name_dvar;
dvar_t event_data_dvar;
// log to debug
KLOG_ERR("META DATA:");
// parse the tag_data as AMF data
flv_err = amf0_parse_t::amf_to_dvar(bytearray, event_name_dvar);
DBG_ASSERT( flv_err.succeed() );
KLOG_ERR("event_name=" << event_name_dvar);
flv_err = amf0_parse_t::amf_to_dvar(bytearray, event_data_dvar);
DBG_ASSERT( flv_err.succeed() );
KLOG_ERR("event_data=" << event_data_dvar);
}
}
// display the kframe_boffset if any
file_size_t kframe_boffset;
kframe_boffset = flv_parse_helper_t::kframe_boffset_from(flv_parse, parse_event);
if( !kframe_boffset.is_null() ) KLOG_ERR("KEY frame at " << kframe_boffset);
// return tokeep
return true;
}
