Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

RÉCUPÉRER LES IMAGES D’UNE CAMERA IP TRANSMETTANT UN FLUX MJPEG


Information sur la source

Catégorie :Multimédia Classé sous : camera, ip, mjpeg Niveau : Débutant Date de création : 11/03/2006 Vu : 18 659

Note :
8,33 / 10 - par 3 personnes
8,33 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10

Commentaire sur cette source (26)
Ajouter un commentaire et/ou une note

Description

Récupérer les images d’une camera IP ( une DLINK DCS-900) transmettant un flux MJPEG (et non MPEG), transformation en image bitmap puis affichage.
Cette base me sert en robotique mobile (simple vision à distance) et pour différents projet (reconnaissance des formes, d’iris etc..) avec traitement.
Elle utilise la librairie PLIB ( plib.net plib.org) pour le transfert entre la camera (donc facilement  migrable sous linux), par contre elle utilise les fonctions windows pour la décompression JPEG ( mais on doit pouvoir facilement utiliser la librairie JPEG de ijg.org )

 

Source

  • /******************************************************************
  • * recuperation d'un flux Mjpeg venant d'une camera IP (DCS-900) *
  • * 320x200 *
  • * ouvre une connexion tcp client, envoi une requete http, traite *
  • * le flux reçu, extrait les images jpeg, les convertit, et *
  • * affiche le resultat *
  • ******************************************************************
  • * Copyright 2006 Grimal sylvain *
  • * utilisation libre pour application non commerciale *
  • ******************************************************************
  • * linker avec: net ul (plib) libsock32 libgdi32 libuser32 *
  • * libole32 liboleaut32 libolepro32 libuuid (.a ou .lib selon *
  • * compilateur) *
  • ******************************************************************/
  • #include <windows.h>
  • #include <olectl.h>
  • #include "include/netsocket.h" // librarie PLIB voir plib.net ou plib.org
  • #define TCP true
  • #define UDP false
  • #define longMaxJpeg 16384 // longueur maximale d'une image jpeg reçue (suffisant pour du 320x200)
  • unsigned char image[longMaxJpeg];
  • HWND hWmain;
  • netSocket *sockr;
  • // DC d'affichage
  • HDC hdcSortie;
  • // Bitmap après convertion du jpeg
  • HBITMAP hbmp;
  • /*******************************************************
  • * convertion d'une image Jpeg en bitmap *
  • * utilisation ole de windows cf msdn *
  • *******************************************************/
  • HBITMAP convertJpegBmp(LPBYTE pmem, DWORD nSize)
  • {
  • HRESULT hr;
  • CoInitialize(0);
  • HBITMAP hbmp_dst = 0;
  • // copie image jpeg dans global
  • HGLOBAL hgbl =(HGLOBAL)GlobalAlloc(GMEM_FIXED, nSize);
  • memcpy(hgbl, pmem, nSize);
  • // création du stream d'échange
  • IStream* stream = 0;
  • // image jpeg dans global dans stream
  • hr = CreateStreamOnHGlobal(hgbl, TRUE, &stream);
  • if(!SUCCEEDED(hr) || !stream) { // si erreur libération des objets déja crées
  • GlobalFree(hgbl);
  • CoUninitialize();
  • } else {
  • // création d'une 'picture'
  • IPicture* picture = 0;
  • // conversion stream vers picture
  • hr = OleLoadPicture(stream, nSize, 0, IID_IPicture, (void**)&picture);
  • if(!SUCCEEDED(hr) || !picture) { // si erreur libération des objets déja crées
  • stream->Release();
  • GlobalFree(hgbl);
  • CoUninitialize();
  • } else {
  • // recuperation du handle de la 'picture'
  • HBITMAP hbmp_src;
  • picture->get_Handle((OLE_HANDLE *)&hbmp_src);
  • // recuperation du handle du bitmap de la 'picture'
  • BITMAP bmp;
  • GetObject(hbmp_src, sizeof bmp, &bmp);
  • // bmp est le bitmap resultant mais son pointeur vers le contenu pointe vers le contenu de 'picture'
  • // comme on va dechargé la 'picture' on copie dans une autre zone memoire
  • hbmp_dst = (HBITMAP)CopyImage(hbmp_src, IMAGE_BITMAP, 0, 0, 0);
  • picture->Release();
  • stream->Release();
  • GlobalFree(hgbl);
  • CoUninitialize();
  • }
  • }
  • return hbmp_dst;
  • }
  • /****************************************************
  • * affiche une image jpeg contenue dans le tableau *
  • * image[52 ou 53 à longueur-5] *
  • ****************************************************/
  • int afficheImage(HWND hwnd, DWORD longueur)
  • {
  • HDC hdc;
  • DWORD debut;
  • // recherche debut variable selon texte indication taille image
  • debut=50; // normalement debut=52 si taille<10Ko et 53 si >
  • while (!((image[debut]==0xFF) & (image[debut+1]==0xD8)) & (debut<54)) {
  • debut ++;
  • }
  • // test entete et fin fichier JPEG
  • if ((image[debut]==0xFF) & (image[debut+1]==0xD8) &(image[longueur-6]==0xFF)&(image[longueur-5]==0xD9)) {
  • // conversion de l'image JPEG en Bitmap (ole Windows)
  • hbmp = convertJpegBmp((LPBYTE) &image[debut], longueur-debut-4);
  • // et affichage (GDI windows)
  • hdc = GetDC(hwnd);
  • SelectObject(hdcSortie, hbmp);
  • BitBlt(hdc, 0, 0, 320, 240, hdcSortie, 0, 0, SRCCOPY);
  • ReleaseDC(hwnd,hdc);
  • // et destruction du bitmap
  • DeleteObject(hbmp);
  • }
  • }
  • /***************************************************************
  • * Ouverture d'un socket TCP IP Plib port de sortie *
  • * geré automatiquement par plib non contrôlable mais avantage *
  • * gestion automatique si lancement de plusieurs applications *
  • ****************************************************************/
  • netSocket* OpenTcpMjpegParser(char* ip,unsigned int port)
  • {
  • netSocket *sockr;
  • netInit();
  • sockr= new netSocket();
  • sockr->open(TCP);
  • sockr->connect(ip,port);
  • return sockr;
  • }
  • /***************************************************************
  • * Fermeture du socket TCP IP *
  • ****************************************************************/
  • int CloseTcpMjpegParser(netSocket *sockr)
  • {
  • sockr->close();
  • }
  • /****************************************************************
  • * routine principale: ouvre une connection TCP/IP entre l'hote *
  • * (le client) et la camera (le serveur), envoi la demande http *
  • * *
  • *****************************************************************/
  • DWORD WINAPI TcpMjpegParser( void *param)
  • {
  • char rbuffer[2048];
  • char limiteImage[19]="--video boundary--"; // limite entre deux images sur dcs-900
  • int len;
  • DWORD pointeur=0;
  • DWORD i;
  • DWORD n;
  • bool flag;
  • //dc compatible avec mode d'affichage
  • hdcSortie = CreateCompatibleDC(0);
  • // ouverture du socket et envoi de la demande http GET
  • // mettre l'adresse de la camera
  • sockr=OpenTcpMjpegParser("172.16.186.51",80);
  • // requete http à envoyer à la camera pour recevoir le flux MJPEG à adapter à votre camera
  • // utiliser un sniffer lors d'une connexion avex IE par exemple
  • const char* s = netFormat ("GET /VIDEO.CGI HTTP/1.0\r\nUser-Agent: user\r\nAuthorization: Basic YWRtaW46REVVU1Q=\r\n\r\n") ;
  • sockr->send ( s, strlen(s) ) ;
  • /****************************************************************
  • * traitement des informations reçues dans le buffer. Attention *
  • * un buffer trop petit entraine la perte de TOUTES les infos *
  • * trouve la frontiere entre deux images JPEG *
  • *****************************************************************/
  • while(true) // a faire fin du thread
  • {
  • len=sockr->recv(rbuffer,2048,0);
  • // si on a reçue quelque chose
  • if (len>=0) {
  • // traitement un à un des octets reçus
  • for (i=0;i<len;i++) {
  • image[pointeur++]=rbuffer[i];
  • // on ne fait rien tant que l'on à pas reçu au moins 18 octets
  • if (pointeur>18) {
  • // test limite de l'image dans le flux
  • flag=true;
  • for (n=0;n<18;n++)
  • if (image[pointeur-18+n]==limiteImage[n])
  • flag=flag&true;
  • else
  • flag=false;
  • if (flag) {
  • afficheImage(hWmain, pointeur-18); // 18 pour suppression de la frontiere
  • Sleep(50) ;
  • pointeur=0;
  • }
  • }
  • } // fin de boucle for lecture du buffer
  • }
  • }
  • CloseTcpMjpegParser(sockr);
  • return 0;
  • }
  • /* Declare Windows procedure */
  • LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT mssg, WPARAM wParam, LPARAM lParam)
  • {
  • switch(mssg)
  • {
  • case WM_DESTROY:
  • DeleteObject(hbmp);
  • DeleteDC(hdcSortie);
  • PostQuitMessage(0);
  • return 0;
  • }
  • return DefWindowProc(hwnd, mssg, wParam, lParam);
  • }
  • /* Make the class name into a global variable */
  • char szClassName[ ] = "WindowsApp";
  • int WINAPI WinMain (HINSTANCE hThisInstance,
  • HINSTANCE hPrevInstance,
  • LPSTR lpszArgument,
  • int nFunsterStil)
  • {
  • // classique programmation de gestion windows (generé par dev c++)
  • MSG messages; /* Here messages to the application are saved */
  • WNDCLASSEX wincl; /* Data structure for the windowclass */
  • /* The Window structure */
  • wincl.hInstance = hThisInstance;
  • wincl.lpszClassName = szClassName;
  • wincl.lpfnWndProc = WindowProcedure; /* This function is called by windows */
  • wincl.style = CS_DBLCLKS; /* Catch double-clicks */
  • wincl.cbSize = sizeof (WNDCLASSEX);
  • /* Use default icon and mouse-pointer */
  • wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
  • wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
  • wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
  • wincl.lpszMenuName = NULL; /* No menu */
  • wincl.cbClsExtra = 0; /* No extra bytes after the window class */
  • wincl.cbWndExtra = 0; /* structure or the window instance */
  • /* Use Windows's default color as the background of the window */
  • wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
  • /* Register the window class, and if it fails quit the program */
  • if (!RegisterClassEx (&wincl))
  • return 0;
  • /* The class is registered, let's create the program*/
  • HWND hWnd;
  • hWnd = CreateWindowEx (
  • 0, /* Extended possibilites for variation */
  • szClassName, /* Classname */
  • "Vision hexapode", /* Title Text */
  • WS_OVERLAPPEDWINDOW, /* default window */
  • CW_USEDEFAULT, /* Windows decides the position */
  • CW_USEDEFAULT, /* where the window ends up on the screen */
  • 328, /* The programs width */
  • 270, /* and height in pixels */
  • HWND_DESKTOP, /* The window is a child-window to desktop */
  • NULL, /* No menu */
  • hThisInstance, /* Program Instance handler */
  • NULL /* No Window Creation data */
  • );
  • // pas très propre: handle de la fentre commun à tout le programme
  • hWmain=hWnd;
  • /* Make the window visible on the screen */
  • ShowWindow (hWmain, nFunsterStil);
  • //création du thread (API Windows) de recuperation et d'affichage
  • DWORD len=0;
  • DWORD total=0;
  • DWORD ThreadId;
  • HANDLE hThread ;
  • DWORD threadID;
  • hThread=CreateThread( NULL, 0, TcpMjpegParser, NULL, NULL , &ThreadId);
  • /* Run the message loop. It will run until GetMessage() returns 0 */
  • while (GetMessage (&messages, NULL, 0, 0))
  • {
  • /* Translate virtual-key messages into character messages */
  • TranslateMessage(&messages);
  • /* Send message to WindowProcedure */
  • DispatchMessage(&messages);
  • }
  • /* The program return-value is 0 - The value that PostQuitMessage() gave */
  • return messages.wParam;
  • }
