comment utiliser ISampleGrabber

comment utiliser ISampleGrabber - C++ - Programmation

Marsh Posté le 15-04-2008 à 20:31:11    

Bonjour  
Je suis entrain de travailler sur un programme implémenté pour un robot et qui utilise  IvmrWindowlesscontrol9,je veux récupérer l'image de la caméra montée sur le robot pour pouvoir l'utiliser avec une autre fonction qui va la traiter, mais j'arrive pas à réaliser ça, voiçi la partie  
 du code que je viens d'ajouter.  
Au niveau de fichier header j'ai ajouté:  
 
#include "Qedit.h"  // cette line une fois ajouté a généré plusieurs erreurs et je sais pas pourquoi!!!!???    
ISampleGrabber* pGrabber;  
IVMRWindowlesscontrol9* pwc;  
HRESULT GetCurrentBuffer(&size, (long *)pBuffer);  
   
 
Au programme principale j'ai ajouté  
 
if ( camera = RUNNING)  
 
{  
HRESULT hr;  
 
size = x*y*3; //x = height and y = weight  
 
char *pBuffer = new char[size];  
 
hr = pGrabber->GetCurrentBuffer(&size, (long *)pBuffer);  
 
if (FAILED(hr))  
 
AfxMessageBox("Impossible de récupérer le buffer" );  
 
else  
 
Function1(&pGrabber);// Function1 étant la fonction qui va traiter l'image  
 
}  
 
   
Si quelqu'un peut m'aider je serais trés reconnaissante et merci d'avance.


---------------
fedora6
Reply

Marsh Posté le 15-04-2008 à 20:31:11   

Reply

Marsh Posté le 15-04-2008 à 23:23:35    

Il faut connecter la source à la pin d'entrée de l'ISampleGrabber (en ayant spécifié le format du média désiré) puis connecter la sortie de l'ISampleGrabber a un renderer.

Reply

Marsh Posté le 16-04-2008 à 06:20:45    


Bonjour bjone,
Merci de m'avoir répondre mais est-ce que vous pouvez m'expliquer comment faire exactement je suis nulle en C++, quelle modification dois-je aujouter pour que ça fonctionne.

Reply

Marsh Posté le 16-04-2008 à 13:30:38    

bin en fait à voir le code, je m'attendais a cette réponse :D
 
Il te faut le Platform SDK (Windows 2003), dedans tu auras le graphedit, et par exemple dans le graphedit en ouvrant un média, tu verras le graphe directshow construit automatiquement.
 
tu pourras ajouter des filtres intermédiaires et jouer avec les connections des pins, ça te donnera une représentation mentale de comment ça marche, ce qui est obligatoire avant d'essayer de coder quoique ce soit.
 
ensuite commence a potasser la doc:
http://msdn2.microsoft.com/en-us/l [...] S.85).aspx
 
Comme essai à coder, l'idée est d'abord de commencer par instancier une source, instancier un renderer, puis de connecter les deux avec le gestionnaire de graphe.  
puis d'incruster des filtres (dont le ISampleGrabber)

Message cité 1 fois
Message édité par bjone le 16-04-2008 à 13:31:00
Reply

Marsh Posté le 19-05-2008 à 22:22:26    

bjone a écrit :

bin en fait à voir le code, je m'attendais a cette réponse :D
 
Il te faut le Platform SDK (Windows 2003), dedans tu auras le graphedit, et par exemple dans le graphedit en ouvrant un média, tu verras le graphe directshow construit automatiquement.
 
tu pourras ajouter des filtres intermédiaires et jouer avec les connections des pins, ça te donnera une représentation mentale de comment ça marche, ce qui est obligatoire avant d'essayer de coder quoique ce soit.
 
ensuite commence a potasser la doc:
http://msdn2.microsoft.com/en-us/l [...] S.85).aspx
 
Comme essai à coder, l'idée est d'abord de commencer par instancier une source, instancier un renderer, puis de connecter les deux avec le gestionnaire de graphe.  
puis d'incruster des filtres (dont le ISampleGrabber)


Bonjour  :hello:  
J'ai besoin d'aide car j'ai toujours des problémes avec le SampleGrabber.
voila une partie de mon code source:
Les déclarations:  

Code :
  1. long pBufferSize;
  2. unsigned char* pBuffer;
  3. unsigned char* buffer=0;
  4. unsigned char size = 640*576*3;
  5. unsigned int gWidth=0;
  6. unsigned int gHeight=0;
  7. unsigned int gChannels=0;


 
