LocalMediaStream::LocalMediaStream(const talk_base::scoped_refptr<webrtc::LocalMediaStreamInterface>& pStream)
: FB::JSAPIAuto("MediaStream")
, m_label(pStream->label())
, m_videoTracks(FB::variant_list_of())
, m_audioTracks(FB::variant_list_of())
{
registerProperty("label", make_property(this, &LocalMediaStream::get_label));
registerProperty("videoTracks", make_property(this,&LocalMediaStream::get_videoTracks));
registerProperty("audioTracks", make_property(this, &LocalMediaStream::get_audioTracks));
for(int i=0; i<pStream->video_tracks()->count(); i++)
{
talk_base::scoped_refptr<webrtc::VideoTrackInterface> pTrack(pStream->video_tracks()->at(i));
talk_base::scoped_refptr<webrtc::LocalVideoTrackInterface> pTrack_(
static_cast<webrtc::LocalVideoTrackInterface*>(pTrack.get())
);
AddTrack(LocalVideoTrack::Create(pTrack_));
}
for(int i=0; i<pStream->audio_tracks()->count(); i++)
{
talk_base::scoped_refptr<webrtc::AudioTrackInterface> pTrack(pStream->audio_tracks()->at(i));
talk_base::scoped_refptr<webrtc::LocalAudioTrackInterface> pTrack_(
static_cast<webrtc::LocalAudioTrackInterface*>(pTrack.get())
);
AddTrack(LocalAudioTrack::Create(pTrack_));
}
}
//----------------------------------------------
// get track info from URI
//----------------------------------------------
TRef TLSpotify::TSession::FindTrack(const TString& URI)
{
THeapArray<char> UriString;
URI.GetAnsi( UriString );
// find link
sp_link *link = sp_link_create_from_string( UriString.GetData() );
if (!link)
return TRef();
// get track from the link
sp_track* pTrack = sp_link_as_track( link );
if ( !pTrack )
{
TDebugString Debug_String;
Debug_String << "URI " << URI << " is not a track";
TLDebug_Print( Debug_String );
return TRef();
}
// create new track info
TRef TrackRef = AddTrack( *pTrack );
const char* TrackName = sp_track_name( pTrack );
// The create function will have increased the reference count for us so release
sp_link_release(link);
return TrackRef;
}
void *m_alloc(unsigned long size, const char *file, unsigned long line)
{
ILvoid *ptr;
ptr = malloc(size);
if (!ptr)
return NULL;
AddToAtexit();
AddTrack((unsigned long)ptr, size, file, line);
return ptr;
}
/*****************************************************************************
* Everything else
*****************************************************************************/
static int AddDevice( services_discovery_t *p_sd,
LIBMTP_raw_device_t *p_raw_device )
{
char *psz_name = NULL;
LIBMTP_mtpdevice_t *p_device;
LIBMTP_track_t *p_track, *p_tmp;
if( ( p_device = LIBMTP_Open_Raw_Device( p_raw_device ) ) != NULL )
{
if( !( psz_name = LIBMTP_Get_Friendlyname( p_device ) ) )
if( !( psz_name = LIBMTP_Get_Modelname( p_device ) ) )
if( !( psz_name = strdup( N_( "MTP Device" ) ) ) )
return VLC_ENOMEM;
msg_Info( p_sd, "Found device: %s", psz_name );
p_sd->p_sys->i_bus = p_raw_device->bus_location;
p_sd->p_sys->i_dev = p_raw_device->devnum;
p_sd->p_sys->i_product_id = p_raw_device->device_entry.product_id;
if( ( p_track = LIBMTP_Get_Tracklisting_With_Callback( p_device,
CountTracks, p_sd ) ) == NULL )
{
msg_Warn( p_sd, "No tracks on the device" );
}
else
{
if( !( p_sd->p_sys->pp_items = calloc( p_sd->p_sys->i_tracks_num,
sizeof( input_item_t * ) ) ) )
{
free( psz_name );
return VLC_ENOMEM;
}
p_sd->p_sys->i_count = 0;
while( p_track != NULL )
{
msg_Dbg( p_sd, "Track found: %s - %s", p_track->artist,
p_track->title );
AddTrack( p_sd, p_track );
p_tmp = p_track;
p_track = p_track->next;
LIBMTP_destroy_track_t( p_tmp );
}
}
p_sd->p_sys->psz_name = psz_name;
LIBMTP_Release_Device( p_device );
return VLC_SUCCESS;
}
else
{
msg_Info( p_sd, "The device seems to be mounted, unmount it first" );
return VLC_EGENERIC;
}
}
Dialog::Dialog(QWidget *parent) :
QDialog(parent),
ui(new Ui::Dialog)
{
ui->setupUi(this);
this->setLayout(ui->verticalLayout);
model=new QStandardItemModel();
model->setHorizontalHeaderLabels(QStringList({"Title", "Duration"}));
ui->tableView->setModel(model);
ui->tableView->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
connect(ui->AddButton, SIGNAL(clicked()), this, SLOT(AddTrack()));
connect(ui->RemoveButton, SIGNAL(clicked()), this, SLOT(DelTrack()));
connect(ui->UpButton, SIGNAL(clicked()), this, SLOT(PopTrack()));
connect(ui->DownButton, SIGNAL(clicked()), this, SLOT(PushTrack()));
NewArtist=NULL;
}
GpxRootElement::GpxRootElement(const wxString &creator, GpxMetadataElement *metadata, ListOfGpxWpts *waypoints, ListOfGpxRoutes *routes, ListOfGpxTracks *tracks, GpxExtensionsElement *extensions) : TiXmlElement("gpx")
{
my_extensions = NULL;
my_metadata = NULL;
first_waypoint = NULL;
last_waypoint = NULL;
first_route = NULL;
last_route = NULL;
first_track = NULL;
last_track = NULL;
SetAttribute ( "version", "1.1" );
SetAttribute ( "creator", creator.ToUTF8() );
SetAttribute( "xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance" );
SetAttribute( "xmlns", "http://www.topografix.com/GPX/1/1" );
SetAttribute( "xmlns:gpxx", "http://www.garmin.com/xmlschemas/GpxExtensions/v3" );
SetAttribute( "xsi:schemaLocation", "http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd" );
SetMetadata(metadata);
if (waypoints) {
wxListOfGpxWptsNode *waypoint = waypoints->GetFirst();
while (waypoint)
{
AddWaypoint(waypoint->GetData());
waypoint = waypoint->GetNext();
}
}
if (routes) {
wxListOfGpxRoutesNode *route = routes->GetFirst();
while (route)
{
AddRoute(route->GetData());
route = route->GetNext();
}
}
if (tracks) {
wxListOfGpxTracksNode *track = tracks->GetFirst();
while (track)
{
AddTrack(track->GetData());
track = track->GetNext();
}
}
SetExtensions(extensions);
}
CDDBData::CDDBData(const CDDBData &from)
:
fDiscID(from.fDiscID),
fArtist(from.fArtist),
fAlbum(from.fAlbum),
fGenre(from.fGenre),
fDiscTime(from.fDiscTime),
fYear(from.fYear)
{
STRACE(("CDDBData::Copy Constructor\n"));
for (int32 i = 0; i < from.fTrackList.CountItems(); i++) {
BString *string = (BString*)from.fTrackList.ItemAt(i);
CDAudioTime *time = (CDAudioTime*)from.fTimeList.ItemAt(i);
if (!string || !time)
continue;
AddTrack(string->String(), *time);
}
}
CDDBData &
CDDBData::operator=(const CDDBData &from)
{
_EmptyLists();
fDiscID = from.fDiscID;
fArtist = from.fArtist;
fAlbum = from.fAlbum;
fGenre = from.fGenre;
fDiscTime = from.fDiscTime;
fYear = from.fYear;
for (int32 i = 0; i < from.fTrackList.CountItems(); i++) {
BString *string = (BString*)from.fTrackList.ItemAt(i);
CDAudioTime *time = (CDAudioTime*)from.fTimeList.ItemAt(i);
if (!string || !time)
continue;
AddTrack(string->String(),*time);
}
return *this;
}
void TrackUnionStream::ProcessInput(GraphTime aFrom, GraphTime aTo, uint32_t aFlags)
{
if (IsFinishedOnGraphThread()) {
return;
}
nsAutoTArray<bool,8> mappedTracksFinished;
nsAutoTArray<bool,8> mappedTracksWithMatchingInputTracks;
for (uint32_t i = 0; i < mTrackMap.Length(); ++i) {
mappedTracksFinished.AppendElement(true);
mappedTracksWithMatchingInputTracks.AppendElement(false);
}
bool allFinished = !mInputs.IsEmpty();
bool allHaveCurrentData = !mInputs.IsEmpty();
for (uint32_t i = 0; i < mInputs.Length(); ++i) {
MediaStream* stream = mInputs[i]->GetSource();
if (!stream->IsFinishedOnGraphThread()) {
// XXX we really should check whether 'stream' has finished within time aTo,
// not just that it's finishing when all its queued data eventually runs
// out.
allFinished = false;
}
if (!stream->HasCurrentData()) {
allHaveCurrentData = false;
}
bool trackAdded = false;
for (StreamBuffer::TrackIter tracks(stream->GetStreamBuffer());
!tracks.IsEnded(); tracks.Next()) {
bool found = false;
for (uint32_t j = 0; j < mTrackMap.Length(); ++j) {
TrackMapEntry* map = &mTrackMap[j];
if (map->mInputPort == mInputs[i] && map->mInputTrackID == tracks->GetID()) {
bool trackFinished;
StreamBuffer::Track* outputTrack = mBuffer.FindTrack(map->mOutputTrackID);
if (!outputTrack || outputTrack->IsEnded()) {
trackFinished = true;
} else {
CopyTrackData(tracks.get(), j, aFrom, aTo, &trackFinished);
}
mappedTracksFinished[j] = trackFinished;
mappedTracksWithMatchingInputTracks[j] = true;
found = true;
break;
}
}
if (!found && (!mFilterCallback || mFilterCallback(tracks.get()))) {
bool trackFinished = false;
trackAdded = true;
uint32_t mapIndex = AddTrack(mInputs[i], tracks.get(), aFrom);
CopyTrackData(tracks.get(), mapIndex, aFrom, aTo, &trackFinished);
mappedTracksFinished.AppendElement(trackFinished);
mappedTracksWithMatchingInputTracks.AppendElement(true);
}
}
if (trackAdded) {
for (MediaStreamListener* l : mListeners) {
l->NotifyFinishedTrackCreation(Graph());
}
}
}
for (int32_t i = mTrackMap.Length() - 1; i >= 0; --i) {
if (mappedTracksFinished[i]) {
EndTrack(i);
} else {
allFinished = false;
}
if (!mappedTracksWithMatchingInputTracks[i]) {
mTrackMap.RemoveElementAt(i);
}
}
if (allFinished && mAutofinish && (aFlags & ALLOW_FINISH)) {
// All streams have finished and won't add any more tracks, and
// all our tracks have actually finished and been removed from our map,
// so we're finished now.
FinishOnGraphThread();
} else {
mBuffer.AdvanceKnownTracksTime(GraphTimeToStreamTime(aTo));
}
if (allHaveCurrentData) {
// We can make progress if we're not blocked
mHasCurrentData = true;
}
}
sbError
sbiTunesAgentProcessor::ProcessTaskFile()
{
int retry = 60;
if (!OpenResultsFile()) {
return sbError("Failed to open results file to check for start!");
}
if (OpenResultsFile().tellp() == std::ofstream::pos_type(0)) {
OpenResultsFile() << '[' << SCHEMA_VERSION << ":2]\n"
<< '[' << ADDED_MEDIA_ITEMS << "]\n";
}
// Keep process all files we find
while (OpenTaskFile(mInputStream)) {
if (!mInputStream) {
// Can't open, maybe it's being written to try again
if (--retry == 0) {
return sbError("Unable to open the export track file");
}
Sleep(1000);
continue;
}
sbError const & error = Initialize();
if (error && !ErrorHandler(error)) {
return error;
}
std::string line;
std::string action;
std::string source;
int lineno = 0;
while (std::getline(mInputStream, line)) {
std::string::size_type const beginBracket =
line.find_first_not_of(" \t");
// Look for the right bracket as first non-whitespace
if (beginBracket != std::string::npos && line[beginBracket] == '[') {
std::string::size_type const endBracket = line.find_last_of(']');
if (endBracket != std::string::npos) {
std::string task = line.substr(beginBracket + 1,
endBracket - beginBracket - 1);
ParseTask(task, action, source);
if (action == SCHEMA_VERSION) {
VersionAction const versionAction = VersionCheck(source);
action.clear();
source.clear();
if (versionAction == ABORT) {
return sbError("Incompatible version encountered");
}
else if (versionAction == RETRY) {
mInputStream.close();
continue; // Will hit the inner while and it will stop
}
}
sbError error = ProcessPendingTrackBatch();
SB_ENSURE_ERRORHANDLER(error);
}
}
else {
// If there is no action then there's nothing to do yet
if (action.empty()) {
++lineno;
continue;
}
std::string::size_type const equalSign = line.find('=');
if (equalSign != std::string::npos) {
std::string const & key =
Strip(line.substr(0, equalSign));
std::string const & value =
Unescape(Strip(line.substr(equalSign + 1)));
// We've been told to add the track
if (action == ADDED_MEDIA_ITEMS) {
sbError const & error = AddTrack(source, key, value, ADDED_MEDIA_ITEMS);
SB_ENSURE_ERRORHANDLER(error);
}
else if (action == UPDATED_MEDIA_ITEMS) {
sbError const & error = UpdateTrack(key, value);
SB_ENSURE_ERRORHANDLER(error);
}
else if (action == ADDED_PLAYLISTS) {
sbError error = CreatePlaylist(value);
SB_ENSURE_ERRORHANDLER(error);
}
// We've been told to remove the playlist
else if (action == DELETED_PLAYLISTS) {
sbError error = RemovePlaylist(value);
SB_ENSURE_ERRORHANDLER(error);
}
else if (action == UPDATED_SMARTPLAYLIST) {
sbError const & error = AddTrack(source,
key,
value,
UPDATED_SMARTPLAYLIST);
SB_ENSURE_ERRORHANDLER(error);
}
else {
std::ostringstream msg;
msg << action << " is an invalid action , ignoring line "
<< lineno;
sbError error(msg.str());
SB_ENSURE_ERRORHANDLER(error);
action.clear();
}
}
else {
// If the line wasn't blank then report an error
if (!Strip(line).empty()) {
std::ostringstream msg;
msg << action
<< " is an invalid action , ignoring line " << lineno;
sbError error(msg.str());
SB_ENSURE_ERRORHANDLER(error);
}
}
}
++lineno;
if (ShouldShutdown()) {
// Notify shutdown done and exit
ShutdownDone();
return sbNoError;
}
}
if (!mTrackBatch.empty()) {
sbError const & error = ProcessPendingTrackBatch();
SB_ENSURE_ERRORHANDLER(error);
}
// Close the stream and remove the file
mInputStream.close();
mInputStream.clear();
RemoveTaskFile();
}
return sbNoError;
}
void
TrackWindow::MessageReceived( BMessage * msg )
{
switch (msg->what)
{
case VolumeQuery::BEGIN_FETCH:
{
m_fetching++;
} break;
case VolumeQuery::END_FETCH:
{
m_fetching--;
if ( !m_fetching )
{ // no more fetches underway, add to list
//printf("sorting tracks..\n");
// m_fetched_items.SortItems( compare_track_items );
//printf("adding tracks..\n");
m_list->SupressUpdates(true);
for ( int i=0; i<m_fetched_items.CountItems(); i++ )
{ // add items to list
TrackItem * item = (TrackItem*)m_fetched_items.ItemAt(i);
if ( !item )
{
//printf("Something fishy..\n");
continue;
}
AddTrack( item, false );
}
SortTracks();
m_list->SupressUpdates(false);
}
} break;
case LIST_INVOKE:
{
TrackItem * item = dynamic_cast<TrackItem*>(m_list->CurrentSelection());
if ( item )
{
// send message to playlist window!
// DON'T -- be_roster->Launch( item->GetTrack()->GetEntry() );
BMessage playmsg( PlayList::PLAY_FILE );
playmsg.AddRef( "file", item->GetTrack()->GetEntry() );
m_playlist_messenger.SendMessage( &playmsg );
} else {
BetterListItem * i = m_list->CurrentSelection();
if ( i->IsExpanded() )
m_list->Collapse( i );
else
m_list->Expand( i );
}
} break;
case B_QUERY_UPDATE:
{
int32 op = 0;
int64 node = 0;
msg->FindInt32("opcode",&op);
msg->FindInt64("node",&node);
switch ( op )
{
case B_ENTRY_CREATED:
{
const char * name;
dev_t device;
ino_t directory;
ino_t node;
msg->FindString("name", &name );
msg->FindInt64("directory", &directory);
msg->FindInt32("device", &device);
msg->FindInt64("node", &node);
bool found = false;
for ( int c=0; m_list->ItemAt(c); c++ )
{
TrackItem * item = dynamic_cast<TrackItem*>(m_list->ItemAt(c));
if ( item && item->IsNode(node) )
{
found = true;
break;
}
}
if ( !found )
{ // a new file is added
entry_ref ref( device, directory, name );
TrackItem * item = new TrackItem( new Track(&ref), false );
m_info->TrackAdded( item->GetTrack() );
if ( m_fetching )
{
m_fetched_items.AddItem( item );
} else
{
AddTrack( item );
SortTracks();
}
}
} break;
case B_ENTRY_REMOVED:
{
for ( int c=0; m_list->ItemAt(c); c++ )
{
TrackItem * item = dynamic_cast<TrackItem*>(m_list->ItemAt(c));
if ( item && item->IsNode(node) )
{
m_info->TrackRemoved( item->GetTrack() );
BetterListItem * album = m_list->Superitem(item);
m_list->RemoveItem( item );
delete item;
// remove album if empty
if ( m_list->CountItemsUnder(album,true) == 0 )
{
BetterListItem * artist = m_list->Superitem(album);
m_list->RemoveItem( album );
delete album;
// remove artist if empty
if ( m_list->CountItemsUnder(artist,true) == 0 )
{
m_list->RemoveItem( artist );
delete artist;
}
}
// if last track in album and/or last album in artist
// delete these as well
break;
}
}
} break;
default:
break;
}
} break;
default:
BWindow::MessageReceived(msg);
}
}
void FSpawnTrackEditor::HandleAddSpawnTrackMenuEntryExecute(FGuid ObjectBinding)
{
FScopedTransaction AddSpawnTrackTransaction(LOCTEXT("AddSpawnTrack_Transaction", "Add Spawn Track"));
AddTrack(GetSequencer()->GetFocusedMovieSceneSequence()->GetMovieScene(), ObjectBinding, UMovieSceneSpawnTrack::StaticClass(), NAME_None);
NotifyMovieSceneDataChanged();
}
Firnplayer::ListAlbum::ListAlbum(Json::Value * TrackJson)
{
this->Name = (*TrackJson)["TALB"].asString();
AddTrack(TrackJson);
}
Firnplayer::ListArtist::ListArtist(Json::Value * TrackJson)
{
this->Name = (*TrackJson)["TPE2"].asString();
Expanded = false;
AddTrack(TrackJson);
}
void TrackUnionStream::ProcessInput(GraphTime aFrom, GraphTime aTo,
uint32_t aFlags) {
TRACE_AUDIO_CALLBACK_COMMENT("TrackUnionStream %p", this);
if (IsFinishedOnGraphThread()) {
return;
}
AutoTArray<bool, 8> mappedTracksFinished;
AutoTArray<bool, 8> mappedTracksWithMatchingInputTracks;
for (uint32_t i = 0; i < mTrackMap.Length(); ++i) {
mappedTracksFinished.AppendElement(true);
mappedTracksWithMatchingInputTracks.AppendElement(false);
}
AutoTArray<MediaInputPort*, 32> inputs(mInputs);
inputs.AppendElements(mSuspendedInputs);
bool allFinished = !inputs.IsEmpty();
bool allHaveCurrentData = !inputs.IsEmpty();
for (uint32_t i = 0; i < inputs.Length(); ++i) {
MediaStream* stream = inputs[i]->GetSource();
if (!stream->IsFinishedOnGraphThread()) {
// XXX we really should check whether 'stream' has finished within time
// aTo, not just that it's finishing when all its queued data eventually
// runs out.
allFinished = false;
}
if (!stream->HasCurrentData()) {
allHaveCurrentData = false;
}
for (StreamTracks::TrackIter tracks(stream->GetStreamTracks());
!tracks.IsEnded(); tracks.Next()) {
bool found = false;
for (uint32_t j = 0; j < mTrackMap.Length(); ++j) {
TrackMapEntry* map = &mTrackMap[j];
if (map->mInputPort == inputs[i] &&
map->mInputTrackID == tracks->GetID()) {
bool trackFinished = false;
StreamTracks::Track* outputTrack =
mTracks.FindTrack(map->mOutputTrackID);
found = true;
if (!outputTrack || outputTrack->IsEnded() ||
!inputs[i]->PassTrackThrough(tracks->GetID())) {
trackFinished = true;
} else {
CopyTrackData(tracks.get(), j, aFrom, aTo, &trackFinished);
}
mappedTracksFinished[j] = trackFinished;
mappedTracksWithMatchingInputTracks[j] = true;
break;
}
}
if (!found && inputs[i]->AllowCreationOf(tracks->GetID())) {
bool trackFinished = false;
uint32_t mapIndex = AddTrack(inputs[i], tracks.get(), aFrom);
CopyTrackData(tracks.get(), mapIndex, aFrom, aTo, &trackFinished);
mappedTracksFinished.AppendElement(trackFinished);
mappedTracksWithMatchingInputTracks.AppendElement(true);
}
}
}
for (int32_t i = mTrackMap.Length() - 1; i >= 0; --i) {
if (mappedTracksFinished[i]) {
EndTrack(i);
} else {
allFinished = false;
}
if (!mappedTracksWithMatchingInputTracks[i]) {
for (auto listener : mTrackMap[i].mOwnedDirectListeners) {
// Remove listeners while the entry still exists.
RemoveDirectTrackListenerImpl(listener, mTrackMap[i].mOutputTrackID);
}
mTrackMap.RemoveElementAt(i);
}
}
if (allFinished && mAutofinish && (aFlags & ALLOW_FINISH)) {
// All streams have finished and won't add any more tracks, and
// all our tracks have actually finished and been removed from our map,
// so we're finished now.
FinishOnGraphThread();
}
if (allHaveCurrentData) {
// We can make progress if we're not blocked
mHasCurrentData = true;
}
}