/******************************************************************
 * recuperation d'un flux Mjpeg venant d'une camera IP (DCS-900)  *
 * 320x200                                                        *
 * ouvre une connexion tcp client, envoi une requete http, traite *
 * le flux reçu, extrait les images jpeg, les convertit, et       *
 * affiche le resultat                                            *
 ******************************************************************
 * Copyright 2006 Grimal sylvain                                  *
 * utilisation libre pour application non commerciale             *
 ******************************************************************
 * linker avec: net ul (plib) libsock32 libgdi32 libuser32        *
 * libole32 liboleaut32 libolepro32 libuuid (.a ou .lib selon     *
 * compilateur)                                                   *
 ******************************************************************/

#include <windows.h>
#include <olectl.h>
#include "include/netsocket.h" // librarie PLIB voir plib.net ou plib.org

#define  TCP true
#define  UDP false
#define longMaxJpeg 16384 // longueur maximale d'une image jpeg reçue (suffisant pour du 320x200)

unsigned char image[longMaxJpeg];

HWND hWmain;
netSocket *sockr; 

// DC d'affichage
HDC hdcSortie;
// Bitmap après convertion du jpeg
HBITMAP hbmp;

/*******************************************************
 *  convertion d'une image Jpeg en bitmap              *
 *    utilisation ole de windows  cf msdn              *
 *******************************************************/