La fonction CaptureVideo() qui se charge de caputrer la video et qui fait appel à la fonction GrabData() qui me permet de récupérer le buffer(vers la fin de la fontion):  

Code :
  1. HRESULT CCaptureVideo::CaptureVideo()
  2. {
  3. HRESULT hr;
  4.     IBaseFilter *pSrcFilter=NULL;
  6.     // Get DirectShow interfaces
  7.     hr = GetInterfaces();
  8. if (FAILED(hr))
  9.     {
  10.         DisplayMesg(TEXT("Failed to get video interfaces!  hr=0x%x" ), hr);
  11.         return hr;
  12.     }
  14.     // Attach the filter graph to the capture graph
  15.     hr = m_pCapture->SetFiltergraph(m_pGraph);
  16.     if (FAILED(hr))
  17.     {
  18.         DisplayMesg(TEXT("Failed to set capture filter graph!  hr=0x%x" ), hr);
  19.         return hr;
  20.     }
  22.     // Use the system device enumerator and class enumerator to find
  23.     // a video capture/preview device, such as a desktop USB video camera.
  25. hr = FindCaptureDevice(&pSrcFilter);
  26.     if (FAILED(hr))
  27.     {
  28.         // Don't display a message because FindCaptureDevice will handle it
  29.         return hr;
  30.     }
  31. if( bDevCheck == FALSE)
  32. {
  33.  return E_FAIL;
  34. }
  37.     // Add Capture filter to our graph.
  38.     hr = m_pGraph->AddFilter(pSrcFilter, L"Video Capture" );
  39.     if (FAILED(hr))
  40.     {
  41.         DisplayMesg(TEXT("Couldn't add the capture filter to the graph!  hr=0x%x\r\n\r\n" )
  42.             TEXT("If you have a working video capture device, please make sure\r\n" )
  43.             TEXT("that it is connected and is not being used by another application.\r\n\r\n" ), hr);
  44.         pSrcFilter->Release();
  45.         return hr;
  46.     }
  48. // Create the Sample Grabber.
  49.          hr = CoCreateInstance(CLSID_SampleGrabber, NULL, CLSCTX_INPROC_SERVER,
  50.                                       IID_IBaseFilter, (void**) & pGrabberF);
  51.         if (FAILED(hr)) {
  52.                 return hr;
  53.       }
  54.         hr = m_pGraph->AddFilter(pGrabberF, L"Sample Grabber" );
  55.         if (FAILED(hr)) {
  56.                 return hr;
  57.      }
  59.         pGrabberF->QueryInterface(IID_ISampleGrabber, (void**)&pGrabber);
  60.    
  62.         AM_MEDIA_TYPE mt;
  63.         ZeroMemory(&mt, sizeof(AM_MEDIA_TYPE));
  64.         mt.majortype = MEDIATYPE_Video;
  65.         mt.subtype = MEDIASUBTYPE_RGB24;
  66.         hr = pGrabber->SetMediaType(&mt);
  67.         if (FAILED(hr)) {
  68.                 return hr;
  69.   }
  71.         hr = pGrabber->SetOneShot(FALSE);
  72.         hr = pGrabber->SetBufferSamples(TRUE);
  74.        hr = pSrcFilter->QueryInterface(IID_IAMVideoProcAmp, (void**)&pProcAmp);
  76. ConfigRenderer();
  78. // Add Renderer filter to our graph.
  79.     hr = m_pGraph->AddFilter(pVmr, L"VMR9" );
  81.     // Render the preview pin on the video capture filter
  82.     // Use this instead of m_pGraph->RenderFile
  83.     hr = m_pCapture->RenderStream (&PIN_CATEGORY_PREVIEW, &MEDIATYPE_Video,
  84.                                    pSrcFilter,pGrabberF, pVmr);
  85.     if (FAILED(hr))
  86.     {
  87.         DisplayMesg(TEXT("Couldn't render the video capture stream.  hr=0x%x\r\n" )
  88.             TEXT("The capture device may already be in use by another application.\r\n\r\n" )
  89.             TEXT("The sample will now close." ), hr);
  90.         pSrcFilter->Release();
  91.         return hr;
  92.     }
  94.         hr = pGrabber->GetConnectedMediaType(&mt);
  95.         if (FAILED(hr)) {
  96.                 return hr;
  97.         }
  99.         VIDEOINFOHEADER *pVih = (VIDEOINFOHEADER *)mt.pbFormat;
  100.         gChannels = pVih->bmiHeader.biBitCount / 8;
  101.         gWidth = pVih->bmiHeader.biWidth;
  102.         gHeight = pVih->bmiHeader.biHeight;
  104.     // Now that the filter has been added to the graph and we have
  105.     // rendered its stream, we can release this reference to the filter.
  106.     pSrcFilter->Release();
  108. #ifdef REGISTER_FILTERGRAPH
  109.     // Add our graph to the running object table, which will allow
  110.     // the GraphEdit application to "spy" on our graph
  111.     hr = AddGraphToRot(m_pGraph, &m_dwGraphRegister);
  112.     if (FAILED(hr))
  113.     {
  114.         DisplayMesg(TEXT("Failed to register filter graph with ROT!  hr=0x%x" ), hr);
  115.         m_dwGraphRegister = 0;
  116.     }
  117. #endif
  119.     // Start previewing video data
  120.     hr = m_pMC->Run();
  121.     if (FAILED(hr))
  122.     {
  123.         DisplayMesg(TEXT("Couldn't run the graph!  hr=0x%x" ), hr);
  124.         return hr;
  125.     }
  127.     // Remember current state
  128.       m_psCurrent = RUNNING;
  130. FILE *stream;
  131.   buffer = new unsigned char[size];
  133. for(int i=0;i<5;i++)
  134. {
  135.   Sleep(100);
  136.   buffer = GrabData();
  137.   if (buffer!=NULL)
  138.   {
  139.     stream=fopen("c:\somefile.txt","w+" );
  140.  //fwrite(buffer,3,sizeof(buffer),stream);
  141.     fprintf(stream,"%s",buffer);
  142.  fclose(stream);
  143.   }
  144. }
  147.   unsigned char image=GetImage();
  149.     return S_OK;
  150. }


