Bildschirmübertragung mit Udp

  • VB.NET

Es gibt 23 Antworten in diesem Thema. Der letzte Beitrag () ist von MarioGeier00.

    Bildschirmübertragung mit Udp

    Hallo liebe VB-ler,

    ich würde gerne wissen, wie ich die Screenshots, die auf dem Client Computer gemacht werden, am besten mit einem bestimmten Protokoll sende (z. B. UDP oder TCP?).
    Nun muss ich aber erst noch erklären, bevor ich die zweite Frage stellen kann:

    Ich habe einen Raspberry Pi(Minicomputer, der programmierbare Aus-/Eingänge hat und meiner Meinung nach blöderweise zum ordnungsgemäßen Programmieren einen Bildschirm braucht). Diesen Raspberry möchte ich nun über ein eigens programmiertes Programm fernsteuern. Dazu gehört auch die Bildschirmübertragung. Deshalb hab ich es mir zur Aufgabe geamacht, dies sehr ausgefeilt und effizient zu programmieren, als zusätzliche Übung sozusagen. Ich bin also hergegeangen und habe den Bildschirm in eine frei definierbare Anzahl an gleichgroßen Teilen geteilt und überprüfe dann mittels Durchschnitt der ganzen Farbenwerte in jedem der Rechtecke, ob sich auf dem Bildschirm etwas ändert.

    VB.NET-Quellcode

    1. ' Bildschirm aufnehmen:
    2. Dim TileScreenShot = FromScreen(ScreenTileRect)
    3. ' Durchschnitt ausrechnen:
    4. Dim ScreenTileAverageImage = New Bitmap(TileScreenShot.Bitmap, New Size(1, 1))
    5. If Not ScreenTileAverageImage.GetPixel(0, 0) = LastScreenTileAverageImage.GetPixel(0, 0) Then
    6. LastScreenTileAverageImage = ScreenTileAverageImage
    7. ' Senden:
    8. ' . . . . . . . . ?
    9. End If


    Ich führe die Abfrage in mehreren Threads aus, je nachdem, wie viele Bildschirmteile vorher als Wert übergeben wurden.

    Nun zur zweiten Frage: Wie könnte man es am besten lösen, mit gegeben Werten, wie IP-Adresse des Servercomputers..., die Einzelbilder zu versenden?
    Konkreter:
    -Sollte ich mehrere Ports definieren, um eine bessere Leistung zu erziehlen, weil man schneller empfangen kann?
    -Wie kann ich die empfangenen Teilbilder schnell (ohne SetPixel(GetPixel()) also) in die gegebene Fäche in ein Gesamtbild am Servercomputer einsetzen?
    -Gibt es sonst noch weitere Methoden, die z.B. das Bild komprimieren, aber noch genug Schnelligkeit garantieren?
    -noch Sachen, die ich beachten sollte?


    Vielen Dank im vorraus schonmal für hilfreiche Antworten ^^

    Mit freundlichen Grüßen

    Mario Geier

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „MarioGeier00“ ()

    Guten Abend,
    was meinst du mit mehreren Ports freischalten?
    Möchtest du das Byte-Paket in Sub-Pakete distribuieren , und auf diverse Ports senden?
    Wäre eine Möglichkeit, fände diese imho aber nicht wirklich sinnvoll

    Am besten du verwendest UDP.. ein Screenshot kannst du über die Methode

    C#-Quellcode

    1. ​public Bitmap CaptureScreen()
    2. {
    3. Bitmap b = new Bitmap(SystemInformation.VirtualScreen.Width, SystemInformation.VirtualScreen.Height);
    4. Graphics g = Graphics.FromImage(b);
    5. g.CopyFromScreen(0, 0, 0, 0, b.Size);
    6. g.Dispose();
    7. return b;
    8. }

    aufnehmen...

    Mit der Methode ImageToByteArray sendest du dann das Bild über UDP ..
    wenn ich mich nicht gänzlich irre, musst du die einzelnen Pakete enummerieren, sodass die Reihenfolge erhalten bleibt.

    Liebe Grüße
    DotNETWork (Generische Tcp-Klasse, verschlüsselt!)
    MonogameMinecraftClone (Minecraft-Klon)
    NeuroEvolution (Implementation zweier Lernmethoden für neuronale Netze)
    Hallo, Danke für deine schnelle Antwort :D

    Mit mehreren Ports meine ich, praktisch parallel mit mehreren workern an den versch. Ports auf teilbilder zu warten und zu empfangen. Die frage ist bloß, ob das sinn macht, also ob ich dadurch mehr pro zeiteinheit empfangen könnte?

    Und Bildschirm aufnehmen ist auch kein ding, alles schon erledigt. Es geht lediglich um die fragen oben, v. a. wie ich die bilder dann wieder zu einem zusammensetze, am server.

    Ach, was noch nicht ganz klar sein könnte, mit bild teilen am client meine ich dass ich z. B. 12 Threads gestartet habe und jeder einzelne überwacht einen bestimmten bereich der bildschirms. sobald der sich ändert wierd gesendet(das ist der obige code). und das habe ich auch schon programmiert.

    lg mario

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „MarioGeier00“ ()

    Ach, was noch nicht ganz klar sein könnte, mit bild teilen am client meine ich dass ich z. B. 12 Threads gestartet habe und jeder einzelne überwacht einen bestimmten bereich der bildschirms. sobald der sich ändert wierd gesendet(das ist der obige code). und das habe ich auch schon programmiert.

    Wenn du das implementiert hast, dann Hut ab.. fortan hätte ich TCP verwendet.
    Du musst dir dann nämlich keine Sorgen darüber machen, ob ALLE Daten auch in RICHTIGER Reihenfolge angekommen sind.
    Am besten hilft ein Benchmark(bezüglich verschiedener Ports), UDP wird expressis verbis schneller sein, doch für deine Zwecke , so wie ich verstehe, reicht TCP allemal.
    DotNETWork (Generische Tcp-Klasse, verschlüsselt!)
    MonogameMinecraftClone (Minecraft-Klon)
    NeuroEvolution (Implementation zweier Lernmethoden für neuronale Netze)

    φConst schrieb:

    doch für deine Zwecke , so wie ich verstehe, reicht TCP allemal

    Zur reinen Übertragung der einzelnen Teile des Bildes ist UDP hier definitiv besser.

    @MarioGeier00 Guck dir mal LockBits an (einfach mal hier im Forum danach suchen), die GetPixel-Funktion ist ziemlich langsam.

    Rinecamo schrieb:


    Zur reinen Übertragung der einzelnen Teile des Bildes ist UDP hier definitiv besser.

    @MarioGeier00 Guck dir mal LockBits an (einfach mal hier im Forum danach suchen), die GetPixel-Funktion ist ziemlich langsam.


    So sehe ich das auch, UDP vorzuziehen.

    φConst schrieb:

    Ach, was noch nicht ganz klar sein könnte, mit bild teilen am client meine ich dass ich z. B. 12 Threads gestartet habe und jeder einzelne überwacht einen bestimmten bereich der bildschirms. sobald der sich ändert wierd gesendet(das ist der obige code). und das habe ich auch schon programmiert.

    Wenn du das implementiert hast, dann Hut ab.. fortan hätte ich TCP verwendet.
    Du musst dir dann nämlich keine Sorgen darüber machen, ob ALLE Daten auch in RICHTIGER Reihenfolge angekommen sind.
    Am besten hilft ein Benchmark(bezüglich verschiedener Ports), UDP wird expressis verbis schneller sein, doch für deine Zwecke , so wie ich verstehe, reicht TCP allemal.


    φConst schrieb:


    Du musst dir dann nämlich keine Sorgen darüber machen, ob ALLE Daten auch in RICHTIGER Reihenfolge angekommen sind.


    Ich kann mir vorstellen, dass zwar ein paar bytes verlorengehen, aber das macht ja nichts, werden ja gleich wieder überschrieben. Und das ein Bild in der falschen Reihenfolge, sprich das zuerst die unteren Pixel, dann z. B. die oberen Pixel gesendet werden(wenn ich dich richtig verstanden habe) kann ich mir nicht vorstellen!


    Nun zu den Lockbits: Ich würde also ein Bitmap an der Server Anwendung in einer variable definieren, diese in mehreren BackgroundWorkern in eine neue Variable erben und dann mit lockbits den bereich um den zu ändernden Bildschirmbereich sperren. Dann weise ich das emfangene bild dem bild im backgroundworker zu, oder wie ist das LockBits gemeint?

    Ach noch als hinweis: Ich verwende FastGraphicsLib, mit der ich zur zeit recht zufrieden bin. Vieleicht kann man die bei der zusammensetzung des bildes am server auch einsetzen?

    LG MARIO GEIER ^^
    Mach es erst mit TCP, wenn du deine Architektur gescheit aufbaust, ist das austauschen mit UDP nur eine weitere Implementierung der Übertragung.
    Wenn es mit TCP läuft hast du schonmal alle Probleme ausgeschlossen, die durch UDP verursacht werden können. Das parallele Übertragen über unterschiedliche Ports bringt dir keinen Geschwindigkeitsvorteil, es macht nur das Auseinanderhalten der Daten einfacher, wo sie hin gehören.

    Aber mal ganz nebenbei, warum selbst programmiert?
    Es gibt VNC und andere RemoteDesktop-Lösungen für den Raspberry. Oder auch ganz einfaches X11 über SSH forwarden.
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---
    ok danke ;)

    Und wie würde der code um ein Teil des Bildes in das Gesamtbild zusammenzusetzen?
    So: ScreenImage.setpixel(x, y, TileScreenImage.Getpixel(x, y))
    -> natürlich sind beide variablen vom Typ Fastgraphicslib
    -> das würde ich natürlich noch in eine schleife packen

    ist das die methode die ihr meint? Oder geht das anders?

    Lg mario
    ja so würde das funktionieren. Als einfache und relativ schneller Komprimierung könnte sich Deflate anbieten.

    Wenn du das Bitmap-Locking selbst machen würdest, dann könntest du etwas Zeit für die Indexberechnung beim einfügen eines Teilbildes sparen. Mit C# könntest du unsafe verwenden und somit durch Pointer-Arithmetik auch noch etwas rausholen.

    Aber wie gesagt, erstmal brauchst du eine entsprechende Architektur, bevor du an die tatsächliche Funktionsimplementierung gehst.
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---
    Hi, und vielen Dank für deine Antwort.Ich habe jetzt erst mal versucht, in einer neuen Projektmappe per udp ein Bild zu verschicken und wieder zu empfangen, um es in einer zweiten picturebox wieder anzuzeigen.

    VB.NET-Quellcode

    1. Dim UdpPort As Integer = 8000
    2. Dim UdpAdress = "127.0.0.1"
    3. Private Sub btn_Send_Click() Handles btn_Send.Click
    4. Dim udpClient As New UdpClient()
    5. udpClient.Connect(IPAddress.Parse(UdpAdress), UdpPort)
    6. Dim ImgConverter As New ImageConverter
    7. Dim BytesToSend As Byte() = CType(ImgConverter.ConvertTo(PictureBox1.Image, GetType(Byte())), Byte())
    8. ' Informationen, wie größe, Lage und Sonstiges, an den Server senden
    9. Dim cmdBytes() As Byte = System.Text.Encoding.Default.GetBytes("Information1" & ":" & BytesToSend.Length)
    10. udpClient.Send(cmdBytes, cmdBytes.Length)
    11. Dim offset As Integer = 0
    12. While offset < BytesToSend.Length
    13. ' Ein Stückchen zum Senden rausnehmen, und...
    14. Dim offsetBytes() As Byte = BytesToSend.Skip(offset).Take(10240).ToArray()
    15. ' ...die bereits gesendeten Bytes notieren
    16. offset = offset + 10240
    17. ' schließlich senden
    18. udpClient.Send(offsetBytes, offsetBytes.Length)
    19. End While
    20. End Sub
    21. Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
    22. BackgroundWorker1.RunWorkerAsync()
    23. End Sub
    24. Dim ReceivedPicture As Image
    25. Private Sub BackgroundWorker1_DoWork(ByVal sender As System.Object, ByVal e As System.ComponentModel.DoWorkEventArgs) Handles BackgroundWorker1.DoWork
    26. Dim IpEndPoint As New IPEndPoint(IPAddress.Any, 0)
    27. Dim udpClient As New UdpClient(UdpPort)
    28. Do
    29. Dim cmd As String = ASCII.GetString(udpClient.Receive(IpEndPoint))
    30. ' Informationen auseinanderspalten
    31. Dim fileName = cmd.Substring(0, cmd.IndexOf(":"))
    32. Dim fileSize As Integer = cmd.Substring(cmd.IndexOf(":") + 1)
    33. Dim receivedBytes As Integer = 0
    34. ' Keine Ahnung, wie ich das sonst auf die reihe kriegen soll, die einzenen Datenteile abzuspeichern
    35. Dim Image As String = ""
    36. While receivedBytes < fileSize
    37. ' Empfangen
    38. Dim data() As Byte = udpClient.Receive(IpEndPoint)
    39. ' Unnötigerweise umwandeln, weis aber net wies anders gehn soll
    40. Image &= ASCII.GetString(data)
    41. ' Wieder notieren
    42. receivedBytes += data.Length
    43. End While
    44. Dim IC As New ImageConverter
    45. ' Umwandeln
    46. Dim bytes As Byte() = ASCII.GetBytes(Image)
    47. ' Umwandeln, hier sagt er mir übrigens auch, es gäbe einen ungültigen Parameter :D
    48. ReceivedPicture = CType(IC.ConvertFrom(bytes), Image)
    49. ' Bild im ursprünglichen Thread, der auf Steuerelemente zugreifen kann, der zweiten PictureBox zuweisen
    50. BackgroundWorker1.ReportProgress(1)
    51. Loop
    52. End Sub


    Also, ich habe ja als komentar vor funktionen schon meine Probleme wiedergegeben.Dazusagen muss ich, das mir gerade die idee kommt, jeden einzelnen pixel zu senden, anstatt das ganze teilscreenbild, also praktisch an serverseite getpixel auch ausfüren zu müssen, würde ich mir dann sparen. Dann hätte sich nämlich das problem mit der string variable, was man im codeausschnitt oben sehen kann, gelöst, da ich ja nichts zwischenspeichern muss.Sinnvoll?

    LG Mario Geier
    Nein, damit wird das ganze wesentlich langsamer und noch viel schlimmer, das Bild wird ziemlich sicher einige Fehler beinhalten.
    Wie gesagt bekomm es erst über TCP zum laufen, anschließend kannst dich mit den UDP Problemen immernoch rumschlagen.
    Das ganze GetPixel/SetPixel zeug sollte ansich ja kein Problem darstellen, nur die relative Koordinatenberechnung muss man ein wenig überlegen.
    Verwende z.B. auch keinen Backgroundworker, sondern lieber BeginReceive/BeginSend(bzw. BeginRead/BeginWrite). Mach kein string gefriemel, guck dir z.B. BitConverter.GetBytes an, damit kann man die länge in den bytebuffer schreiben.

    Mach ein einfaches PaketSystem, wobei in jedem Paket die Info steht, um welchen Bildausschnitt es sich handelt(oder für die Reihenfolge u.a.)
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---
    Soll heißen, dass ich...
    -das TileScreenBild in Bytes umwandle
    -vor jedem Teil der Bytes eines Teilbildes die Information(en) packe, die z. B. die Position beinhalten oder dass ich Nummern vergebe.(Jetzt verstehe ich auch was oben gemeint wurde: die einzelnen Teile der Bilder kommen ja wild und in unwilkürlicher Reihenfolge am server an)
    -im nächsten Schritt die bytes in Typ Image umwandeln
    -mit setpixel(getpixel()) den bereich überschreiben
    -Bild ausgeben

    Dazu muss man sagen, dass ich denke, sehr viel schwierigkeiten zu bekommen, weil ja ständig daten gesendet werden und dann muss ich entscheiden, ob ich das bild ausgebe, oder noch die änderung, die gerade empfangen wird.

    Ach und kannst du des mit beginsend/beginreceive näher erklären, wie ich das einsetzen soll? Ich hab damit nämlich keine erfahrung :huh:

    Mit freundlichen Grüßen

    Mario Geier
    Hi, keine Rückmeldung mehr? ^^

    Noch eine Frage: Ich möchte ein einzelnes Paket am Client mit den Daten versehen (Lage und Größe des Bildes) und muss ja da zwei ByteArrays zusammensetzten (die Informationen und die Bytes des Bildes). Ich habe im Internet folgende Möglichkeit recherchiert:

    VB.NET-Quellcode

    1. Dim ImgBytes() As Byte = CType(ImgConverter.ConvertTo(TileScreenShot.Bitmap, GetType(Byte())), Byte())
    2. Dim PacketName() As Byte = ASCII.GetBytes("100;200;0;0;")
    3. Dim BytesToSend(ImgBytes.Length + 20) As Byte
    4. PacketName.CopyTo(BytesToSend, 0)
    5. ImgBytes.CopyTo(BytesToSend, 20)
    6. Try
    7. udpClient.Send(ImgBytes, ImgBytes.Length)
    8. Catch
    9. End Try


    Nun bräuchte ich aber eine Methode, die das ganze ohne drei Variablen kann, das braucht einfach zu viel Arbeitsspeicher.

    Und dann am Server wieder auseinandernehmen:
    [Info: davor BeginReceive aufgerufen; Die Werte zwecks Testzwecke in MsgBox angezeigen]

    VB.NET-Quellcode

    1. Public Sub ReceiveCallback(ByVal ar As IAsyncResult)
    2. Dim IpEndPoint As New Net.IPEndPoint(Net.IPAddress.Any, 8000)
    3. Dim udpClient As UdpClient = CType(ar.AsyncState, UdpClient)
    4. ' Hier weiter empfangen.
    5. u.BeginReceive(New AsyncCallback(AddressOf ReceiveCallback), udpClient)
    6. Dim receiveBytes() As Byte = udpClient.EndReceive(ar, IpEndPoint)
    7. MsgBox(System.Text.Encoding.ASCII.GetString(receiveBytes.Take(20).ToArray))
    8. Dim IC As New ImageConverter
    9. Picture.Image = CType(IC.ConvertFrom(receiveBytes.Skip(20).ToArray), Image)
    10. End Sub


    Hier packe ich dann des mit den getpixel rein. Ich werde in eine liste die aktuell zu emfangenen Bilder notieren, und dabei auch eine Variable mit dem bis jetzt empfangenen Array von Byte dazumachen.

    Wie kann ich aber auch hier in ein bereits existierendes ByteArray das neu empfangene ByteArray anfügen?
    Und was geht an dem Code noch effizienter?

    Frohe Weihnachten

    Mario Geier :)
    Hallo,
    ich habe jetzt mal überflogen.
    Wie groß ist denn jedes einzelne Tile ?

    Zu deiner Frage mit Arrays.
    Verwende List.
    Ich finde dies logischer.
    Arrays sind dann effizient, wenn sie seit dem Start eine fixe Größe haben.
    Bei dir scheint es so, dass das Array perpetuell vergrößert werden muss.

    Wenn du aber trotzdem mit Arrays arbeiten willst:

    Finde die Größe des aktuellen Arrays.
    Addiere zu dieser Größe, die Größe des kommenden Arrays.
    Erzeuge neues Array mit der Größe n (n = array_old.length + array_new.length)
    Mit Array.Copy erstmal die Daten von array_old, und dann die Daten von array_new füllen.

    Aber merke:
    Immer zuerst x iterieren.
    Sequenzielles iterieren ist schneller.

    Weil: Man habe exemplarisch ein Byte-Array mit 2048x2048 Bytes.
    Wenn du zuerst y iterierst, dann lädst du,

    index = x + j * WIDHT = 0 + 1 * 2048 = 2048 Bytes, von denen 2047 Bytes aber wieder verworfen werden.

    Wenn du x zuerst iterierst, dann lädst du nur ,
    index = 1 + 0 * WIDHT = 1 Byte.


    Um den Arbeitsspeicher würde ich jetzt noch keine Sorgen machen.
    Das ist Optimierung, dies kannst du versuchen, wenn alles klappt.
    Ich empfehle dir ebenso erstmal mit TCP zu arbeiten.

    Gibt auch asynchrones Verfahren zum Senden und Empfangen, einfach deswegen, um zu verstehen, was man macht.
    Versuche es erst damit, dann UDP.

    Post scriptum:
    Entferne dieses Try-Catch.
    Du debuggst ja nicht umsonst.

    Liebe Grüße.
    DotNETWork (Generische Tcp-Klasse, verschlüsselt!)
    MonogameMinecraftClone (Minecraft-Klon)
    NeuroEvolution (Implementation zweier Lernmethoden für neuronale Netze)

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „φConst“ ()

    Es waren 3 Tage :P Auch wenn die Antwortquote hier sonst überttieben ist.
    Der Code ist außerdem buargh :D

    Visual Basic-Quellcode

    1. Using bufferStream As New MemoryStream()
    2. bufferStream.Position = 4 '4 byte offset für die länge
    3. bufferStream.WriteByte(xIndex);'Chunk position X
    4. bufferStream.WriteByte(yIndex);'Chunk position Y
    5. TileScreenShot.Bitmap.Save(bufferStream,ImageFormat.PNG) ' daten schreiben(weiß vorher die länge nicht)
    6. bufferStream.Position = 0 'wieder an position 0 des streams
    7. bufferStream.Write(BitConverter.GetBytes(bufferStream.Length - 4-2),0,4) ' schreibe die länge(- offset, da die daten nicht zu den bilddaten gehören)
    8. End Using
    9. bufferStream.ToArray()'dein byte array

    Natürlich kann man hier noch beliebige andere Serialisierungsmöglichkeiten verwenden, Image.Save ist jedoch erstmal am einfachsten. Durch diese Optimierung werden nicht so oft daten hin und herkopiert MemoryStream arbeitet wie Listen mit dem verdoppeln der Datenmenge bei Bereichüberschreitung.
    Positionen braucht man nicht pixelgenau, sondern da reicht der Index auf X/Y achse(man könnte auch einen einzigen verwendet, welcher aus X/Y Chunkposition berechnet wird (Y*ChunkCountX + X)), würde noch ein weiteres byte sparen.
    die größen der einzelnen bilder können im vorraus ausgemacht werden, ist hier aber irrelevant, da das bitmap selbst die eigene größe sogar enthält.(Andere Serialisierungsarten möchte man evtl. später noch einbauen)

    Natürlich kann das ganze auf diese Art probleme machen, da du immer noch nicht angefangen hast TCP zu verwenden. Vergiss mal die nachteile von TCP und denk erstmal an die Vorteile, denn für soetwas wirst du nachher immer noch jedes paket mit einem header versehen müssen um alles richtig wieder zusammensetzen zu können, mit TCP erstmal nicht, da kannst du dich erstmal um die Problematik des sendens, empfangens und grundsätzlichen Serialisierens kümmern.

    Laden geht natürlich ebenso einfach mit einem MemoryStream.
    BitConverter.ToInt32 um die Länge wieder zu lesen und den MemoryStream mit Offset 6 um das Bild zu laden.

    Aber am besten baust du das mal auf TCP um, dann werden wir erstmal das zum laufen bekommen, bevor wir uns hier weitere Gedanken machen.
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---
    Vielen Dank für die super hilfreichen Nachrichten ;)
    Mit Codebeispiel, das ist ja mal vorbildlich.

    Also, Ihr habt gewonnen, Tcp ist jetzt in mein Programm mit eingekehrt ^^

    Nun stehe ich aber mit deinem komplexen Code da, als ob ich noch nie programmiert hätte :D
    Es geht hauptsächlich um die 3. und 4. Zeile:
    Was ist xIndex/yIndex?
    Falls es die Breite/Höhe sein soll, warum in Byte? Man kann ja dann nur bis 255 die Größe übergeben!
    Ohne Trennzeichen?

    Ansonsten ist Tcp wirklich viel einfach vom Handling, das fällt an dem Code oben direkt auf! Danke nochmal.

    LG Mario Geier
    xIndex/yIndex ist das n-te Bild in jeweilige Richtung. Ich denke man braucht erstmal nicht mehr als 255 bilder pro Richtung, ich denke es gibt auch keinen großen Sinn die Bilder kleiner zu machen als 50px und 12750x12750 dürfte als Auflösung erstmal reichen.

    Warum ein Trennzeichen, wir Wissen genau wie groß ein Byte ist(nämlich ein Byte) und ein Int ist 4 Byte groß. Wir übergeben die Daten binär, d.h. mein Header ist bereits kleiner als deiner, obwohl er bei maximaler größe mehr Information erlaubt und bei minimaler genau gleich viel. Außerdem ist das auslesen/konvertieren schneller. Mein Header besitzt also ggü. deinem keinen einzigen Nachteil.
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---
    Da hast du völlig recht. Jetzt vertehe ich das. Jedoch ist das nicht exakt das, was ich brauche:
    Ich werde nämlich nicht einen screentile senden, sondern nur einen Teil eines Screentiles(falls sich jedoch viel ändert, also viele einzelne Teile gesendet werden müssten, werde ich natürlich das ganze screentile senden). Das ist möglich, weil ich ja ein screentile auf wenige pixel reduziere, die ich mit dem vorherigen. Werten validiere. Und da habe ich dann die möglichkeit, den bereich noch weiter einzugrenzen->wenuger daten-> Geschwindigkeit->Super
    Dann müsste ich einfach 2*4bytes reservieren?

    Noch eine ganz andere Frage: Die bildschirm screenshots sind nicht ideal, mit den zwei funktionen(graphics.copyfromscreen oder fastgraphicslib.fromscreen), weil ich bei spielen, während ich nen eigenen screnrecorder mit der funktion von der graphics klasse laufen lies, entweder das problem hatte, schwarze bilder dazwischen zu haben, oder, dass manche anwendungen, komplett aus dem Bild verschwinden und das was dahinter ist, an der stelle angezeigt wurde. Gibts andere funktionn?

    Mit freundlichen Grüßen und mit hoffnung, euch endlich nicht mehr mit fragen bombadieren zu müssen :D

    Mario Geier
    Ich glaube ehrlich gesagt nicht, dass es Sinn ergibt nur noch kleine teilbereiche davon zu senden, ändere einfach die tile size. Denn irgendwann dauert die Serialisierungszeit länger als das Senden der Daten selbst.
    Außerdem kann man immernoch später irgendwelche Optimierungen einbauen - bekomms erstmal überhaupt zum laufen ;)

    Wenn du von Spielen den Screenshot willst, dann wird es natürlich wesentlich schwieriger, die einzige Möglichkeit die ich kenne ist mit einem OpenGL/DirectX Inject und anschließend das kopieren des FrontBuffers.

    Jedoch wird somit dein gesamtes vorhaben Fraglich, denn für Spiele will man eine möglichst hohe Übertragungsrate, da wäre etwas GPU basiertes vmtl. wesentlich besser.
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---