HBITMAP convertJpegBmp(LPBYTE pmem, DWORD nSize)
{
  HRESULT hr;
  CoInitialize(0);
  HBITMAP hbmp_dst = 0;
  
  // copie image jpeg dans global
  HGLOBAL hgbl =(HGLOBAL)GlobalAlloc(GMEM_FIXED, nSize);
  memcpy(hgbl, pmem, nSize);
  
  // création du stream d'échange
  IStream* stream = 0;
  // image jpeg dans global dans stream
  hr = CreateStreamOnHGlobal(hgbl, TRUE, &stream);
  if(!SUCCEEDED(hr) || !stream) { // si erreur libération des objets déja crées
    GlobalFree(hgbl);
    CoUninitialize();                    
  } else {
     // création d'une 'picture'
     IPicture* picture = 0;
     // conversion stream vers picture
     hr = OleLoadPicture(stream, nSize, 0, IID_IPicture, (void**)&picture);
     if(!SUCCEEDED(hr) || !picture) { // si erreur libération des objets déja crées
        stream->Release();
        GlobalFree(hgbl);
        CoUninitialize();
    } else {
        // recuperation du handle de la 'picture'
        HBITMAP hbmp_src;
        picture->get_Handle((OLE_HANDLE *)&hbmp_src);
  
        // recuperation du handle du bitmap de la 'picture'
        BITMAP bmp;
        GetObject(hbmp_src, sizeof bmp, &bmp);
        // bmp est le bitmap resultant mais son pointeur vers le contenu pointe vers le contenu de 'picture'
        // comme on va dechargé la 'picture' on copie dans une autre zone memoire
        hbmp_dst = (HBITMAP)CopyImage(hbmp_src, IMAGE_BITMAP, 0, 0, 0);

        picture->Release();
        stream->Release();
        GlobalFree(hgbl);
        CoUninitialize();
    }
  }
  return hbmp_dst;
}

