Ok dicen que el protocolo UDP es mejor que el TCP para el video streamming, ok lo entiendo, leo teoria y tiene sentido, entonces programo una aplicacion que envia paquetes no mayores a 1.45kb ( este es el limite, el mtu ), pero la aplicacion no logra enviar mas de 100kb en un segundo .... lo probe con un amigo al otro lado de la ciudad y con una amiga de costa rica y no sobrepasa los 100kb/s ... lo cual no es de mi agrado porque cuando descargo algo de mega o de mediafre , o de cualquier otro lugar, descargo a 160kb/s, .... quiero entender el protocolo udp y no me refiero a guias o manuales.. porque he leido muchos ... me refiero a porque eso ocurre .... ? algun experimentado tiene idea ?

Bueno, voy a ser directo, un programa que funciona a manera de videollamda, por ejemplo

servidor: envia datos visuales al cliente
cliente: decodifica datos y los muestra a manera de imagen

se hace esto varios frames en un segudo ..

buum videollamada xd

es esta la manera en que funciona no ? ,  esa pregunta no es el objetivo de este post, resulta que tengo una duda ... tomemos una imagen bmp cualquiera de 800x600x3 pixeles eso es equivalente a 1.4mb no ? hahaha ... yo recibo buena señal por videollamada, sin mucho lag ... pero mi internet solo puede bajar 150kb/s, asi que la teoria de que se envia una imagen bmp es falsa, se necesitarian 10 segundos para enviar una imagen bmp xd entonces .... comprimimos la imagen ? la transformamos en jpg ? ya lo intente con varias imagenes y lo mas que puedo reducir es hasta 50kb , puedo enviar 3 imagenes jpg en 1 segundo .. pero eso seria lag !!!!


entonces la pregutna ... existe alguna manera que ignore , algun algoritmo, alguna forma de enviar informacion visual en vivo ? alguien sabe ? llevo todo el dia pensando ... y no encuentro nada ! xd

Hola, hace un par de meses realize un post para pedir que me ayudaran a leer una imagen haha, lo logré hacer por mi cuenta y he aprendido bastante sobre el manejo básico de imagenes.

El siguiente post lo realizo porque me molesta que haya tan pocos artículos en español sobre este tema. Lo que pondré es un algoritmo de detección de bordes de una imagen en c++, lo acabo de terminar xd