La fonction GrabData() qui me permet de récupérer le buffer:

Code :
  1. unsigned char* CCaptureVideo::GrabData()
  2. {
  4. HRESULT hr;
  6.    if (pGrabber == 0)
  7.                 return 0;
  9.         long Size = 0;
  10.         hr = pGrabber->GetCurrentBuffer(&Size, NULL);
  11.         if (FAILED(hr))
  12.                 return 0;
  13.         else if (Size != pBufferSize) {
  14.                 pBufferSize = Size;
  15.                 if (pBuffer != 0)
  16.                         delete[] pBuffer;
  17.                 pBuffer = new unsigned char[pBufferSize];
  18.         }
  20.         hr = pGrabber->GetCurrentBuffer(&pBufferSize, (long*)pBuffer);
  21.         if (FAILED(hr))
  22.  {
  23.                 return 0;
  24.  }
  25.         else {
  26.    return pBuffer;               
  27.  }
  28. }


La fonction qui me permet de lire une bitmap:

Code :
  1. unsigned char * CCaptureVideo::LoadBitmapFile(char *filename, BITMAPINFOHEADER *bitmapInfoHeader)
  2. {
  3.     FILE *filePtr;    // Le pointeur du fichier
  4.     BITMAPFILEHEADER bitmapFileHeader;    // En-tête du fichier bitmap
  5.     unsigned char *bitmapImage; // Données du fichier bitmap
  6.     int imageIdx = 0; // image index counter
  7.     unsigned char tempRGB; // Variable temporaire de permutation BGR -> RGB
  9.     // Ouvre le fichier en lecture binaire
  10.     filePtr = fopen(filename, "rb" );
  11.     if (filePtr == NULL)
  12. { // Si l'ouverture du fichier ne s'est pas dérouler correctement, on quitte la fonction
  13.  return NULL;    // On quitte la fonction en renvoyant un NULL
  14. }
  15.     // Lecture de l'en-tête de fichier
  16.     fread(&bitmapFileHeader, sizeof(BITMAPFILEHEADER), 1, filePtr);
  18.     // On vérifie que le fichier est bien de type Bitmap
  19.     if (bitmapFileHeader.bfType != BITMAP_ID)
  20.     {
  21.         fclose(filePtr);    // Fermeture du fichier
  22.         return NULL;    // On quitte la fonction en renvoyant NULL
  23.     }
  25.     // Lecture des l'en-tête d'informations du Bitmap
  26.     fread(bitmapInfoHeader, sizeof(BITMAPINFOHEADER), 1, filePtr);
  28.     // Vérification de la compression. Doit être égal à BI_RGB
  29.     if (bitmapInfoHeader->biCompression != BI_RGB)
  30.     {
  31.         fclose(filePtr);    // Fermeture du fichier
  32.         return NULL;    // On quitte la fonction en renvoyant NULL
  33.     }
  35.     // Allocation de la mémoire pour contenir les données de l'image
  36.     bitmapImage = (unsigned char*)malloc(bitmapInfoHeader->biSizeImage);
  38.     // On vérifie l'allocation de la mémoire
  39.     if (!bitmapImage)
  40.     {
  41.         free(bitmapImage);    // Libération de la mémoire
  42.         fclose(filePtr);    // Fermeture du fichier
  43.         return NULL;    // Renvoie de NULL
  44.     }
  46.     // On place le pointeur du fichier au début des données du bitmap
  47.     fseek(filePtr, bitmapFileHeader.bfOffBits, SEEK_SET);
  49.     // Lecture des données de l'image
  50.     fread(bitmapImage, 1, bitmapInfoHeader->biSizeImage, filePtr);
  52.     // On s'assure que les données de l'image aient bien été lues
  53.     if (bitmapImage == NULL)
  54.     {
  55.         fclose(filePtr);    // Fermeture du fichier
  56.         return NULL;    // Renvoie de NULL
  57.     }
  59.     // Inversion du rouge et du bleu BGR -> RGB
  60.     for (imageIdx = 0; imageIdx < bitmapInfoHeader->biSizeImage; imageIdx+=3)
  61.     {
  62.         tempRGB = bitmapImage[imageIdx];
  63.         bitmapImage[imageIdx] = bitmapImage[imageIdx + 2];
  64.         bitmapImage[imageIdx + 2] = tempRGB;
  65.     }
  67.     fclose(filePtr);    // Fermeture du fichier
  68.     return bitmapImage;    // Renvoie des données de l'image
  70. }