/****************************************************
 * affiche une image jpeg contenue dans le tableau  *
 * image[52 ou 53 à longueur-5]                     *
 ****************************************************/
int afficheImage(HWND hwnd, DWORD longueur)
{
     HDC hdc;
     DWORD debut;     
     // recherche debut variable selon texte indication taille image
     debut=50; // normalement debut=52 si taille<10Ko et 53 si >
     while (!((image[debut]==0xFF) & (image[debut+1]==0xD8)) & (debut<54)) {
           debut ++;
     }
     // test entete et fin fichier JPEG 
     if ((image[debut]==0xFF) & (image[debut+1]==0xD8) &(image[longueur-6]==0xFF)&(image[longueur-5]==0xD9)) {
          // conversion de l'image JPEG en Bitmap  (ole Windows)
          hbmp = convertJpegBmp((LPBYTE) &image[debut], longueur-debut-4);     

          // et affichage (GDI windows)
          hdc = GetDC(hwnd);          
          SelectObject(hdcSortie, hbmp);
          BitBlt(hdc, 0, 0, 320, 240, hdcSortie, 0, 0, SRCCOPY);
          ReleaseDC(hwnd,hdc);
          // et destruction du bitmap 
          DeleteObject(hbmp);
     }
}


/***************************************************************
* Ouverture d'un socket TCP IP  Plib  port de sortie           *
* geré automatiquement par plib non contrôlable mais avantage  *
* gestion automatique si lancement de plusieurs applications   *
****************************************************************/
netSocket* OpenTcpMjpegParser(char* ip,unsigned int port)
{
   netSocket *sockr; 
   netInit();
   sockr= new netSocket();
   sockr->open(TCP);
   sockr->connect(ip,port);
   return sockr;
}

/***************************************************************
* Fermeture du socket TCP IP                                   *
****************************************************************/
int CloseTcpMjpegParser(netSocket *sockr)
{
   sockr->close();
}

/****************************************************************
* routine principale: ouvre une connection TCP/IP entre l'hote  *
* (le client) et la camera (le serveur), envoi la demande http  *
*                                                               *
*****************************************************************/
DWORD WINAPI TcpMjpegParser( void *param)
{  
   char rbuffer[2048];
   char limiteImage[19]="--video boundary--"; // limite entre deux images sur dcs-900
   int len;
   DWORD pointeur=0;
   DWORD i;
   DWORD n;
   bool flag;

   //dc compatible avec mode d'affichage
   hdcSortie = CreateCompatibleDC(0);
   
   // ouverture du socket et envoi de la demande http GET
   // mettre l'adresse de la camera
   sockr=OpenTcpMjpegParser("172.16.186.51",80);
   // requete http à envoyer à la camera pour recevoir le flux MJPEG à adapter à votre camera
   // utiliser un sniffer lors d'une connexion avex IE par exemple
   const char* s = netFormat ("GET /VIDEO.CGI HTTP/1.0\r\nUser-Agent: user\r\nAuthorization: Basic YWRtaW46REVVU1Q=\r\n\r\n") ;
   sockr->send ( s, strlen(s) ) ;

   /****************************************************************
   * traitement des informations reçues dans le buffer. Attention  *
   * un buffer trop petit entraine la perte de TOUTES les infos    *
   * trouve la frontiere entre deux images JPEG                    *
   *****************************************************************/

   while(true)  // a faire fin du thread
   {

     len=sockr->recv(rbuffer,2048,0);

     // si on a reçue quelque chose
     if (len>=0) {
       // traitement un à un des octets reçus          
       for (i=0;i<len;i++) {
            image[pointeur++]=rbuffer[i];
            // on ne fait rien tant que l'on à pas reçu au moins 18 octets
            if (pointeur>18) {
               // test limite de l'image dans le flux
               flag=true;    
               for (n=0;n<18;n++) 
                   if (image[pointeur-18+n]==limiteImage[n])
                      flag=flag&true;
                   else
                      flag=false;

                 if (flag) { 
                    afficheImage(hWmain, pointeur-18);  // 18 pour suppression de la frontiere
                    Sleep(50) ;
                    pointeur=0;
                 }
            }
       }   // fin de boucle for lecture du buffer
     }
   }
   CloseTcpMjpegParser(sockr);
   return 0;
}