Lo pondré luego explicaré cada parte.

 
struct cannyAlgorithm
    {
        unsigned char * image;
 
        unsigned width;
        unsigned height;
        unsigned size;
        unsigned bpp;
 
        short * Gx;
        short * Gy;
 
        short * Direction;
 
        double * Magnitude;
 
        cannyAlgorithm( unsigned char * data, unsigned imgw, unsigned imgh, unsigned bitsperpixel )
        {
            width   = imgw;
            height  = imgh;
 
            size = width* height;
 
            bpp = bitsperpixel;
 
            Gx = new short[ size ];
            Gy = new short[ size ];
 
            Direction = new short[ size ];
 
            Magnitude = new double[ size ];
 
            image = new unsigned char[ size* bpp ];
            memcpy( image, data, size* bpp );
        }
        ~cannyAlgorithm( void )
        {
            delete[] Gx;
            delete[] Gy;
            delete[] Direction;
            delete[] Magnitude;
        }
        int max( int a, int b )
        {
            int c = a > b ? a : b;
            return c;
        }
        int min( int a, int b )
        {
            int c = a < b ? a : b;
            return c;
        }
        short getAngle( double X, double Y )
        {
            short Angle;
 
            if( X* Y > 0 )  // Quadrant 1 or 3
            {
                if( abs( X ) >= abs( Y ) )
                    Angle = 0;
                else
                    Angle = 180;
            }
            else            // Quadrant 2 or 4
            {
                if( abs(X) >= abs(Y) )
                    Angle = 90;
                else
                    Angle = 270;
            }
 
            return( Angle );
        }
        double hypotenuse( double a, double b )
        {
            double h = sqrt( a*a + b*b );
            return(h);
        }
        bool isLocalMax( unsigned offset )
        {
            unsigned bottom     = max(offset - width, 0);
            unsigned top        = min(offset + width, size);
            unsigned left       = max(offset - 1, 0);
            unsigned right      = min(offset + 1, size);
            unsigned bottomLeft = max(bottom - 1, 0);
            unsigned bottomRight= min(bottom + 1, size);
            unsigned topLeft    = max(top - 1, 0);
            unsigned topRight   = min(top + 1, size);
 
            double thisPoint = 0.0;
            double mag[2]    = { 0.0 };
 
            switch( Direction[offset] )
            {
                case 0:
                {
                                /*   90
                                      *
                                      |******
                                      |******
                                -------------* 0
                                      |
                                      |
 
                                */
                    thisPoint = abs( Gx[offset]* Magnitude[offset] );
 
                    mag[0] = abs( Gy[offset]* Magnitude[topRight  ] + ( Gx[offset] - Gy[offset] )* Magnitude[right] );
                    mag[1] = abs( Gy[offset]* Magnitude[bottomLeft] + ( Gx[offset] - Gy[offset] )* Magnitude[left ] );
                    }break;
 
                case 90:
                {
                                /*
                                      90
                                      *
                                 *****|
                                 *****|
                            180 *-------------
                                      |
                                      |
                                */
                    thisPoint = abs(Gx[offset]* Magnitude[offset] );
 
                    mag[0] = abs( Gy[offset]* Magnitude[bottomRight] - ( Gx[offset] + Gy[offset])* Magnitude[right] );
                    mag[1] = abs( Gy[offset]* Magnitude[topLeft    ] - ( Gx[offset] + Gy[offset])* Magnitude[left ] );
                }break;
 
                case 180:
                {
                                /*
                                      |
                                      |
                            180 *-------------
                                ******|
                                ******|
                                      *
                                     270
                                */
                    thisPoint = abs( Gy[offset]* Magnitude[offset] );
 
                    mag[0] = abs( Gx[offset]* Magnitude[topRight  ] + ( Gy[offset] - Gx[offset] )* Magnitude[top   ] );
                    mag[1] = abs( Gx[offset]* Magnitude[bottomLeft] + ( Gy[offset] - Gx[offset] )* Magnitude[bottom] );
                }break;
 
                case 270:
                {
                                /*
                                      |
                                      |
                                -------------* 0
                                      |*******
                                      |*******
                                      *
                                     270
                                */
                    thisPoint = abs( Gy[offset]* Magnitude[offset] );
 
                    mag[0] = abs( Gx[offset]* Magnitude[bottomRight] - ( Gy[offset] + Gx[offset] )* Magnitude[bottom] );
                    mag[1] = abs( Gx[offset]* Magnitude[topLeft    ] - ( Gy[offset] + Gx[offset] )* Magnitude[top   ] );
                }break;
 
                default:
                    break;
            }
 
            if( thisPoint >= mag[0] && thisPoint >= mag[1] )
                return( true );
            return( false );
        }
        void grayScaleCompress( void )
        {
            unsigned char * compressed = new unsigned char[ size ];
 
            for( unsigned offset = 0; offset < size; offset++ )
                compressed[offset] = image[offset* bpp];
 
            delete[] image;
            image = new unsigned char[ size ];
            memcpy( image, compressed, size );
 
            delete[] compressed;
        }
        void continuousTracing( unsigned offset, unsigned char * in, unsigned char * out, unsigned thresholding )
        {
            /*
            The concept is sample:
            I found a possible edge and I will follow this edge until its end.
            Test 8 neighboring pixels and if someone is higher than thresholding then
            that pixel will be another edge and I will follow it.
 
            This process is repeated until the value of the current pixel tested is null.
            */
            const unsigned edge = 255;
 
            unsigned dir[2];
            dir[0] = width;      // Top - Bottom
            dir[1] = 1;          // Left - Right
 
            unsigned top = min( offset + dir[0], size );
            if( in[top] >= thresholding )
                do
                {
                    if( !out[top] )
                    {
                        out[top] = edge;
                        continuousTracing( top, in, out, thresholding );
                    }
                    else
                        break;
 
                    top += dir[0];
 
                    if( top > size )
                        break;
 
                }while( in[top] >= thresholding );
 
            unsigned bottom = max( offset - dir[0], 0 );
            if( in[bottom >= thresholding] )
                do
                {
                    if( !out[bottom] )
                    {
                        out[bottom] = edge;
                        continuousTracing( bottom, in, out, thresholding );
                    }
                    else
                        break;
 
                    bottom -= dir[0];
 
                    if( bottom < 0 )
                        break;
 
                }while( in[bottom] >= thresholding );
 
            unsigned right = min( offset + dir[1], size );
            if( in[right] >= thresholding )
                do
                {
                    if( !out[right] )
                    {
                        out[right] = edge;
                        continuousTracing( right, in, out, thresholding );
                    }
                    else
                        break;
 
                    right += dir[1];
 
                    if( right > size )
                        break;
 
                }while( in[right] >= thresholding );
 
            unsigned left = max( offset - dir[1], 0 );
            if( in[left] >= thresholding )
                do
                {
                    if( !out[left] )
                    {
                        out[left] = edge;
                        continuousTracing( left, in, out, thresholding );
                    }
                    else
                        break;
 
                    left -= dir[1];
 
                    if( left < 0 )
                        break;
 
                }while( in[left] >= thresholding );
 
            unsigned topRight = min( offset + dir[0] + dir[1], size );
            if( in[topRight] >= thresholding )
                do
                {
                    if( !out[topRight] )
                    {
                        out[topRight] = edge;
                        continuousTracing( left, in, out, thresholding );
                    }
                    else
                        break;
 
                    topRight += dir[0] + dir[1];
 
                    if( topRight > size )
                        break;
 
                }while( in[topRight] >= thresholding );
 
            unsigned bottomLeft = max( offset - dir[0] - dir[1], 0 );
            if( in[bottomLeft] >= thresholding )
                do
                {
                    if( !out[bottomLeft] )
                    {
                        out[bottomLeft] = edge;
                        continuousTracing( bottomLeft, in, out, thresholding );
                    }
                    else
                        break;
 
                    bottomLeft -= dir[0] - dir[1];
 
                    if( bottomLeft < 0 )
                        break;
 
                }while( in[bottomLeft] >= thresholding );
 
            unsigned topLeft = min( offset + dir[0] - dir[1], size );
            if( in[topLeft] >= thresholding )
                do
                {
                    if( !out[topLeft] )
                    {
                        out[topLeft] = edge;
                        continuousTracing( topLeft, in, out, thresholding );
                    }
                    else
                        break;
 
                    topLeft += dir[0] - dir[1];
 
                    if( topLeft > size )
                        break;
 
                }while( in[topLeft] >= thresholding );
 
            unsigned bottomRight = max( offset - dir[0] + dir[1], 0 );
            if( in[bottomRight] >= thresholding )
                do
                {
                    if( !out[bottomRight] )
                    {
                        out[bottomRight] = edge;
                        continuousTracing( bottomRight, in, out, thresholding );
                    }
                    else
                        break;
 
                    bottomRight -= dir[0] + dir[1];
 
                    if( bottomRight < 0 )
                        break;
 
                }while( in[bottomRight] >= thresholding );
 
            /* Works with feedback and not will be an infinite loop cause I am saving the new data into a new image */
        }
        void computeGradients( void )
        {
            // Compute Gradients in X
            for( unsigned y = 0; y < height; y++ )
            {
                unsigned offset = y* width;
 
                Gx[offset] = image[offset + 1] - image[offset];
 
                offset++;
                for( unsigned x = 1; x < width - 1; x++, offset++ )
                    Gx[offset] = image[offset + 1] - image[offset - 1];
 
                Gx[offset] = image[offset] - image[offset - 1];
            }
            // Compute Gradients in Y
            for( unsigned x = 0; x < width; x++ )
            {
                unsigned offset = x;
 
                Gy[offset] = image[offset + width] - image[offset];
 
                offset += width;
                for( unsigned y = 1; y < height - 1; y++, offset += width )
                    Gy[offset] = image[offset + width] - image[offset - width];
 
                Gy[offset] = image[offset] - image[offset - width];
            }
            // Hypotenuse = sqrt(x^2 + y^2)
            for( unsigned y = 0, offset = 0; y < height; y++ )
                for( unsigned x = 0; x < width; x++, offset++ )
                    Magnitude[offset] = hypotenuse( Gx[offset], Gy[offset] );
            // Okay, edges of the image must be null
            for( unsigned x = 0; x < width; x++ )
                Magnitude[x] = 0;
 
            for( unsigned x = 0, offset = width* (height - 1); x < width; x++, offset++ )
                Magnitude[offset] = 0;
 
            for( unsigned y = 0; y < width* height; y += width )
                Magnitude[y] = 0;
 
            for( unsigned y = 0, offset = width - 1; y < width* height; y += width, offset += width)
                Magnitude[offset] = 0;
        }
        void nonMaxSupress( void )
        {
            /* Compute magnitudes direction and save it */
            for( unsigned y = 0, offset = 0; y < height; y++ )
                for( unsigned x = 0; x < width; x++, offset++ )
                    Direction[offset] = getAngle( Gx[offset], Gy[offset] );
            /*
                The most complicated part:
                If the pixel is not a local maximum then kill it.
                How do I know if my point is a local max ?
                I will compare the current pixel with neighboring pixels in the gradient direction.
                Remember: Pixel with null magnitude are not candidate to be an edge.
            */
            for( unsigned y = 0, offset = 0; y < height; y++ )
                for( unsigned x = 0; x < width; x++, offset++ )
                {
                    if( Magnitude[offset] && isLocalMax(offset) )
                        image[offset] = Magnitude[offset] > 255 ? 255 : (unsigned char)Magnitude[offset];
                    else
                        image[offset] = 0;
                }
        }
        void hysteresis( float lowScale, float highScale )
        {
            /*
            We need a High value and a Low value, High value will be the edge color.
            All pixels with color higher than ' Hight value ' will be edges
            and we will follow this pixel until another pixel is founded.
            The pixel founded must be a color higher than ' Low value ', if that is the case
            then we will set this pixel like edge, else it will be background ( null ).
            */
 
            lowScale    = lowScale <= 0.0f ? 0.01f : lowScale > 1.0f ? 1.0f : lowScale;
            highScale   = highScale <= 0.0f ? 0.01f : highScale > 1.0f ? 1.0f : highScale;
 
            unsigned char globalMax = 0;
            for( unsigned offset = 0; offset < size; offset++ )
                if( image[offset] > globalMax )
                    globalMax = image[offset];
 
            unsigned highV = globalMax* highScale;
            unsigned lowV = globalMax* lowScale;
 
            unsigned char * finalPic = new unsigned char[ size ];
            memset( finalPic, 0, size );
 
            for( unsigned y = 1,offset = 1; y < height - 1; y++ )
                for( unsigned x = 1; x < width - 1; x++, offset++ )
                    if( image[offset] >= highV && !finalPic[offset] )
                    {
                        finalPic[offset] = 255;
                        continuousTracing( offset, image, finalPic, lowV );
                    }
 
            delete[] image;
            image = new unsigned char[ size ];
            memcpy( image, finalPic, size );
 
            delete[] finalPic;
        }
        void grayScaleDecompress( void )
        {
            size = width* height* bpp;
            unsigned char * decompressed = new unsigned char[ size ];
 
            for( unsigned offset = 0; offset < width* height; offset++ )
                decompressed[offset*bpp + 0] = decompressed[offset* bpp + 1] = decompressed[offset* bpp + 2] = image[offset];
 
            delete[] image;
            image = new unsigned char[ size ];
            memcpy( image, decompressed, size );
 
            delete[] decompressed;
        }
        void AutoEdgeDetection( unsigned char * data, float lowV, float highV )
        {
            grayScaleCompress();
            computeGradients();
            nonMaxSupress();
            hysteresis(lowV, highV);
            grayScaleDecompress();
 
            memcpy( data, image, size );
        }
        unsigned char * get_data( void )
        {
            grayScaleDecompress();
            return( image );
        }
    };
 
 

