static void biasSelection(float value)
{
int track, row;
struct sync_track** tracks = getTracks();
TrackViewInfo* viewInfo = getTrackViewInfo();
int selectLeft = mini(viewInfo->selectStartTrack, viewInfo->selectStopTrack);
int selectRight = maxi(viewInfo->selectStartTrack, viewInfo->selectStopTrack);
int selectTop = mini(viewInfo->selectStartRow, viewInfo->selectStopRow);
int selectBottom = maxi(viewInfo->selectStartRow, viewInfo->selectStopRow);
// If we have no selection and no currenty key bias the previous key
if (selectLeft == selectRight && selectTop == selectBottom)
{
int idx;
struct sync_track* track;
struct sync_track** tracks = getTracks();
if (!tracks || !tracks[getActiveTrack()]->keys)
return;
track = tracks[getActiveTrack()];
idx = sync_find_key(track, getRowPos());
if (idx < 0)
{
idx = -idx - 1;
selectTop = selectBottom = track->keys[emaxi(idx - 1, 0)].row;
}
}
Commands_beginMulti("biasSelection");
for (track = selectLeft; track <= selectRight; ++track)
{
struct sync_track* t = tracks[track];
for (row = selectTop; row <= selectBottom; ++row)
{
struct track_key newKey;
int idx = sync_find_key(t, row);
if (idx < 0)
continue;
newKey = t->keys[idx];
newKey.value += value;
Commands_updateKey(track, &newKey);
}
}
Commands_endMulti();
updateNeedsSaving();
}
static void endEditing()
{
const char* track_name;
struct track_key key;
struct sync_track* track;
int row_pos = getRowPos();
int active_track = getActiveTrack();
if (!is_editing || !getTracks())
return;
track = getTracks()[active_track];
if (strcmp(s_editBuffer, ""))
{
key.row = row_pos;
key.value = (float)atof(s_editBuffer);
key.type = 0;
if (track->num_keys > 0)
{
int idx = sync_find_key(track, getRowPos());
if (idx > 0)
{
// exact match, keep current type
key.type = track->keys[emaxi(idx, 0)].type;
}
else
{
// no match, grab type from previous key
if (idx < 0)
idx = -idx - 1;
key.type = track->keys[emaxi(idx - 1, 0)].type;
}
}
track_name = track->name;
Commands_addOrUpdateKey(active_track, &key);
updateNeedsSaving();
}
is_editing = false;
s_editorData.trackData.editText = 0;
}
void UserMediaRequest::allow(const String& audioDeviceUID, const String& videoDeviceUID)
{
m_allowedAudioDeviceUID = audioDeviceUID;
m_allowedVideoDeviceUID = videoDeviceUID;
RefPtr<UserMediaRequest> protectedThis = this;
RealtimeMediaSourceCenter::NewMediaStreamHandler callback = [this, protectedThis = WTFMove(protectedThis)](RefPtr<MediaStreamPrivate>&& privateStream) mutable {
if (!m_scriptExecutionContext)
return;
if (!privateStream) {
deny(MediaAccessDenialReason::HardwareError, emptyString());
return;
}
auto stream = MediaStream::create(*m_scriptExecutionContext, WTFMove(privateStream));
if (stream->getTracks().isEmpty()) {
deny(MediaAccessDenialReason::HardwareError, emptyString());
return;
}
for (auto& track : stream->getAudioTracks())
track->source().startProducingData();
for (auto& track : stream->getVideoTracks())
track->source().startProducingData();
m_promise.resolve(stream);
};
RealtimeMediaSourceCenter::singleton().createMediaStream(WTFMove(callback), m_allowedAudioDeviceUID, m_allowedVideoDeviceUID, &m_audioConstraints.get(), &m_videoConstraints.get());
}
///\brief Builds an index file for HTTP Dynamic streaming.
///\return The index file for HTTP Dynamic Streaming.
std::string OutHDS::dynamicIndex(){
getTracks();
std::stringstream Result;
Result << "<?xml version=\"1.0\" encoding=\"utf-8\"?>" << std::endl;
Result << " <manifest xmlns=\"http://ns.adobe.com/f4m/1.0\">" << std::endl;
Result << " <id>" << streamName << "</id>" << std::endl;
Result << " <mimeType>video/mp4</mimeType>" << std::endl;
Result << " <deliveryType>streaming</deliveryType>" << std::endl;
if (myMeta.vod){
Result << " <duration>" << myMeta.tracks[*videoTracks.begin()].lastms / 1000 << ".000</duration>" << std::endl;
Result << " <streamType>recorded</streamType>" << std::endl;
}else{
Result << " <duration>0.00</duration>" << std::endl;
Result << " <streamType>live</streamType>" << std::endl;
}
for (std::set<int>::iterator it = videoTracks.begin(); it != videoTracks.end(); it++){
Result << " <bootstrapInfo "
"profile=\"named\" "
"id=\"boot" << (*it) << "\" "
"url=\"" << (*it) << ".abst\">"
"</bootstrapInfo>" << std::endl;
Result << " <media "
"url=\"" << (*it) << "-\" "
"bitrate=\"" << myMeta.tracks[(*it)].bps * 8 << "\" "
"bootstrapInfoId=\"boot" << (*it) << "\" "
"width=\"" << myMeta.tracks[(*it)].width << "\" "
"height=\"" << myMeta.tracks[(*it)].height << "\">" << std::endl;
Result << " <metadata>AgAKb25NZXRhRGF0YQMAAAk=</metadata>" << std::endl;
Result << " </media>" << std::endl;
}
Result << "</manifest>" << std::endl;
DEBUG_MSG(DLVL_HIGH, "Sending manifest: %s", Result.str().c_str());
return Result.str();
} //BuildManifest
static void deleteArea(int rowPos, int track, int bufferWidth, int bufferHeight)
{
int i, j;
const int track_count = getTrackCount();
struct sync_track** tracks = getTracks();
Commands_beginMulti("deleteArea");
for (i = 0; i < bufferWidth; ++i)
{
struct sync_track* t;
int trackPos = track + i;
int trackIndex = trackPos;
if (trackPos >= track_count)
continue;
t = tracks[trackIndex];
for (j = 0; j < bufferHeight; ++j)
{
int row = rowPos + j;
Commands_deleteKey(trackIndex, row);
}
}
Commands_endMulti();
updateNeedsSaving();
}
void MusicCollection::displayTracks() {
std::cout << "\nTracks\n-----------------------------\n";
MusicTrackIterator it = getTracks();
while( it.hasNext() ) {
MusicTrack *track = it.next();
std::cout << track->getTitle() << std::endl;
}
}
ChessPiece::Moves& ChessPiece::getValidMoves()
{
if( !m_validMoves.size() )
{
// calculate valid moves from current position
Tracks tracks = getTracks();
for( Tracks::const_iterator i = getTracks().begin(); i != getTracks().end(); i++ )
{
const Position::Track& track = *i;
if( m_currentPos.isValidMove( track ) )
{
Position newPos = m_currentPos + track;
m_validMoves.push_back( newPos );
}
}
}
return m_validMoves;
}
void ofxTLPage::draw(){
ofSetLineWidth(1);
for(int i = 0; i < headers.size(); i++){
//for(int i = headers.size() - 1; i >= 0; i--){
headers[i]->draw();
tracks[headers[i]->name]->_draw();
}
#if 0
// snap from bottom of ticker to bottom edge of timeline
//if(!headerHasFocus && !footerIsDragging && draggingInside && snapPoints.size() > 0){
ofPushStyle();
//ofSetColor(255,255,255,100);
ofSetColor(0, 0, 0,200);
set<unsigned long>::iterator it;
// for(int i = 0; i < snapPoints.size(); i++){
vector<ofxTLTrack*>::iterator t = getTracks().begin();
if (getTracks().size() >= 3) { t++; t++; }
for(it = snapPoints.begin(); it != snapPoints.end(); it++){
//ofLine(timeline->millisToScreenX(*it), trackContainerRect.y, timeline->millisToScreenX(*it), trackContainerRect.y+trackContainerRect.height);
float x = timeline->millisToScreenX(*it);
float y1 = (*t)->getDrawRect().y;
float y2 = y1 + (*t)->getDrawRect().height;
ofLine(x, y1, x, y2);
}
ofPopStyle();
//}
#endif
// for(int i = 0; i < headers.size(); i++){
// tracks[headers[i]->name]->drawModalContent();
// }
ofSetLineWidth(1);
if(draggingSelectionRectangle){
ofFill();
ofSetColor(timeline->getColors().keyColor, 30);
ofRect(selectionRectangle);
ofNoFill();
ofSetColor(timeline->getColors().keyColor, 255);
ofRect(selectionRectangle);
}
}
int MusicCollection::generateTrackList(std::ostream& out) {
int count = 0;
MusicTrackIterator iter = getTracks();
while( iter.hasNext() ) {
MusicTrack *track = iter.next();
out << track->getLocation().toStdString() << std::endl;
count++;
}
return count;
}
// ----------------------------------------------------------------------------
//
void SpotifyEngine::queueTracks( sp_playlist* pl )
{
CSingleLock lock( &m_mutex, TRUE );
for ( auto const& track : getTracks(pl) )
m_track_queue.push_back( TrackQueueEntry( track, 0L ) );
sendCommand( CMD_CHECK_PLAYING );
sendTrackQueueEvent();
}
// ----------------------------------------------------------------------------
//
void SpotifyEngine::playTracks( sp_playlist* pl )
{
CSingleLock lock( &m_mutex, TRUE );
m_track_queue.clear();
for ( auto const& track : getTracks(pl) )
m_track_queue.push_back( TrackQueueEntry( track, 0L ) );
sendCommand( CMD_NEXT_TRACK );
sendTrackQueueEvent();
}
static void onPrevNextKey(bool prevKey, enum Selection selection)
{
struct sync_track* track;
struct sync_track** tracks = getTracks();
TrackViewInfo* viewInfo = getTrackViewInfo();
if (!tracks || !tracks[getActiveTrack()]->keys)
return;
track = tracks[getActiveTrack()];
if (prevKey)
{
int idx = sync_find_key(track, getRowPos());
if (idx < 0)
idx = -idx - 1;
setRowPos(track->keys[emaxi(idx - 1, 0)].row);
if (selection == DO_SELECTION)
viewInfo->selectStopRow = getRowPos();
else
viewInfo->selectStartRow = viewInfo->selectStopRow = getRowPos();
}
else
{
int row = 0;
int idx = key_idx_floor(track, getRowPos());
if (idx < 0)
row = track->keys[0].row;
else if (idx > (int)track->num_keys - 2)
row = track->keys[track->num_keys - 1].row;
else
row = track->keys[idx + 1].row;
setRowPos(row);
if (selection == DO_SELECTION)
viewInfo->selectStopRow = row;
else
viewInfo->selectStartRow = viewInfo->selectStopRow = row;
}
}
static void onEnterCurrentValue()
{
int idx;
struct track_key key;
struct sync_track* track;
struct sync_track** tracks = getTracks();
const int rowPos = getRowPos();
const int activeTrack = getActiveTrack();
if (!tracks)
return;
track = tracks[activeTrack];
if (!track->keys)
{
key.row = rowPos;
key.value = 0.0f;
key.type = 0;
Commands_addOrUpdateKey(activeTrack, &key);
updateNeedsSaving();
return;
}
idx = sync_find_key(track, rowPos);
if (idx < 0)
idx = -idx - 1;
key.row = rowPos;
if (track->num_keys > 0)
{
key.value = (float)sync_get_val(track, rowPos);
key.type = track->keys[emaxi(idx - 1, 0)].type;
}
else
{
key.value = 0.0f;
key.type = 0;
}
Commands_addOrUpdateKey(activeTrack, &key);
updateNeedsSaving();
}
static void copySelection(int row, int track, int selectLeft, int selectRight, int selectTop, int selectBottom)
{
CopyEntry* entry = 0;
int copy_count = 0;
struct sync_track** tracks = getTracks();
// Count how much we need to copy
for (track = selectLeft; track <= selectRight; ++track)
{
struct sync_track* t = tracks[track];
for (row = selectTop; row <= selectBottom; ++row)
{
int idx = sync_find_key(t, row);
if (idx < 0)
continue;
copy_count++;
}
}
free(s_copyData.entries);
entry = s_copyData.entries = malloc(sizeof(CopyEntry) * copy_count);
for (track = selectLeft; track <= selectRight; ++track)
{
struct sync_track* t = tracks[track];
for (row = selectTop; row <= selectBottom; ++row)
{
int idx = sync_find_key(t, row);
if (idx < 0)
continue;
entry->track = track - selectLeft;
entry->keyFrame = t->keys[idx];
entry->keyFrame.row -= selectTop;
entry++;
}
}
s_copyData.bufferWidth = selectRight - selectLeft + 1;
s_copyData.bufferHeight = selectBottom - selectTop + 1;
s_copyData.count = copy_count;
}
std::vector<Database::IdType>
getSimilarArtists(Wt::Dbo::Session& session, Database::IdType artistId, std::size_t maxCount)
{
std::vector<Database::IdType> res;
Wt::Dbo::Transaction transaction(session);
auto artist = Database::Artist::getById(session, artistId);
if (!artist)
return res;
auto artistTracks = artist->getTracks();
std::set<Database::IdType> artistTrackIds;
for (const auto& artistTrack : artistTracks)
artistTrackIds.insert(artistTrack.id());
auto trackIds = getSimilarTracks(session, artistTrackIds, maxCount * 5);
for (auto trackId : trackIds)
{
auto track = Database::Track::getById(session, trackId);
if (!track)
continue;
for (auto trackArtist : track->getArtists())
{
if (!trackArtist || trackArtist.id() == artistId)
continue;
if (std::find(res.begin(), res.end(), trackArtist.id()) != res.end())
continue;
res.push_back(trackArtist.id());
}
if (res.size() == maxCount)
break;
}
return res;
}
std::vector<Database::IdType>
getSimilarReleases(Wt::Dbo::Session& session, Database::IdType releaseId, std::size_t maxCount)
{
std::vector<Database::IdType> res;
Wt::Dbo::Transaction transaction(session);
auto release = Database::Release::getById(session, releaseId);
if (!release)
return res;
auto releaseTracks = release->getTracks();
std::set<Database::IdType> releaseTrackIds;
for (const auto& releaseTrack : releaseTracks)
releaseTrackIds.insert(releaseTrack.id());
auto trackIds = getSimilarTracks(session, releaseTrackIds, maxCount * 5);
for (auto trackId : trackIds)
{
auto track = Database::Track::getById(session, trackId);
if (!track)
continue;
auto trackRelease = track->getRelease();
if (!trackRelease || trackRelease.id() == releaseId)
continue;
if (std::find(res.begin(), res.end(), trackRelease.id()) != res.end())
continue;
res.push_back(trackRelease.id());
if (res.size() == maxCount)
break;
}
return res;
}
static int drawCurrentValue(int posX, int sizeY)
{
char valueText[256];
float value = 0.0f;
int active_track = 0;
int current_row = 0;
const char *str = "---";
struct sync_track** tracks = getTracks();
active_track = getActiveTrack();
current_row = getRowPos();
if (tracks)
{
const struct sync_track* track = tracks[active_track];
int idx = key_idx_floor(track, current_row);
if (idx >= 0)
{
switch (track->keys[idx].type)
{
case KEY_STEP: str = "step"; break;
case KEY_LINEAR: str = "linear"; break;
case KEY_SMOOTH: str = "smooth"; break;
case KEY_RAMP: str = "ramp"; break;
default: break;
}
}
value = (float)sync_get_val(track, current_row);
}
snprintf(valueText, 256, "%f", value);
Emgui_drawText(valueText, posX + 4, sizeY - 15, Emgui_color32(160, 160, 160, 255));
Emgui_drawBorder(Emgui_color32(10, 10, 10, 255), Emgui_color32(10, 10, 10, 255), posX, sizeY - 17, 80, 15);
Emgui_drawText(str, posX + 85, sizeY - 15, Emgui_color32(160, 160, 160, 255));
Emgui_drawBorder(Emgui_color32(10, 10, 10, 255), Emgui_color32(10, 10, 10, 255), posX + 80, sizeY - 17, 40, 15);
return 130;
}
static void onInterpolation()
{
int idx;
struct track_key newKey;
struct sync_track* track;
struct sync_track** tracks = getTracks();
if (!tracks)
return;
track = tracks[getActiveTrack()];
idx = key_idx_floor(track, getRowPos());
if (idx < 0)
return;
newKey = track->keys[idx];
newKey.type = ((newKey.type + 1) % KEY_TYPE_COUNT);
Commands_addOrUpdateKey(getActiveTrack(), &newKey);
updateNeedsSaving();
}
static void onSelectTrack()
{
int activeTrack = getActiveTrack();
TrackViewInfo* viewInfo = getTrackViewInfo();
struct sync_track** tracks;
struct sync_track* track;
if (!(tracks = getTracks()))
return;
track = tracks[activeTrack];
viewInfo->selectStartTrack = viewInfo->selectStopTrack = activeTrack;
if (track->keys)
{
viewInfo->selectStartRow = track->keys[0].row;
viewInfo->selectStopRow = track->keys[track->num_keys - 1].row;
}
else
{
viewInfo->selectStartRow = viewInfo->selectStopRow = getRowPos();
}
}
void SoundCloudPlaylistWindow::onPlaylistStatusChanged(QSoundCloud::ResourcesRequest::Status status) {
switch (status) {
case QSoundCloud::ResourcesRequest::Loading:
showProgressIndicator();
return;
case QSoundCloud::ResourcesRequest::Ready:
loadPlaylistUi();
getTracks();
connect(m_artist, SIGNAL(statusChanged(QSoundCloud::ResourcesRequest::Status)), this,
SLOT(onArtistStatusChanged(QSoundCloud::ResourcesRequest::Status)));
m_artist->loadArtist(m_playlist->artistId());
break;
case QSoundCloud::ResourcesRequest::Failed:
QMessageBox::critical(this, tr("Error"), m_playlist->errorString());
break;
default:
break;
}
hideProgressIndicator();
disconnect(m_playlist, SIGNAL(statusChanged(QSoundCloud::ResourcesRequest::Status)),
this, SLOT(onPlaylistStatusChanged(QSoundCloud::ResourcesRequest::Status)));
}
SoundCloudPlaylistWindow::SoundCloudPlaylistWindow(SoundCloudPlaylist *playlist, StackedWindow *parent) :
StackedWindow(parent),
m_playlist(new SoundCloudPlaylist(playlist, this)),
m_artist(new SoundCloudArtist(this)),
m_model(new SoundCloudTrackModel(this)),
m_cache(new ImageCache),
m_thumbnail(new Image(this)),
m_avatar(new Image(this)),
m_nowPlayingAction(new NowPlayingAction(this)),
m_view(new ListView(this)),
m_delegate(new TrackDelegate(m_cache, SoundCloudTrackModel::ArtistRole, SoundCloudTrackModel::DateRole,
SoundCloudTrackModel::DurationStringRole, SoundCloudTrackModel::ThumbnailUrlRole,
SoundCloudTrackModel::TitleRole, this)),
m_scrollArea(new QScrollArea(this)),
m_titleLabel(new QLabel(this)),
m_descriptionLabel(new TextBrowser(this)),
m_dateLabel(new QLabel(this)),
m_artistLabel(new QLabel(this)),
m_noTracksLabel(new QLabel(QString("<p align='center'; style='font-size: 40px; color: %1'>%2</p>")
.arg(palette().color(QPalette::Mid).name()).arg(tr("No tracks found")), this)),
m_reloadAction(new QAction(tr("Reload"), this)),
m_queuePlaylistAction(new QAction(tr("Queue"), this)),
m_contextMenu(new QMenu(this)),
m_queueAction(new QAction(tr("Queue"), this)),
m_downloadAction(new QAction(tr("Download"), this)),
m_shareAction(new QAction(tr("Copy URL"), this)),
m_favouriteAction(0)
{
loadBaseUi();
loadPlaylistUi();
getTracks();
connect(m_artist, SIGNAL(statusChanged(QSoundCloud::ResourcesRequest::Status)), this,
SLOT(onArtistStatusChanged(QSoundCloud::ResourcesRequest::Status)));
m_artist->loadArtist(playlist->artistId());
}
bool AudioCDDemux::open( const QString &_url )
{
#ifdef Q_OS_WIN
if ( _url.toLower().contains( QRegExp( "file://\\D:/track\\d\\d.cda" ) ) )
{
QString url = _url;
url.remove( "file://" );
device = url.mid( 0, url.indexOf( '/' ) );
trackNo = url.mid( url.toLower().indexOf( "track" ) + 5, 2 ).toUInt();
}
else
#endif
{
if ( _url.left( 10 ) != "AudioCD://" )
return false;
QUrl url( _url.mid( 10 ) );
device = QUrlQuery( url ).queryItemValue( "device" );
trackNo = url.path().toUInt();
}
if ( trackNo > 0 && trackNo < CDIO_INVALID_TRACK )
{
cdio = destroyTimer.getInstance( device, discID );
if ( cdio || ( cdio = cdio_open( device.toLocal8Bit(), DRIVER_UNKNOWN ) ) )
{
cdio_set_speed( cdio, 1 );
numTracks = cdio_get_num_tracks( cdio );
if ( cdio_get_discmode( cdio ) != CDIO_DISC_MODE_ERROR && numTracks > 0 && numTracks != CDIO_INVALID_TRACK )
{
chn = cdio_get_track_channels( cdio, trackNo );
if ( numTracks >= trackNo && ( chn == 2 || chn == 4 ) )
{
if ( useCDTEXT )
{
readCDText( 0 );
readCDText( trackNo );
}
isData = cdio_get_track_format( cdio, trackNo ) != TRACK_FORMAT_AUDIO;
duration = CD_BLOCKSIZE / chn / ( double )srate;
startSector = cdio_get_track_lsn( cdio, trackNo );
numSectors = cdio_get_track_last_lsn( cdio, trackNo ) - startSector;
if ( useCDDB && Title.isEmpty() )
{
cddb_disc_t *cddb_disc;
if ( freedb_query( cddb_disc ) )
{
if ( cdTitle.isEmpty() && cdArtist.isEmpty() )
freedb_get_disc_info( cddb_disc );
freedb_get_track_info( cddb_disc );
cddb_disc_destroy( cddb_disc );
}
}
StreamInfo *streamInfo = new StreamInfo;
streamInfo->type = QMPLAY2_TYPE_AUDIO;
streamInfo->is_default = true;
streamInfo->sample_rate = srate;
streamInfo->channels = chn;
streams_info += streamInfo;
return true;
}
else
QMPlay2Core.log( tr( "Błąd odczytu ścieżki" ) );
}
else
QMPlay2Core.log( tr( "Brak płyty w napędzie" ) );
}
else
QMPlay2Core.log( tr( "Nieprawidłowa ścieżka do napędu CD" ) );
}
else //dodawanie do listy ścieżek AudioCD
{
#ifndef Q_OS_WIN
device = QUrl( _url ).path();
#else
device = _url.mid( strlen( AudioCDName"://" ), 2 );
#endif
#ifndef Q_OS_WIN
if ( !QFileInfo( device ).isDir() )
#endif
if ( !device.isEmpty() )
{
emit QMPlay2Core.processParam( "DelPlaylistEntries", _url );
QList< Playlist::Entry > entries = getTracks( device );
if ( !entries.isEmpty() && Playlist::write( entries, "file://" + AudioCDPlaylist ) )
{
emit QMPlay2Core.processParam( "open", AudioCDPlaylist );
return true;
}
}
}
return false;
}
std::vector<Track> Manager::getVideoTracks()
{
return getTracks(videoTracks);
}
std::vector<Track> Manager::getAudioTracks()
{
return getTracks(audioTracks);
}
void Context::open(const char * file)
{
fh = MP4Read(file, 0);
if (fh == MP4_INVALID_FILE_HANDLE) throw Exception(file, "Open failed");
getTracks(file);
}
std::vector<Track> Manager::getSubtitleTracks()
{
return getTracks(subtitleTracks);
}
std::vector<Track> Manager::getTeletextTracks()
{
return getTracks(teletextTracks);
}
void OutHDS::onHTTP(){
if (H.url.find(".abst") != std::string::npos){
initialize();
std::string streamID = H.url.substr(streamName.size() + 10);
streamID = streamID.substr(0, streamID.find(".abst"));
H.Clean();
H.SetBody(dynamicBootstrap(atoll(streamID.c_str())));
H.SetHeader("Content-Type", "binary/octet");
H.SetHeader("Cache-Control", "no-cache");
H.SendResponse("200", "OK", myConn);
H.Clean(); //clean for any possible next requests
return;
}
if (H.url.find("f4m") == std::string::npos){
initialize();
std::string tmp_qual = H.url.substr(H.url.find("/", 10) + 1);
unsigned int tid;
unsigned int fragNum;
tid = atoi(tmp_qual.substr(0, tmp_qual.find("Seg") - 1).c_str());
int temp;
temp = H.url.find("Seg") + 3;
temp = H.url.find("Frag") + 4;
fragNum = atoi(H.url.substr(temp).c_str()) - 1;
DEBUG_MSG(DLVL_MEDIUM, "Video track %d, fragment %d\n", tid, fragNum);
if (!audioTrack){getTracks();}
unsigned int mstime = 0;
unsigned int mslen = 0;
if (fragNum < (unsigned int)myMeta.tracks[tid].missedFrags){
H.Clean();
H.SetBody("The requested fragment is no longer kept in memory on the server and cannot be served.\n");
H.SendResponse("412", "Fragment out of range", myConn);
H.Clean(); //clean for any possible next requests
std::cout << "Fragment " << fragNum << " too old" << std::endl;
return;
}
//delay if we don't have the next fragment available yet
unsigned int timeout = 0;
while (myConn && fragNum >= myMeta.tracks[tid].missedFrags + myMeta.tracks[tid].fragments.size() - 1){
//time out after 21 seconds
if (++timeout > 42){
myConn.close();
break;
}
Util::sleep(500);
updateMeta();
}
mstime = myMeta.tracks[tid].getKey(myMeta.tracks[tid].fragments[fragNum - myMeta.tracks[tid].missedFrags].getNumber()).getTime();
mslen = myMeta.tracks[tid].fragments[fragNum - myMeta.tracks[tid].missedFrags].getDuration();
VERYHIGH_MSG("Playing from %llu for %llu ms", mstime, mslen);
selectedTracks.clear();
selectedTracks.insert(tid);
if (audioTrack){
selectedTracks.insert(audioTrack);
}
seek(mstime);
playUntil = mstime + mslen;
H.Clean();
H.SetHeader("Content-Type", "video/mp4");
H.StartResponse(H, myConn);
//send the bootstrap
std::string bootstrap = dynamicBootstrap(tid);
H.Chunkify(bootstrap, myConn);
//send a zero-size mdat, meaning it stretches until end of file.
H.Chunkify("\000\000\000\000mdat", 8, myConn);
//send init data, if needed.
if (audioTrack > 0 && myMeta.tracks[audioTrack].init != ""){
if (tag.DTSCAudioInit(myMeta.tracks[audioTrack])){
tag.tagTime(mstime);
H.Chunkify(tag.data, tag.len, myConn);
}
}
if (tid > 0){
if (tag.DTSCVideoInit(myMeta.tracks[tid])){
tag.tagTime(mstime);
H.Chunkify(tag.data, tag.len, myConn);
}
}
parseData = true;
wantRequest = false;
}else{
initialize();
std::stringstream tmpstr;
myMeta.toPrettyString(tmpstr);
H.Clean();
H.SetHeader("Content-Type", "text/xml");
H.SetHeader("Cache-Control", "no-cache");
H.SetBody(dynamicIndex());
H.SendResponse("200", "OK", myConn);
}
}
bool KIso::openArchive(QIODevice::OpenMode mode)
{
KISOFUNC;
iso_vol_desc *desc;
QString path, uid, gid;
QT_STATBUF buf;
int tracks[2*100], trackno = 0, i, access, c_b, c_i, c_j;
KArchiveDirectory *root;
struct iso_directory_record* idr;
struct el_torito_boot_descriptor* bootdesc;
if (mode == QIODevice::WriteOnly)
return false;
readParams();
d->dirList.clear();
tracks[0] = 0;
if (m_startsec > 0) tracks[0] = m_startsec;
//qDebug() << " m_startsec: " << m_startsec << endl;
/* We'll use the permission and user/group of the 'host' file except
* in Rock Ridge, where the permissions are stored on the file system
*/
if (QT_STAT(m_filename.toLocal8Bit(), &buf) < 0) {
/* defaults, if stat fails */
memset(&buf, 0, sizeof(struct stat));
buf.st_mode = 0777;
} else {
/* If it's a block device, try to query the track layout (for multisession) */
if (m_startsec == -1 && S_ISBLK(buf.st_mode))
trackno = getTracks(m_filename.toLatin1(), (int*) & tracks);
}
uid.setNum(buf.st_uid);
gid.setNum(buf.st_gid);
access = buf.st_mode & ~S_IFMT;
//qDebug() << "KIso::openArchive number of tracks: " << trackno << endl;
if (trackno == 0) trackno = 1;
for (i = 0;i < trackno;++i) {
c_b = 1;c_i = 1;c_j = 1;
root = rootDir();
if (trackno > 1) {
path.clear();
QTextStream(&path) << "Track " << tracks[(i<<1)+1];
root = new KIsoDirectory(this, path, access | S_IFDIR,
buf.st_mtime, buf.st_atime, buf.st_ctime, uid, gid, QString());
rootDir()->addEntry(root);
}
desc = ReadISO9660(&readf, tracks[i<<1], this);
if (!desc) {
//qDebug() << "KIso::openArchive no volume descriptors" << endl;
continue;
}
while (desc) {
switch (isonum_711(desc->data.type)) {
case ISO_VD_BOOT:
bootdesc = (struct el_torito_boot_descriptor*) & (desc->data);
if (!memcmp(EL_TORITO_ID, bootdesc->system_id, ISODCL(8, 39))) {
path = "El Torito Boot";
if (c_b > 1) path += " (" + QString::number(c_b) + ')';
dirent = new KIsoDirectory(this, path, access | S_IFDIR,
buf.st_mtime, buf.st_atime, buf.st_ctime, uid, gid, QString());
root->addEntry(dirent);
addBoot(bootdesc);
c_b++;
}
break;
case ISO_VD_PRIMARY:
case ISO_VD_SUPPLEMENTARY:
idr = (struct iso_directory_record*) & (((struct iso_primary_descriptor*) & desc->data)->root_directory_record);
joliet = JolietLevel(&desc->data);
if (joliet) {
QTextStream(&path) << "Joliet level " << joliet;
if (c_j > 1) path += " (" + QString::number(c_j) + ')';
} else {
path = "ISO9660";
if (c_i > 1) path += " (" + QString::number(c_i) + ')';
}
dirent = new KIsoDirectory(this, path, access | S_IFDIR,
buf.st_mtime, buf.st_atime, buf.st_ctime, uid, gid, QString());
root->addEntry(dirent);
level = 0;
mycallb(idr, this);
if (joliet) c_j++; else c_i++;
break;
}
desc = desc->next;
}
free(desc);
}
device()->close();
return true;
}