/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT mssg, WPARAM wParam, LPARAM lParam)

{
  switch(mssg)
  {    
  case WM_DESTROY:
    DeleteObject(hbmp);
    DeleteDC(hdcSortie);
    PostQuitMessage(0);
    return 0;
  }
  return DefWindowProc(hwnd, mssg, wParam, lParam);
}



/*  Make the class name into a global variable  */
char szClassName[ ] = "WindowsApp";

int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int nFunsterStil)

{
    // classique programmation de gestion windows (generé par dev c++)
    MSG messages;            /* Here messages to the application are saved */
    WNDCLASSEX wincl;        /* Data structure for the windowclass */

    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
    wincl.cbSize = sizeof (WNDCLASSEX);

    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 /* No menu */
    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
    wincl.cbWndExtra = 0;                      /* structure or the window instance */
    /* Use Windows's default color as the background of the window */
    wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&wincl))
        return 0;

    /* The class is registered, let's create the program*/
    HWND hWnd;

    hWnd = CreateWindowEx (
           0,                   /* Extended possibilites for variation */
           szClassName,         /* Classname */
           "Vision hexapode",       /* Title Text */
           WS_OVERLAPPEDWINDOW, /* default window */
           CW_USEDEFAULT,       /* Windows decides the position */
           CW_USEDEFAULT,       /* where the window ends up on the screen */
           328,                 /* The programs width */
           270,                 /* and height in pixels */
           HWND_DESKTOP,        /* The window is a child-window to desktop */
           NULL,                /* No menu */
           hThisInstance,       /* Program Instance handler */
           NULL                 /* No Window Creation data */
           );
     // pas très propre: handle de la fentre commun à tout le programme 
      hWmain=hWnd;
      
    /* Make the window visible on the screen */
    ShowWindow (hWmain, nFunsterStil);


 
   //création du thread (API Windows) de recuperation et d'affichage
   DWORD len=0;
   DWORD total=0;
   DWORD ThreadId;
   HANDLE hThread  ;
   DWORD threadID;
   hThread=CreateThread( NULL, 0, TcpMjpegParser, NULL, NULL , &ThreadId);  
   
    /* Run the message loop. It will run until GetMessage() returns 0 */
    while (GetMessage (&messages, NULL, 0, 0))
    {    
        /* Translate virtual-key messages into character messages */
        TranslateMessage(&messages);
        /* Send message to WindowProcedure */
        DispatchMessage(&messages);
 
    }

    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}

Commentaires et avis

signaler à un administrateur
Commentaire de poldere le 12/03/2006 14:28:21

Salut! Tiens ! Tu travaille sur un robot ? Moi aussi. A l'occasion on pourra avoir un contact pour échange vocal. De mon coté je suis en VB , win XP et cam USB ( un peu différent n'est ce pas lol ). A  plus . . .

signaler à un administrateur
Commentaire de aerith le 14/03/2006 11:11:32

J'ai commencer un algo de traitement d'image (il en est a la recherche de lignes complexes), sont but seras la vision binoculaire, en C+SDL...
Si tu arrive a me motivé je veux bien le continuer...

Je doit modifier cette recherche de ligne pour la rendre plus sensible, avec une notion d'intervale.

Je dev portable...

signaler à un administrateur
Commentaire de poldere le 14/03/2006 11:16:58

concernat la vision binoculaire . . . . tu connait ce site http://www.fuzzgun.btinternet.co.uk/rodney/rodney.htm . Si ça peut t'aider il y a un bon projet et de bonnes sources.

signaler à un administrateur
Commentaire de turnerom le 10/04/2006 16:45:20

Salut
dans ton code, tu déclare
#define longMaxJpeg 16384 // longueur maximale d'une image jpeg reçue (suffisant pour du 320x200)
Comment tu trouve ton 16384, comment le caluler ? car moi j'utilise du 320x240.
Merci

signaler à un administrateur
Commentaire de turnerom le 18/04/2006 11:10:10

Pour que ca marche il faut aussi linker avec libws2_32.a et libwsock32.a.

signaler à un administrateur
Commentaire de hugo_cpp le 12/05/2006 16:53:03

Slt,
Merci pour ton code, il est plutôt bien fait et surtout il marche!! Je l'ai adapter pour ma camera (Sony SNC-P1) car elle peut délivrer soit des MJPEG, soit du MPEG4. J'aimerai maintenant récupérer le flux MPEG4, pense-tu que c'est possible à partir de ton code? J'ai pas encore eu trop le temps de me pencher dessus mais si je trouve je te previens.
A+