Lo puse todo en una estructura para que sea más portable y además para que  no dependa de otras librerias añadí funciones como max, min y hypotenuse, creo que solo debe incluir la libreria <cmath> para la funcion abs

Se preguntarán: Okay, tengo el algorithmo, ¿ Ahora qué ?.

fácil, para usarlo deben iniciailizarlo con el ancho y alto de la imagen, la cantidad de bits por pixel( 1 , 2 , 3 o 4 ) y el unsigned char de la data de la imagen, ejemplo:

 
    gaussianBlur(15, 2);
    grayScale();
    cannyAlgorithm cpix( ~self.data, self.width, self.height, self.bpp / 8 );
 
    cpix.AutoEdgeDetection( ~self.data, 0.2f, 0.25f );
 
 

seguire explicando abajo

¿ Que ven mal en mi codigo ?
Es que me muestra un cuadro gris pero no carga la textura .... no entiendo porque
Estoy algo desesperado y puede que este pasando algo por alto, si alguien ve algo malo digame T_T

PD: empeze a hacerlo hace unas horas y no he estudiado mucho con respecto al manejo de BMP's, tal ves ese sea mi problema

 
bool SPRITE::LoadBMP(const char * path, GLuint * texture)
{
	std::ifstream img(path, std::ios::binary);
	if( !img )
		return(False);
 
	BITMAPFILEHEADER	imgHeader;
	BITMAPINFOHEADER	imgInfo;
 
	img.read( (char*)&imgHeader,sizeof(BITMAPFILEHEADER) );
	img.read( (char*)&imgInfo, sizeof( BITMAPINFOHEADER ) );
 
	if (imgHeader.bfType != 0x4D42) 
		return(False);
 
	int size = ( imgInfo.biSizeImage );
 
	BYTE * pix =new BYTE[size];
	img.read( (char*)pix, size );
 
	img.close();
 
	BYTE * data = new BYTE[size];
	for (int i = 0; i < size; i += 3)
	{
		data[i+0] = pix[i+2];
		data[i+1] = pix[i+1];
		data[i+2] = pix[i+0];;
	}
 
	unsigned int w = imgInfo.biWidth;
	unsigned int h = imgInfo.biHeight;
 
	glGenTextures(1, texture);           
	glBindTexture(GL_TEXTURE_2D, *texture);            
 
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
 
	glBindTexture(GL_TEXTURE_2D, NULL);
 
	return(True);
}
 
 

