static void Main(string[] args)
{
string mp3FilePath = args[0];
var sw = new Stopwatch();
sw.Start();
string stateJsonInit = string.Empty;
// Read json state.
using (var fs = File.OpenRead($"{mp3FilePath}.json"))
{
byte[] arrJson = new byte[fs.Length];
fs.Read(arrJson, 0, arrJson.Length);
stateJsonInit = System.Text.ASCIIEncoding.UTF8.GetString(arrJson, 0, arrJson.Length);
}
using (IStorage storage = GoogleDriveStorageFactory.Create("", "", ""))
//using(IStorage storage = new LocalStorage(""))
{
using (var file = storage.Open("/Wovenwar/Honor is Dead/World on Fire.mp3"))
//using(var file = storage.Open("World on Fire.mp3"))
{
using (var encoder = MediaEncoderExtension.EncoderByMediaType("mp3"))
{
if (encoder.Init(file, false, stateJsonInit))
{
var packets = encoder.ReadPackets(100, 50);
// // Save state json
// string stateJson;
// encoder.SaveStateIntoJson(true, out stateJson);
// // Save json state.
// using(var fs = File.OpenWrite($"{mp3FilePath}.json"))
// {
// byte[] arrJson = System.Text.ASCIIEncoding.UTF8.GetBytes(stateJson);
// fs.Write(arrJson, 0, arrJson.Length);
// }
sw.Stop();
Console.WriteLine($"Elapsed {sw.ElapsedMilliseconds}ms");
}
}
}
}
}
private void SyncMediaFileStream(MediaFile mediaFile, string copyAsFilePath, string encoderFilePath)
{
var fileStates = new MediaFileStateInfos
{
MediaFileStateJson = string.Empty,
EncoderFileStateJson = string.Empty
};
using (var file = _localStorage.Open(mediaFile.TempUrl))
{
// Generate encoder state and store as json file.
if (!string.IsNullOrEmpty(encoderFilePath))
{
var encoderStateJson = MediaEncoderExtension.GenerateEncoderState(mediaFile.Format, file, true);
if (!string.IsNullOrEmpty(encoderStateJson))
{
using (var mem = new MemoryStream(ASCIIEncoding.UTF8.GetBytes(encoderStateJson)))
{
using (var encoderFile = _mediaStorage.StoreAndGetFileStream(encoderFilePath, mem, "text/json"))
{
fileStates.EncoderFileStateJson = encoderFile.SaveStateAsJson();
}
}
}
}
using (var mediaFileStream = _mediaStorage.StoreAndGetFileStream(copyAsFilePath, file,
MediaFormatExtension.GetMimeType(mediaFile.Format)))
{
fileStates.MediaFileStateJson = mediaFileStream.SaveStateAsJson();
}
}
// Add MediaFileStateInfo entry.
_mediaDataContext.Add(new MediaFileStateInfo
{
MediaFileId = mediaFile.Id,
StateInfoJson = JsonConvert.SerializeObject(fileStates)
});
}
/// <summary>
/// Reads media packets passing delegate to read packets using different logic.
/// </summary>
/// <param name="sessionKey">Streaming session key.</param>
/// <param name="mediaId">Media identifier.</param>
/// <param name="funcReadPackets">Delegate function to read packets.</param>
/// <returns></returns>
protected AudioPackets ReadMediaPackets(string sessionKey, string songId, Func <IMediaEncoder, AudioPackets> funcReadPackets)
{
Guid gSongId, sessionId;
if (!Guid.TryParse(songId, out gSongId) || !Guid.TryParse(sessionKey, out sessionId))
{
return(null);
}
var mediaFile = (from s in _mediaDataContext.Get <Song>()
where s.Id == gSongId && s.Media.IsArchived == false
select s.Media).FirstOrDefault();
if (mediaFile == null)
{
return(null);
}
Guid playingMediaId = Guid.Empty;
int playingAtMSec = 0;
if (!_userSession.GetSessionInfo(sessionKey, out playingMediaId, out playingAtMSec))
{
throw new InvalidOperationException("Session not exists !");
}
string encoderStateJson = string.Empty, mediaFileStateJson = string.Empty;
AudioPackets packets = null;
int currentMSec = 0;
// Check media of state json.
if (playingMediaId == gSongId)
{
mediaFileStateJson = _cacheService.ReadFileState <string>(sessionKey);
encoderStateJson = _cacheService.ReadEncoderState <string>(sessionKey);
if (string.IsNullOrEmpty(encoderStateJson))
{
encoderStateJson = ReadMediaFileEncoderStateJson(mediaFile, out mediaFileStateJson);
_cacheService.SaveEncoderState(sessionKey, encoderStateJson);
}
}
else
{
encoderStateJson = ReadMediaFileEncoderStateJson(mediaFile, out mediaFileStateJson);
_cacheService.SaveEncoderState(sessionKey, encoderStateJson);
_cacheService.SaveFileState(sessionKey, mediaFileStateJson);
}
using (var media = string.IsNullOrEmpty(mediaFileStateJson) ?
_storage.Open(mediaFile.Url) :
_storage.OpenAndRestoreState(mediaFile.Url, mediaFileStateJson))
{
IMediaEncoder encoder = MediaEncoderExtension.EncoderByMediaType(mediaFile.Format);
if (encoder == null)
{
throw new InvalidOperationException($"Unable to instantiate encoder by format = '{mediaFile.Format}'!");
}
if (encoder.Init(media, false, encoderStateJson))
{
packets = funcReadPackets.Invoke(encoder);
if (packets != null)
{
// if(encoder.SaveStateIntoJson(out encoderStateJson))
// {
// // Save encoder state in cache.
// SaveEncoderStateInCache(sessionKey, encoderStateJson);
// }
currentMSec = (int)encoder.CurrentMs;
}
}
// Save media file state in cache.
if (string.IsNullOrEmpty(mediaFileStateJson))
{
_cacheService.SaveFileState(sessionKey, media.SaveStateAsJson());
}
// ???
//encoder.Dispose();
}
// Update playing session info.
_userSession.UpdateSessionInfo(sessionKey, gSongId, currentMSec);
return(packets);
}