La fonction qui me permet d'écrire une bitmap:

Code :
  1. BOOL CCaptureVideo::WriteBitmapFile(char *filename, int width, int height, unsigned char *imageData)
  2. {
  3.     FILE *filePtr; // Pointeur de fichier
  4.     BITMAPFILEHEADER bitmapFileHeader; // En-tête de fichier
  5.     BITMAPINFOHEADER bitmapInfoHeader; // En-tête d'informations
  6.     unsigned char tempRGB; // Variable temporaire pour changer BGR -> RGB
  8.     // Ouverture du fichier en mode écriture binaire
  9.     filePtr = fopen(filename, "wb" );
  10.     if (!filePtr)
  11.         return FALSE;
  13.     // Définition de tous les champs des en-tête
  14.     // En-tête de fichier BITMAPFILEHEADER
  15.     bitmapFileHeader.bfSize = sizeof(BITMAPFILEHEADER);
  16.     bitmapFileHeader.bfType = 0x4D42;
  17.     bitmapFileHeader.bfReserved1 = 0;
  18.     bitmapFileHeader.bfReserved2 = 0;
  19.     bitmapFileHeader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
  21.     // En-tête d'informations
  22.     bitmapInfoHeader.biSize = sizeof(BITMAPINFOHEADER);
  23.     bitmapInfoHeader.biPlanes = 1;
  24.     bitmapInfoHeader.biBitCount = 24;
  25.     bitmapInfoHeader.biCompression = BI_RGB;
  26.     bitmapInfoHeader.biSizeImage = width * abs(height) * 3;
  27.     bitmapInfoHeader.biXPelsPerMeter = 0;
  28.     bitmapInfoHeader.biYPelsPerMeter = 0;
  29.     bitmapInfoHeader.biClrUsed = 0;
  30.     bitmapInfoHeader.biClrImportant = 0;
  31.     bitmapInfoHeader.biWidth = width;
  32.     bitmapInfoHeader.biHeight = height;
  34.     // Inversion des composants RGB -> BGR  
  35.     for (unsigned int i = 0; i < bitmapInfoHeader.biSizeImage; i += 3)
  36.     {
  37.         tempRGB = imageData[i];
  38.         imageData[i] = imageData [i + 2];
  39.         imageData[i + 2] = tempRGB;
  40.     }
  42.     // Ecriture de l'en-tête de fichier  
  43.     fwrite(&bitmapFileHeader, 1, sizeof(BITMAPFILEHEADER), filePtr);
  45.     // Ecriture de l'en-tête d'informations  
  46.     fwrite(&bitmapInfoHeader, 1, sizeof(BITMAPINFOHEADER), filePtr);
  48.     // Ecriture des données de l'image  
  49.     fwrite(imageData, 1, bitmapInfoHeader.biSizeImage, filePtr);
  50.        
  51.     fclose(filePtr);    // fermeture du fichier
  52.     return TRUE;
  53. }


La fonction GetIamge():