Amm, soy nuevo ._. me vi en la necesidad de unirme a un foro de programacion porque hay algo que realmente no logro comprender, me explicare...

Llevo varias horas estudiando sobre como inyectar fracciones de codigo en un programa, desde otro programa creado por mi en c++ ( alrededor de 50 horas en los ultimos 3 dias ), y hasta ahora he logrado modificar el valor del dinero en counter strike xd y el valor de una variable de un programa "victima.exe" que yo mismo cree para iniciarme.

si, tuve exito, pero si reinicio el programa la posicion de la memoria de la variable es distinta, ya se que eso es normal xd lo que no logro es encontrar la posicion de memoria estatica, me es dificil explicarme pero supongo que mas de uno paso por esto.

"Address=Base+offset+offset+offset"

ok .. intente con el cheat engine 6.2 pero solo logre conseguir una posicion de memoria dinamica y de ahi no logro por mas que lo intento conseguir la estatica

les muestro mi codigo y les explico:

main.cpp

 
 
#include "stdafx.h"
#include "util.h"
#include <tlhelp32.h>  
#include <shlwapi.h>  
 
#define PROCESS_NAME "victima.exe"
 
int readMemory(DWORD pId); 
DWORD getProcessId(IN PCHAR szExeName); 
 
 
int main()
{
	DWORD pId=getProcessId(PROCESS_NAME);
	if(!pId)
		return(0);
 
	int result=readMemory(pId);
 
	std::cout<<result<<std::endl;
	system("pause");
 
	return 0;
} 
 