signaler à un administrateur
Commentaire de sarkosichon le 09/06/2006 12:07:20

salut!
Merci pour ton code mais je n'arrive pas à le compiler. je ne trouve pas la lib plib. j'ai trouvé netSocket.h mais il me manque toujours des fichiers d'en tete. si tu peu m'aiguillé ou ziper ton repertoire include et le mettre sur le site ca serai bien sympa de ta part.
merci d'avance.

signaler à un administrateur
Commentaire de poseidon162 le 07/07/2006 15:04:37

Salut a tous.

Deja bien ton code.
Moi je travailles avec une DCS-6620G mais je dois recuperer le flux video afin de l'afficher dans une frame.
Alors j'arrive a controler la camera au niveau rotation par contre impossible de recuperer le flux.
J'utilise ethereal pour recuperer la requete a envoyer mais lorsque je l'envoie j'ai une exception : "Le serveur a renvoyé une réponse non valide ou non reconnue".
Pourtant j'envoi la même requête qu'IE.

voila le code correspondant.

char *l_strHeaders2 = "User-Agent: VVTK (ver=40)\r\nAccept: */*\r\nHost: 10.226.144.238\r\n\r\n";
char *l_strObject2 = "/cgi-bin/downstream.cgi?SID=0";
m_pconnection = m_session.GetHttpConnection(l_strServeur, port , "VVTK (ver=40)");
m_pfile = m_pconnection->OpenRequest(CHttpConnection::HTTP_VERB_GET , l_strObject2,NULL , 1 , NULL , "HTTP/1.0");
if(m_pfile != NULL)
{
try
{
m_pfile->AddRequestHeaders(l_strHeaders2);
m_pfile->SendRequest(NULL,0,NULL,0);
}
catch(CInternetException *e)
{
char error[255];
e->GetErrorMessage(error,255);
}
catch(CException  *e)
{
char error[255];
e->GetErrorMessage(error,255);
}
}

et voila la requete envoyé par IE vu par ethereal :
GET /cgi-bin/downstream.cgi?SID=0 HTTP/1.0

User-Agent: VVTK (ver=40)

Accept: */*

Host: 10.226.144.238

et voila la mienne :

GET /cgi-bin/downstream.cgi?SID=0 HTTP/1.1

User-Agent: VVTK (ver=40)

Accept: */*

Host: 10.226.144.238



alors je me dit que c a cause du HTTP/1.1 mais il me le met par defaut et je ne sais comment le passer en 1.0.

Si quelqu'un a une idée je vous serez vraiment reconnaissant.

Merci d'avance

signaler à un administrateur
Commentaire de je7ch le 14/12/2006 20:55:18

salut
j'arrive à compiler votre code mais il ne veut pas s'executer.Bon il m'affiche le message suivant "fatal error C1010: unexpected end of file while looking for precompiled header directive
Error executing cl.exe."
j'ai besoin de votre aide s.v.p .C'est tres important.
merci

signaler à un administrateur
Commentaire de isetcom le 14/12/2006 21:19:52

salut
je suis un etudiant en informatique je suis entrient de travailler sur la videsurveillance ip. ce pendant j'ai un probleme avec la compilation de votre code il ne genére pas .exe si vous pouvez m'aidé je serais tres reconéssant. c'est tres urgent svp.
voila mon e-mail:mekki.ben-younes@laposte.net
merci d'avance..

signaler à un administrateur
Commentaire de Nylsax le 29/01/2007 11:14:04

Salut je voudrai comprendre cette ligne de programme :
const char* s = netFormat ("GET /VIDEO.CGI HTTP/1.0\r\nUser-Agent: user\r\nAuthorization: Basic YWRtaW46REVVU1Q=\r\n\r\n") ;
Je sais pas comment tu apel ? netFormat ? d'ou il vient ?
Merci.

signaler à un administrateur
Commentaire de 4u4me4us le 05/03/2007 11:53:05

Salut,
J'arrive pas a compiler tu peu me donner la lib netsoket STP

signaler à un administrateur
Commentaire de kalidor86 le 14/08/2007 11:58:23

Salut à vous,

j'ai un problème avec la fonction netInit() à la compliation il me met une error comme quoi elle a besoin d'arguments (elle est appelée avec des arguments dans  netSocket.h)
Or si je modifie la fonction dans le .h en lui virant les arguments , il la reconnait plus quand il doit aller la chercher dans la lib et me fait une erreur du type lnk2019.

Comme vous arruvez à le compiler je comprend pas d'où vient mon erreur.
pour info ,j'utilise Visual C++

Merci d'avance pour votre aide :)

signaler à un administrateur
Commentaire de Crepuscule3 le 24/11/2007 09:07:28