Code :
  1. unsigned char CCaptureVideo::GetImage()
  2. {
  3. FILE* stream;
  4. BITMAPINFOHEADER bitmapInfoHeader;
  5. unsigned char* bitmapData;
  7. bitmapData = LoadBitmapFile("C:\search.bmp", &bitmapInfoHeader);
  8. if(bitmapData!=0)
  9. {
  10. bool write;
  12. write = WriteBitmapFile("c:\imagewrite",760,576,bitmapData);
  14. stream = fopen("wahiba.txt","w+" );
  15. fprintf(stream,"%s",bitmapData);
  16. fclose(stream);
  17. }
  18. return (unsigned char)bitmapData;
  19. }


 
Au début je veux bien m'excuser d'avoir envoyé tout à la fois.
Mes problémes sont les suivants:
1. le buffer récupérer par la fonction GrabData() n'est pas de taille fixe, j'essaye de l'écrire dans un fichier texte et le nombre des caractéres écrits est considérablement variable(entre 12000 et 180000), alors je pense qu'il n'est pas entrain de récupérer une image car la taille doit être fixe (largeur*hauteur*3(RGB)=640*576*3)
alors je voulais savoir où est le probléme et si mon raisonnement est correcte ou pas???????
 
2. Alors vu que la récupération du buffer est bloquée et que je dois avancé dans la projet j'ai essayé de lire une image sur le disque dûr pour pouvoir continuer par la suite(j'ai besoin d'une image pour le reste du projet) alors j'utilise la fonction LoadBitmap avec une image enregistrée dans le repertoire du projet et d'essayer de la écrire dans un fichier juste pour vérifier et de la réecrire une autre fois avec la fonction WriteBitmap, le probléme est que cette fonction fonctionne correctement une fois dans un fichier .cpp tout seule(contenant uniquement LoadbitmapFile, WritebitmapFile et GetImage) mais dans mon programme le fichier
 contenant l'image ne s'ouvre même pas(j'ai vérifié le chemin).
 
Alors si vous pouvez m'aider je serai vraiment trés reconnaissante  :jap: et merci d'avance.


---------------
fedora6
Reply

Marsh Posté le 20-05-2008 à 21:59:45    

Difficile de t'aiguiller.
 
sinon déjà:
unsigned char size = 640*576*3;  
KABOOOM :D
 
il me semble que chez ms il y a des exemples de capture d'une frame vidéo.
 
moi je me sers de directshow pour récuper l'audio de medias inconnus pour les position en OpenAl.
pas tourné autour de la capture précise d'une frame.
dans mon cas, je récupère aussi des buffers variables de samples audio, que je mets bout à bout.
 
dans le cas d'une capture de frame, il y a certainement des états qui permette de savoir quand tu as récupéré une frame entière.
 

Reply

Marsh Posté le 21-05-2008 à 11:28:42    

Pour le:
unsigned char size = 640*576*3;  
je l'ai utilisé parceque il m'a semblé que je dois spécifier le taille du buffer(l'imposé en quelque sorte) parceque la taille récupérée est notamment plus pétite que la taille réelle mais cela a donné le même résultat.
Je veux dire que même avant d'utiliser ce unsigned char size = 640*576*3; le probléme existait.
Alors je vais préciser une question:
Pour la fonction LoadBitmapFile j'arrive m^me pas à ouvrir le fichier de l'image dans mon programme alors que lorsque je l'ai utilisé dans u fichier .cpp à part ça a fonctionné à quoi est due cela vous pensez??? j'ai vérifié le chemin.


---------------
fedora6
Reply

Marsh Posté le 21-05-2008 à 13:27:54    

j'ai pas bien compris l'explication, mais pour être plus clair un unsigned char est limité à 255, donc ton 640*576*3 dépasse. (donc int ou unsigned int)  
 
après effectivement pour tes chemins, \ doit être traduit par \\  
genre "C:\search.bmp" ça doit être "c:\\search.bmp"
 
sinon ta fonction GetImage() pourrait juste retourner un bool pour indiquer le succès ou l'échec.
 
sinon:
stream = fopen("wahiba.txt","w+" );
fprintf(stream,"%s",bitmapData);
fclose(stream);
 
je suppose que c'est pour du débuggage voir si ça vit ?
mais bon avec un %s, t'ira pas bien loin (si y'a un octet à 0 dans les premiers pixels) ou t'ira trop loin (si y'a pas d'octet à 0 tu sors du buffer), donc c'est un peu voir totallement crade.
 
aussi essaye d'utiliser les iostreams.


Message édité par bjone le 21-05-2008 à 13:38:02
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed