Hallo Leute,

ich möchte ein Bitmap über das Netzwerk verschicken.

Hab schonmal ein kleinen chat geschrieben. in dem wurden aber nur strings verschickt.

ich möchte gerne CAsyncSocket verwenden.

weiß aber nicht genau was ich der Send Funktion übergeben muss.

Mein Bitmap hät ich als "HBITMAP". aber das werd ich ja nicht direkt verschicken können oder? weil das handle ist ja nur auf meinem rechner gültig.

könnt ihr mir ein paar denkanstöße geben? :-)

Danke SwordMaster

Na einfach binär öffnen und als string rüberschicken, auf der anderen seite dann halt wieder als .bmp speichern

hmmm geht das nicht eventuell auch anders?

das bitmap wird zur Laufzeit erstellt (u.a. Screenshots).

und da ists doch irgendwie komisch wenn ich es zuerst

- abspeichern

- binär öffnen

- versenden

- den empfangen string wieder als *.bmp abspeichern

- und dann wieder öffnen muss.

Ciao SwordMaster

Na wenn du das Bitmap schon im Speicher hast, kannst du auch direkt die Daten die du in die Datei speichern würdest über das Socket verschicken würde ich sagen.

Ich denke du wirst Base64 noch benötigen.

Hier eine Standard C++ Variante von mir (ehemals MFC; hab ich umgeschrieben).

Funktioniert tadelos, falls ich den Thread sprenge mit editieren

header

#ifndef BASE64_H

#define BASE64_H


/*

Usage:

  CBase64::Encode("C:\\T.b64"   ,"C:\\T.bmp");

  CBase64::Decode("C:\\TB64.bmp","C:\\T.b64");

*/

#include <string>

#include <fstream>

using namespace std;


namespace Base64

{

	bool Encode(const char* outFilePath, const char* inFilePath); 

	void Encode(char* Result, const unsigned char* src, int Len);


	bool Decode(const char* outFilePath, const char* inFilePath);

	char Decode(char* Result, const char* src); 

}


#endif

[/php]

[b]implementierung[/b]

[php]
#include "base64.h"

namespace Base64
{
//-----------------------------------------------------------------------------------------//

bool Encode(const char* outFilePath, const char* inFilePath)
{
ofstream outFile(outFilePath, ios::app);
ifstream inFile(inFilePath, ios::in | ios::binary);

if(!outFile || !inFile)
return(false);

inFile.seekg(0, ios::end);
unsigned long Len = streamoff(inFile.tellg());
inFile.seekg(0, ios::beg);

unsigned char src[57];
char dst[76+1];
int Count=Len/57;

for(int i=0; i<Count; i++)
{
inFile.read(reinterpret_cast<char*>(&src), 57);
Encode(dst,src,57);
outFile.write(dst,76);
outFile.write("\r\n",2);
}

if(int K=Len%57)
{
inFile.read(reinterpret_cast<char*>(&src), K);
Encode(dst,src,K);
outFile.write(dst,((K+2)/3)<<2);
outFile.write("\r\n",2);
}

return(true);
}

//-----------------------------------------------------------------------------------------//

void Encode(char* Result, const unsigned char* src, int Len)
{
static const char Bit6ToBase64[65]={"\
ABCDEFGHIJKLMNOPQRSTUVWXYZ\
abcdefghijklmnopqrstuvwxyz\
0123456789+/"};

register char* dst=Result+3;
register unsigned long EncodeShifter=0;
int div=(Len==57) ? 57/3 : Len/3;
int mod=(Len==57) ? 0 : Len%3;

for(int i=0; i<div; i++)
{
EncodeShifter=*src++;
EncodeShifter=(EncodeShifter<<8)|*src++;
EncodeShifter=(EncodeShifter<<8)|*src++;
*dst--=Bit6ToBase64[EncodeShifter & 0x3F]; EncodeShifter>>=6;
*dst--=Bit6ToBase64[EncodeShifter & 0x3F]; EncodeShifter>>=6;
*dst--=Bit6ToBase64[EncodeShifter & 0x3F]; EncodeShifter>>=6;
*dst =Bit6ToBase64[EncodeShifter & 0x3F];
dst+=7;
}

*(dst-3)=0;

switch(mod)
{
case 1:
{
EncodeShifter=*src;
EncodeShifter<<=4;//111111 112222 222233 333333
*(dst+1)=0; // ====
*dst--='=';
*dst--='=';
*dst--=Bit6ToBase64[EncodeShifter & 0x3F]; EncodeShifter>>=6;
*dst =Bit6ToBase64[EncodeShifter & 0x3F];
break;
}

case 2:
{
EncodeShifter=*src++;
EncodeShifter=(EncodeShifter<<8)|*src;
EncodeShifter<<=2;//111111 112222 222233 333333
*(dst+1)=0; // ==
*dst--='=';
*dst--=Bit6ToBase64[EncodeShifter & 0x3F]; EncodeShifter>>=6;
*dst--=Bit6ToBase64[EncodeShifter & 0x3F]; EncodeShifter>>=6;
*dst =Bit6ToBase64[EncodeShifter & 0x3F];
}
}
}

//-----------------------------------------------------------------------------------------//

bool Decode(const char* outFilePath, const char* inFilePath)
{
ofstream outFile(outFilePath, ios::out | ios::binary);
ifstream inFile(inFilePath);

if(!outFile || !inFile)
return(false);

char Result[57+1];

for(string line; getline(inFile, line); )
{
char Len=Decode(Result,line.c_str());
outFile.write(Result, Len);
}
return true;
}

//-----------------------------------------------------------------------------------------//

char Decode(char* Result, const char* src)
{
static const unsigned char Base64ToBit6[128]={
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,
52,53,54,55,56,57,58,59,60,61,-1,-1,-1, 0,-1,-1,
-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,
-1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1,
};
register char* dst=Result+2;
register unsigned long DecodeShifter=0;
size_t div=strlen(src)>>2; //no mod: the Law says its divisible by 4.
unsigned char B;
for(size_t i=0; i<div; i++)
{
if((B=*src++) & 0x80 || B<0)
return *Result=0; //Bad characters in stream

DecodeShifter=Base64ToBit6[B];

if((B=*src++) & 0x80 || B<0)
return *Result=0; //Bad characters in stream

DecodeShifter=(DecodeShifter<<6) | Base64ToBit6[B];

if((B=*src++) & 0x80 || B<0)
return *Result=0; //Bad characters in stream

if(B=='=')
{//1111 11222222
*--dst=0; //====
DecodeShifter>>=4; *--dst=(char)DecodeShifter;
return static_cast<char>(dst-Result+1);
}

DecodeShifter=(DecodeShifter<<6) | Base64ToBit6[B];

if((B=*src++) & 0x80 || B<0)
return *Result=0; //Bad characters in stream

if(B=='=')
{//11 11112222 22333333
*dst--=0; //==
DecodeShifter>>=2; *dst--=(char)DecodeShifter;
DecodeShifter>>=8; *dst =(char)DecodeShifter;
return static_cast<char>(dst-Result+2);
}

DecodeShifter=(DecodeShifter<<6) | Base64ToBit6[B];

*dst--=(char)DecodeShifter; DecodeShifter>>=8;
*dst--=(char)DecodeShifter; DecodeShifter>>=8;
*dst =(char)DecodeShifter;
dst+=5;
}
*(dst-=2)=0;

if(dst-Result>127)
return *Result=0; //We're not looking at a valid Base64 section!

return static_cast<char>(dst-Result);
}

//-----------------------------------------------------------------------------------------//

} // end of namespace