Bonjour à tous,

   je travaille actuellement sur une camera axis 207MW. Je souhaiterais faire un traitement d'image temps réel sur le flux MJPEG ou MPEG4 provenant de cette camera IP, dans le but de ne visualiser que les contours des objets filmés. Je possède actuellement un programme provenant de chez axis me permettant de relever le flux MJPEG. J'arrive donc à le visualiser mais je n'arrive toujours pas à trouver comment faire un traitement vidéo dessus (pour cela il me faudrait un accès aux pixels). Par ailleurs, je préciserai que les commandes utilisées pour afficher la vidéo sont des fonctions "InvokeHelper" de ActiveX ou DirectX je ne sais plus.
   Si l'un d'entre vous a réussit à faire un traitement d'image sur un flux MJPEG, ou si quelqu'un a réussit à faire marcher le programme de cette page web, ou encore si quelqu'un sait comment utiliser le programme de chez axis, pourriez vous me donner un coup de main? Je galère vraiment depuis quelque temps.

Cordialement

Crepuscule3

signaler à un administrateur
Commentaire de SebLinck le 03/06/2008 11:17:08

Salut,
je travail sur une Axis 210, il est possible d'utiliser la même méthode que propose GSDevelop, mais il faut changer légèrement la requête ( ça va sans dire ).

"GET /axis-cgi/mjpg/video.cgi?resolution="320x240"&fps="25" HTTP/1.1\r\nUser-Agent: HttpClient\r\nHost:"192.168.10.50"\r\nConnection:Keep-Alive\r\nCache-Control:no-cache\r\n\r\n"

Voilà, sinon il est très facile de récupérer un flux M-jpeg en utilisant l'exemple AXIS,
mais comme le souligne Crepuscule3, il est assez difficile de faire un traitement derrière.
En revanche, la méthode fournis par AXIS est très bonne pour un enrgistrement de flux...

signaler à un administrateur
Commentaire de youp_youp_ le 17/11/2008 18:00:03

Bonjour,

je souhaiterai savoir si l'un de vous à réussi dans cette mission qu'est la récupération des pixels de l'image?

Bonne soirée

signaler à un administrateur
Commentaire de youp_youp_ le 24/11/2008 21:02:12

up

signaler à un administrateur
Commentaire de Crepuscule3 le 25/11/2008 08:06:36

Bonjour Youp_youp...

   Pour ta question, lorsque j'étais encore sur mon projet de master 2, j'ai finis par réussir à récupérer les pixels dans un tableau que je pouvais traiter à ma guise.
