| Archiv für April 2011 Donnerstag, 14. April 2011 Das FFmpeg.exe hat Problem mit Videofiles über 5-6mb Größe. Grund dafür ist, dass die FFmpeg.exe den Application pool aufhängt und seinen Ram verschlingt. Daher musste ich den Code des Prozessaufrufes umbauen. Folgender Code funktioniert auch mit Files weit über 2gb. ProcessStartInfo oInfo = new ProcessStartInfo(this._ffExe, Parameters);
oInfo.WorkingDirectory = Path.GetDirectoryName(this._ffExe);
oInfo.UseShellExecute = false;
oInfo.CreateNoWindow = true;
oInfo.RedirectStandardOutput = true;
oInfo.RedirectStandardError = true;
using (Process proc = System.Diagnostics.Process.Start(oInfo)) {
using (StreamReader srOutput = proc.StandardError) {
System.Text.StringBuilder output = new System.Text.StringBuilder();
using (StreamReader objStreamReader = proc.StandardError) {
System.Text.StringBuilder sbOutPut = new StringBuilder();
while (!proc.WaitForExit(1000)) {
sbOutPut.Append(objStreamReader.ReadToEnd().ToString());
}
if (proc.ExitCode == 0) {
proc.Close();
if (objStreamReader != null) {
objStreamReader.Close();
}
} else {
proc.Close();
if (objStreamReader != null) {
objStreamReader.Close();
}
}
return sbOutPut.ToString();
}
}
}Schlagworte:C#, ffmpeg, große dateien, Problem, prozess
Veröffentlicht in Programmierung, Webprogrammierung | Keine Kommentare » Donnerstag, 14. April 2011Folgender Code beinhaltet eine Classe, welche mit Hilfe der ffmpeg.exe die VideoInformationen auslesen kann oder ein Video konvertieren kann. Code wurde hier gefunden Die ffmpeg.exe könnt ihr hier downloaden: download public class Converter {
#region Properties
private string _ffExe;
public string ffExe {
get {
return _ffExe;
}
set {
_ffExe = value;
}
}
private string _WorkingPath;
public string WorkingPath {
get {
return _WorkingPath;
}
set {
_WorkingPath = value;
}
}
#endregion
#region Constructors
public Converter() {
Initialize();
}
public Converter(string ffmpegExePath) {
_ffExe = ffmpegExePath;
Initialize();
}
#endregion
#region Initialization
private void Initialize() {
//first make sure we have a value for the ffexe file setting
if (string.IsNullOrEmpty(_ffExe)) {
object o = ConfigurationManager.AppSettings["ffmpeg:ExeLocation"];
if (o == null) {
throw new Exception("Could not find the location of the ffmpeg exe file. The path for ffmpeg.exe " +
"can be passed in via a constructor of the ffmpeg class (this class) or by setting in the app.config or web.config file. " +
"in the appsettings section, the correct property name is: ffmpeg:ExeLocation");
} else {
if (string.IsNullOrEmpty(o.ToString())) {
throw new Exception("No value was found in the app setting for ffmpeg:ExeLocation");
}
_ffExe = o.ToString();
}
}
//Now see if ffmpeg.exe exists
string workingpath = GetWorkingFile();
if (string.IsNullOrEmpty(workingpath)) {
//ffmpeg doesn't exist at the location stated.
throw new Exception("Could not find a copy of ffmpeg.exe");
}
_ffExe = workingpath;
//now see if we have a temporary place to work
if (string.IsNullOrEmpty(_WorkingPath)) {
object o = ConfigurationManager.AppSettings["ffmpeg:WorkingPath"];
if (o != null) {
_WorkingPath = o.ToString();
} else {
_WorkingPath = string.Empty;
}
}
}
private string GetWorkingFile() {
//try the stated directory
if (File.Exists(_ffExe)) {
return _ffExe;
}
//oops, that didn't work, try the base directory
if (File.Exists(Path.GetFileName(_ffExe))) {
return Path.GetFileName(_ffExe);
}
//well, now we are really unlucky, let's just return null
return null;
}
#endregion
#region Get the File without creating a file lock
public static System.Drawing.Image LoadImageFromFile(string fileName) {
System.Drawing.Image theImage = null;
using (FileStream fileStream = new FileStream(fileName, FileMode.Open,
FileAccess.Read)) {
byte[] img;
img = new byte[fileStream.Length];
fileStream.Read(img, 0, img.Length);
fileStream.Close();
theImage = System.Drawing.Image.FromStream(new MemoryStream(img));
img = null;
}
GC.Collect();
return theImage;
}
public static MemoryStream LoadMemoryStreamFromFile(string fileName) {
MemoryStream ms = null;
using (FileStream fileStream = new FileStream(fileName, FileMode.Open,
FileAccess.Read)) {
byte[] fil;
fil = new byte[fileStream.Length];
fileStream.Read(fil, 0, fil.Length);
fileStream.Close();
ms = new MemoryStream(fil);
}
GC.Collect();
return ms;
}
#endregion
#region Run the process
private string RunProcess(string Parameters) {
//create a process info
ProcessStartInfo oInfo = new ProcessStartInfo(this._ffExe, Parameters);
oInfo.UseShellExecute = false;
oInfo.CreateNoWindow = true;
oInfo.RedirectStandardOutput = true;
oInfo.RedirectStandardError = true;
//Create the output and streamreader to get the output
string output = null; StreamReader srOutput = null;
//try the process
try {
//run the process
Process proc = System.Diagnostics.Process.Start(oInfo);
proc.WaitForExit();
//get the output
srOutput = proc.StandardError;
//now put it in a string
output = srOutput.ReadToEnd();
proc.Close();
} catch (Exception) {
output = string.Empty;
} finally {
//now, if we succeded, close out the streamreader
if (srOutput != null) {
srOutput.Close();
srOutput.Dispose();
}
}
return output;
}
#endregion
#region GetVideoInfo
public VideoFile GetVideoInfo(MemoryStream inputFile, string Filename) {
string tempfile = Path.Combine(this.WorkingPath, System.Guid.NewGuid().ToString() + Path.GetExtension(Filename));
FileStream fs = File.Create(tempfile);
inputFile.WriteTo(fs);
fs.Flush();
fs.Close();
GC.Collect();
VideoFile vf = null;
try {
vf = new VideoFile(tempfile);
} catch (Exception ex) {
throw ex;
}
GetVideoInfo(vf);
try {
File.Delete(tempfile);
} catch (Exception) {
}
return vf;
}
public VideoFile GetVideoInfo(string inputPath) {
VideoFile vf = null;
try {
vf = new VideoFile(inputPath);
} catch (Exception ex) {
throw ex;
}
GetVideoInfo(vf);
return vf;
}
public void GetVideoInfo(VideoFile input) {
//set up the parameters for video info
string Params = string.Format("-i {0}", input.Path);
string output = RunProcess(Params);
input.RawInfo = output;
//get duration
Regex re = new Regex("[D|d]uration:.((\\d|:|\\.)*)");
Match m = re.Match(input.RawInfo);
if (m.Success) {
string duration = m.Groups[1].Value;
string[] timepieces = duration.Split(new char[] { ':', '.' });
if (timepieces.Length == 4) {
input.Duration = new TimeSpan(0, Convert.ToInt16(timepieces[0]), Convert.ToInt16(timepieces[1]), Convert.ToInt16(timepieces[2]), Convert.ToInt16(timepieces[3]));
}
}
//get audio bit rate
re = new Regex("[B|b]itrate:.((\\d|:)*)");
m = re.Match(input.RawInfo);
double kb = 0.0;
if (m.Success) {
Double.TryParse(m.Groups[1].Value, out kb);
}
input.BitRate = kb;
//get the audio format
re = new Regex("[A|a]udio:.*");
m = re.Match(input.RawInfo);
if (m.Success) {
input.AudioFormat = m.Value;
}
//get the video format
re = new Regex("[V|v]ideo:.*");
m = re.Match(input.RawInfo);
if (m.Success) {
input.VideoFormat = m.Value;
}
//get the video format
re = new Regex("(\\d{2,3})x(\\d{2,3})");
m = re.Match(input.RawInfo);
if (m.Success) {
int width = 0; int height = 0;
int.TryParse(m.Groups[1].Value, out width);
int.TryParse(m.Groups[2].Value, out height);
input.Width = width;
input.Height = height;
}
input.infoGathered = true;
}
#endregion
#region Convert to FLV
public OutputPackage ConvertToFLV(MemoryStream inputFile, string Filename) {
string tempfile = Path.Combine(this.WorkingPath, System.Guid.NewGuid().ToString() + Path.GetExtension(Filename));
FileStream fs = File.Create(tempfile);
inputFile.WriteTo(fs);
fs.Flush();
fs.Close();
GC.Collect();
VideoFile vf = null;
try {
vf = new VideoFile(tempfile);
} catch (Exception ex) {
throw ex;
}
OutputPackage oo = ConvertToFLV(vf);
try {
File.Delete(tempfile);
} catch (Exception) {
}
return oo;
}
public OutputPackage ConvertToFLV(string inputPath) {
VideoFile vf = null;
try {
vf = new VideoFile(inputPath);
} catch (Exception ex) {
throw ex;
}
OutputPackage oo = ConvertToFLV(vf);
return oo;
}
public OutputPackage ConvertToFLV(VideoFile input) {
if (!input.infoGathered) {
GetVideoInfo(input);
}
OutputPackage ou = new OutputPackage();
//set up the parameters for getting a previewimage
string filename = System.Guid.NewGuid().ToString() + ".jpg";
int secs;
//divide the duration in 3 to get a preview image in the middle of the clip
//instead of a black image from the beginning.
secs = (int)Math.Round(TimeSpan.FromTicks(input.Duration.Ticks / 3).TotalSeconds, 0);
string finalpath = Path.Combine(this.WorkingPath, filename);
string Params = string.Format("-i {0} {1} -vcodec mjpeg -ss {2} -vframes 1 -an -f rawvideo", input.Path, finalpath, secs);
string output = RunProcess(Params);
ou.RawOutput = output;
if (File.Exists(finalpath)) {
ou.PreviewImage = LoadImageFromFile(finalpath);
try {
File.Delete(finalpath);
} catch (Exception) { }
} else { //try running again at frame 1 to get something
Params = string.Format("-i {0} {1} -vcodec mjpeg -ss {2} -vframes 1 -an -f rawvideo", input.Path, finalpath, 1);
output = RunProcess(Params);
ou.RawOutput = output;
if (File.Exists(finalpath)) {
ou.PreviewImage = LoadImageFromFile(finalpath);
try {
File.Delete(finalpath);
} catch (Exception) { }
}
}
finalpath = Path.Combine(this.WorkingPath, filename);
filename = System.Guid.NewGuid().ToString() + ".flv";
Params = string.Format("-i {0} -y -ar 22050 -ab 64 -f flv {1}", input.Path, finalpath);
output = RunProcess(Params);
if (File.Exists(finalpath)) {
ou.VideoStream = LoadMemoryStreamFromFile(finalpath);
try {
File.Delete(finalpath);
} catch (Exception) { }
}
return ou;
}
#endregion
}
public class VideoFile {
#region Properties
private string _Path;
public string Path {
get {
return _Path;
}
set {
_Path = value;
}
}
public TimeSpan Duration { get; set; }
public double BitRate { get; set; }
public string AudioFormat { get; set; }
public string VideoFormat { get; set; }
public int Height { get; set; }
public int Width { get; set; }
public string RawInfo { get; set; }
public bool infoGathered { get; set; }
#endregion
#region Constructors
public VideoFile(string path) {
_Path = path;
Initialize();
}
#endregion
#region Initialization
private void Initialize() {
this.infoGathered = false;
//first make sure we have a value for the video file setting
if (string.IsNullOrEmpty(_Path)) {
throw new Exception("Could not find the location of the video file");
}
//Now see if the video file exists
if (!File.Exists(_Path)) {
throw new Exception("The video file " + _Path + " does not exist.");
}
}
#endregion
}
public class OutputPackage{
public MemoryStream VideoStream { get; set; } public System.Drawing.Image PreviewImage { get; set; } public string RawOutput { get; set; } public bool Success { get; set; }
}
}Schlagworte:C#, ffmpeg, konvertierung, videoinfo
Veröffentlicht in Programmierung, Webprogrammierung | Keine Kommentare » Dienstag, 12. April 2011Folgender Code hilft Ihnen alle Metadaten einer Datei auszulesen. Bei Videos sogar Duration/Länge und Bitrate. Diese Funktioniert für alle Dateientypen wie z.b. txt, mp4, gif, jpg, mp3 usw. public static class FileInfoExtensions {
public static Dictionary<string, string> GetDetails(this FileInfo fi) {
Dictionary<string, string> ret = new Dictionary<string, string>();
var shl = (Shell)Activator.CreateInstance(Type.GetTypeFromProgID("Shell.Application"));
//Shell shl = new ShellClass();
Folder folder = shl.NameSpace(fi.DirectoryName);
FolderItem item = folder.ParseName(fi.Name);
for (int i = 0; i < 150; i++) {
string dtlDesc = folder.GetDetailsOf(null, i);
string dtlVal = folder.GetDetailsOf(item, i);
if (dtlVal == null || dtlVal == "")
continue;
ret.Add(dtlDesc, dtlVal);
}
return ret;
}
}Hier muss lediglich eine Referenz zu der COM Shell32.dll hinzugefügt werden. Schlagworte:C#, Com, jpg, Metadaten, mp4, Shell32, txt
Veröffentlicht in Programmierung, Webprogrammierung | Keine Kommentare » Freitag, 8. April 2011function printDiv()
{
var divToPrint = document.getElementById('toprint');
newWin= window.open("");
newWin.document.write(divToPrint.innerHTML);
newWin.print();
newWin.close();
}or use this code in the css <head>
<style type="text/css">
#printable { display: none; }
@media print
{
#non-printable { display: none; }
#printable { display: block; }
}
</style>
</head>
<body>
<div id="non-printable">
Your normal page contents
</div>
<div id="printable">
Printer version
</div>
</body>
Schlagworte:Css, div, Javascript, print
Veröffentlicht in Javascript, Webprogrammierung | Keine Kommentare » Freitag, 8. April 2011Nicht sehr einfach ist das Einbinden von .mp4 Dateien mit dem h264 Codec mit dem JW Player. Hier muss man folgendes beachten: Sicherstellen, dass sich der Header der mp4 Datei sich am Beginn befindet.
Ansonsten muss der JW Player zuerst das ganze Video laden, damit er beginnen kann das Video abzuspielen. Hier ein Tool um den Header nach vorne zu setzen: My Mp4Box GUI Um nun den JW Player in allen gängigen Browser entweder mit Html5 oder Flash abzuspielen sollte folgender Code verwendet werden. <video id='mediaplayer'
src='" + src+@"'
controls='controls'
poster=''
title='"+title+@"'
>
</video>
<script type='text/javascript'>
jwplayer('mediaplayer').setup({
skin: '/scripts/jwplayer/skins/glow/glow.zip',
modes: [
{ type: 'html5' },
{ type: 'flash', src: '/scripts/jwplayer/player.swf' },
{ type: 'download' }
],
provider:'http',
'http.startparam':'start'
});
</script>Sollte der Browser Html5 unterstützen, dann verwendet dieser HTML5 mit dem entsprechenden Skin, ansonsten Flash sofern installiert. Weitere Informationen findet ihr hier über den JWPlayer Folgender Code wird verwendet um ein Video zu streamen: provider:'http',
'http.startparam':'start' Für das Streaming empfehle ich einen lighttpd Webserver einzurichten mit folgendem Modul. Mod-H264-Streaming Weiters kann auch das oben genannte Modul im IIS laufen. Jedoch dies hat bei mir leider nicht funktioniert. Schlagworte:browser, h264, Html5, JWplayer, Mod H264 Streaming, mp4, Skin
Veröffentlicht in Webprogrammierung | Keine Kommentare » Freitag, 8. April 2011The following code returns a random number: int num = random.Next();
The following code returns a random number less than 1000.
int num = random.Next(1000); The following code returns a random number between min and max: private int RandomNumber(int min, int max)
{
Random random = new Random();
return random.Next(min, max);�
}At some point, you may also want to generate random strings. I have created a method, which takes first parameter as the size of string and second parameter if you want the string to be lowercase. /// <summary>
/// Generates a random string with the given length
/// </summary>
/// <param name="size">Size of the string</param>
/// <param name="lowerCase">If true, generate lowercase string</param>
/// <returns>Random string</returns>
private string RandomString(int size, bool lowerCase)
{
StringBuilder builder = new StringBuilder();
Random random = new Random();
char ch ;
for(int i=0; i<size; i++)
{
ch = Convert.ToChar(Convert.ToInt32(Math.Floor(26 * random.NextDouble() + 65))) ;
builder.Append(ch);�
}
if(lowerCase)
return builder.ToString().ToLower();
return builder.ToString();
}You can even combine the two methods - RandomNumber and RandomString to generate a combination of random string and numbers. For example, the following code generates a password of length 10 with first 4 letters lowercase, next 4 letters numbers, and last 2 letters as uppercase. public string GetPassword() {
StringBuilder builder = new StringBuilder();
builder.Append(RandomString(4, true));
builder.Append(RandomNumber(1000, 9999));
builder.Append(RandomString(2, false));
return builder.ToString(); }Schlagworte:C#, number, Random, String
Veröffentlicht in Webprogrammierung | Keine Kommentare » |