int readMemory(DWORD pId)
{
	int hex=0x0016FAC8, // esto lo obtengo con cheat engine
	int offset = -8; // esto lo obtengo con cheat engine
	int memory,pointerBase,result;
	HANDLE hProc = OpenProcess(PROCESS_VM_READ, FALSE, pId);
	ReadProcessMemory(hProc, (LPVOID)hex, &memory, 4, NULL);
	pointerBase = memory-offset;
	ReadProcessMemory(hProc, (LPVOID)pointerBase, &result,4, NULL);
	return(result);
}
 
DWORD getProcessId(IN PCHAR szExeName) 
{ 
    DWORD dwRet = 0; 
    DWORD dwCount = 0; 
 
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); 
 
    if (hSnapshot != INVALID_HANDLE_VALUE) 
    { 
        PROCESSENTRY32 pe = {0}; 
        pe.dwSize = sizeof(PROCESSENTRY32); 
 
        BOOL bRet = Process32First(hSnapshot, &pe); 
 
        while (bRet) 
        { 
            if (!_stricmp(cw(pe.szExeFile), szExeName)) 
            { 
                dwCount++; 
                dwRet = pe.th32ProcessID; 
            } 
            bRet = Process32Next(hSnapshot, &pe); 
        } 
 
        if (dwCount > 1) 
            dwRet = 0xFFFFFFFF; 
 
        CloseHandle(hSnapshot); 
    } 
 
    return dwRet; 
} 
 
 