Cela remonte maintenant à plus d'un an et je m'apprête à partir au travail, tout ce que je peux donc faire pour l'instant c'est te donner l'adresse d'un de mes messages sur ce forum où il me semble que je donne la solution (pour le cas d'une camera AXIS207MW utilisant un flux MJPEG).

http://www.cppfrance.com/forum/sujet-RECUPERER-IMAGE-DEPUIS-BUFFER_1043087.aspx

De mémoire, il me semble qu'il faut utiliser une fonction d'Axis genre GetCurrentImage(.. , .. , ..) avec les arguments qui vont bien, ce qui te récupère dans un buffer (qui a été passé en argument de la fonction) une image bitmap (dans le premier argument il me semble, si tu mets 1 ça fait du bitmap, si tu mets 0 ça fait du JPEG).

Je n'avais que 2 mois pour mon projet en plus des cours, je n'ai pas atteint le bout mais il ne me restait plus qu'à réafficher mes images traités dans une fenêtre.

J'espère que ça pourra t'aider.

Sinon, si tu veux plus d'info sur ce que j'avais fait en projet de master, recherche "Crepuscule3" sur ce forum, tu devrais trouver tous mes messages sur le sujet. Peut-être que ça t'aidera.

Cordialement,

Crepuscule3

signaler à un administrateur
Commentaire de zouzoualg le 27/04/2009 23:12:11

slt,
merci pour ton code , ce geniale comme idée , je voulus le compiler mais je trouver quelque deficulte ce qui conserne le linker , j'utilise visual studio C++2008 comme IDE et je ne trouve pas les lib suivants: libgdi32 libuser32 libole32 liboleaut32 libolepro32 libuuid dans mon IDE , et ce qui conserne libsock32 d'ou je peut le charger ?
merci d'avace pour votre aide :)

signaler à un administrateur
Commentaire de SebLinck le 30/04/2009 19:07:13

Salut,

Si Visual Studio 2008 ne trouve pas lalib GDI, c'est la loose...
Tu asfait quoi comme type de projet ?

signaler à un administrateur
Commentaire de zouzoualg le 09/05/2009 12:27:07 8/10

salut Seblink ,
merci de m'avoir répondu ,j'arrivais à compiler cet programme ,j'ai voulu essayer d'integrer cet programmme pour mon projet sur la detection des visages , Mais est ce que vous avez une idée si je peut récupère mon flux MJPEG non pas par une camera mais par un flux MPEG transmis par un client dans un réseaux local ?
merci d'avance pour votre aide :)

signaler à un administrateur
Commentaire de ALICE009 le 09/06/2009 10:59:35

salut ,
je veux récupérer les images d'une camera IP 300 (512 x 480) est ce que je peux adapter ce code pour mon camera IP 300 TRENDnet ?

merci d'avance pour votre aide :)

signaler à un administrateur
Commentaire de SebLinck le 09/06/2009 21:51:58

Salut,

Si ta caméra IP possède un serveur web intégré sur lequel tu peux te connecter,
pour visualiser le flux live en MJPEG, tu peux très simplement adapter ce code.

signaler à un administrateur
Commentaire de SebLinck le 09/06/2009 21:58:39

Désolé ZOUZOUAG, je n'avais pas vu ta question.
Pour utiliser un client sur le réseaux local
comme source du flux, il faut soit connaitre
son protocole ( dans notre cas, protocole HTTP)
soit utiliser une API ou SDK fournissant une méthode.
Par exemple pour Axis:
Il faut lier le programme avec la lib de l'API,
puis appeller la méthode GetCurrentImage(...),
avec les paramètres qui vont bien. Et tu retrouves
ton image dans un buffer.Qu'il ne reste plus qu'a
pousser sur l'interface .

signaler à un administrateur
Commentaire de ALICE009 le 09/06/2009 22:28:31

salut SEBLINCK ,
oui mon camera IP possède un serveur web intégré , le probleme que le flux transmit par la camera IP est MPEG et non pas MJPEG ?
pour l'adabtation du code :

const char* s=netFormat("GET /TRENDnet-cgi/mpeg/video.cgi?resolution="512 x 480"&fps="25" HTTP/1.1\r\nUser-Agent: HttpClient\r\nHost:"192.168.0.30"\r\nConnection:Keep-Alive\r\nCache-Control:no-cache\r\n\r\n");

est ce que c'est juste ?

signaler à un administrateur
Commentaire de SebLinck le 12/06/2009 08:07:26

Salut,

Il faudrait savoir de quel type de mpeg est ton flux d'abord ...
Par exemple certain type de mpeg ne renvois que les pixels qui ont
changé dans l'image par rapport à la précédente ...
Ce qui va engendrer de grosses modifications dans ce code.
Si ta caméra est une TrendNet Tv-IP 300 elle gère le lux MJPEG.
Et si ce n'est pas le cas, il existe du code LGPL chez trend Net:
http://www.trendnet.com/downloads/list_gpl.asp
Avec ça tu devrais pouvoir faire quelque chose de bien !
Bon courage ...

Ajouter un commentaire

Discussions en rapport avec ce code source dans le forum

capture de flux d une camera IP et detecttion d intrusion physique en c++ [ par mannatheking ] voilà j ai un projet de fin d'etude qui s intitule capture de flux video d une camera IP et detection d intusion en C++ sur windows.pour le moment je camera ip + c++ builder 3 [ par pingusfab ] bonjourvoila je souhaiterai recevoir la video en direct d'une camera ip accesible par un navigateur web par son adresse ipd'apres la doc le peut recup reception données depuis gprs vers une @ ip fixe [ par zdoucha ] Salut à tous, Je veux developper une application qui me permet de recuperer une donnée envoyé par un µcontrolleur msc1210 a travers un gprs vers une @ Problem avec les #DEFINE avec winapi en c [ par dyroj ] Bonjour a tous,je suis en train de créer un programme et avec une interface graphique (winapi)  créer par les ressource.j'utilise les DEFINE pour iden Nslookup pour trouver l'ip [ par dolsky ] Bonjour,Je cherche à récupérer les adresses IP d'une liste des machines que j'ai sur AD.J'ai le script suivant avec la liste des machine que j'indique url ip [ par dyroj ] salut a tous,comment recuperer une ip a partir dune url.++ adresse ip [ par moughite ] salut tout le monde j'arrive pas a réaliser un programme en c++ qui permet d'afficher les information de la commande (ipconfig) c'est a dire (adresse Violation d'accès mémoire [ par zoneart ] Bonjour,Je suis débutant et j'ai écris deux trois lignes de codes que j'aimerais vous soumettre car une erreur de violation d'accès mémoire survient l


Nos sponsors

Sondage...

CalendriCode

Juillet 2009
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
2728293031  

Consulter la suite du CalendriCode

Téléchargements

Comparez les prix Nouvelle version

Photothèque Nouveau !



Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés
Temps d'éxécution de la page : 0,858 sec

Google Coop CodeS-SourceS Google Coop CodeS-SourceS


Certaines images présentes sur le site (notament certains avatars) sont issues des collections IconShock, donc si vous souhaitez utiliser ces icons vous devez les acheter, ne les copiez pas et ne utilisez pas dans vos sites et applications sans les avoir commandé.