util.h , tenia unos errores con el stricmp y logre crearme esta funcion xd

wchar_t * wc(const char* word)
{
    size_t newsize = strlen(word) + 1;
    wchar_t * wcs = new wchar_t[newsize];
 
    size_t convertedChars = 0;
    mbstowcs_s(&convertedChars, wcs, newsize, word, _TRUNCATE);
 
	return( wcs );
}
 
char * cw(const wchar_t* word)
{
    size_t newsize = wcslen(word) + 1;
    char * wcs = new char[newsize];
 
    size_t convertedChars = 0;
    wcstombs_s(&convertedChars, wcs, newsize, word, _TRUNCATE);
 
	return( wcs );
}
 
 

aca el link del programa victima.exe:
http://www.mediafire.com/download/4iwb35swrh4o8ei/victima.exe

victima.cpp

#include "stdafx.h"
#include <iostream>
#include <stdlib.h>
 
int _tmain(int argc, _TCHAR* argv[])
{
	int num=1000;
	while(num>0)
	{
		std::cout<<num<<std::endl;
		num-=10;
		system("pause");
	}
	return 0;
}
 
 

me gustaria que si alguno tiene alguna idea de como hacerlo me explicara, señores solo necesito eso xd la ***** posicion de la variable X xd pero .. una posicion que no cambie al reiniciar el programa, me gustaria una explicacion de lo que neceisto hacer y del error que estoy cometiendo xd

espero no haber publicado en la sección incorrecta y espero que alguien me responda al menos un "hola" xd

Gracias de antemano.