zzd10h, voila en C comment je charge une image dans un buffer mémoire en utilisant les datatypes :


/*?*********************************************************
**????????????????????????????????????????????????????????**
**???AmiDARK?Engine?Development?Project???????????????????**
**??------------------------------------??????????????????**
**????????????????????????????????????????????????????????**
**?File???:?AOSLibDTT.o???????????????????????????????????**
**?Author?:?Frederic?Cordier??????????????????????????????**
**?Date???:?2013.04.18????????????????????????????????????**
************************************************************
*/

//?2013.04.18?:?Restructuration?complète?du?SDK
//
//?***************************************************************************************************************
/*???????????????????????????????????????????????????????????????Ouverture?d'une?librairie?et?de?son?interface.?*/
int?deOpenDataTypes(?void?){
??int?Success?=?0;
??DataTypesBase?=?MyOpenLibrary(?"datatypes.library",?0?);
??if?(?DataTypesBase?!=?NULL?){
????#if?defined(?__amigaos4__?)
??????IDataTypes?=?(struct?DataTypesIFace?*)InterfacePtr;
??????if?(?IDataTypes?!=?NULL?){
????????Success?=?1;
???????}
?????#else
??????Success?=?1;
?????#endif
???}
??return?Success;
?}

//?***************************************************************************************************************
/*?????????????????????????????????????????????????????????????????Fermeture?d'une?interface?et?d'une?librairie?*/
void?deCloseDataTypes(?void?){
??#if?defined(?__amigaos4__??)
????MyCloseLibrary(?DataTypesBase,?IDataTypes?);
???#else
????MyCloseLibrary(?DataTypesBase,?NULL?);
???#endif
?}

//?***************************************************************************************************************
/*?????????????????????????????????????????????????????????????Demande?de?création?d'un?buffer?image?en?32?bits?*/
struct?MyPicture?*?AllocPicture32(?int?Width,?int?Height?){
??struct?MyPicture?*pt?=?NULL;
??pt?=?(struct?MyPicture?*)MyAllocVec(?sizeof(?struct?MyPicture?),?MEMF_ANY|MEMF_CLEAR?);
??if?(?pt?){
????pt->Pixels?=?MyAllocVec(?Width?*?(?Height?+?1?)?*?4,?MEMF_ANY|MEMF_CLEAR?);
????pt->Width?=?Width;
????pt->Height?=?Height;
????pt->Depth?=?32;
????if?(?pt->Pixels?==?NULL?){
??????MyFreeVec(?pt?);
??????pt?=?NULL;
?????}
???}
??return?pt;
?}

//?***************************************************************************************************************
/*?????????????????????????????????????Suppression?d'un?buffer?mémoire?précédemment?alloué?par?AllocPicture32()?*/
void?FreePicture(?struct?MyPicture?*pt?){
??if?(?pt?){
????MyFreeVec(?pt->Pixels?);
????pt->Pixels?=?NULL;
????MyFreeVec(?pt?);
???}
?}

//?***************************************************************************************************************
/*????????????????????????????????????????????????????????????Chargement?d'une?image?en?utilisant?les?DataTypes?*/
struct?MyPicture?*?LoadPicture(?APTR?FileName?){
??struct?MyPicture?*pt?=?NULL;
??Object?*dto?=?NULL;
??ULONG?nb;
??ULONG?*?AvailMethod?=?NULL;
??struct?BitMapHeader?*bmh;
??struct?pdtBlitPixelArray?bpa;
??void?*?bpaptr?=?&bpa;
??if?(?!FileName?)?return?NULL;
??#if?defined(?__amigaos4__?)
????dto?=?IDataTypes->NewDTObject(?(STRPTR)FileName,
???????????????????????????????????DTA_SourceType,????DTST_FILE,
???????????????????????????????????DTA_GroupID,???????GID_PICTURE,
???????????????????????????????????PDTA_DestMode,?????PMODE_V43,
???????????????????????????????????PDTA_Remap,????????TRUE,
???????????????????????????????????OBP_Precision,?????PRECISION_EXACT,
???????????????????????????????????TAG_DONE?);
???#else
????dto?=?NewDTObject(?(STRPTR)FileName,
???????????????????????DTA_SourceType,????DTST_FILE,
???????????????????????DTA_GroupID,???????GID_PICTURE,
???????????????????????PDTA_DestMode,?????PMODE_V43,
???????????????????????PDTA_Remap,????????TRUE,
???????????????????????OBP_Precision,?????PRECISION_EXACT,
???????????????????????TAG_DONE?);
???#endif
??if?(?dto?!=?0?){
????#if?defined(?__amigaos4__?)
??????nb?=?IIntuition->GetAttrs(?dto,?PDTA_BitMapHeader,?&bmh,?TAG_DONE?);
?????#else
??????nb?=?GetDTAttrs(?dto,?PDTA_BitMapHeader,?&bmh,?TAG_DONE?);
?????#endif
????if(?nb?!=?0?){
??????int?resread;
??????/*?Allocation?de?la?structure?Picture?et?du?buffer?mémoire?*/
??????pt?=?AllocPicture32(?bmh->bmh_Width,?bmh->bmh_Height?);
??????if?(?pt?!=?NULL?){
????????bpa.pbpa_PixelData?=?pt->Pixels;
????????bpa.pbpa_PixelFormat?=?PBPAFMT_RGBA;
????????bpa.pbpa_PixelArrayMod?=?bmh->bmh_Width?*?4;
????????bpa.pbpa_Left?=?0;
????????bpa.pbpa_Top?=?0;
????????bpa.pbpa_Width?=?bmh->bmh_Width;
????????bpa.pbpa_Height?=?bmh->bmh_Height;
????????#if?defined(?__amigaos4__?)
??????????AvailMethod?=?IDataTypes->GetDTMethods(?dto?);
??????????if?(?IDataTypes->FindMethod(?AvailMethod,?PDTM_READPIXELARRAY?)?!=?0?){
????????????bpa.MethodID?=?PDTM_READPIXELARRAY;
????????????resread?=?IIntuition->IDoMethodA(?dto,?bpaptr?);
???????????}
?????????#else
??????????AvailMethod?=?GetDTMethods(?dto?);
??????????if?(?FindMethod(?AvailMethod,?PDTM_READPIXELARRAY?)?!=?0?){
????????????bpa.MethodID?=?PDTM_READPIXELARRAY;
????????????resread?=?DoMethodA(?dto,?bpaptr?);
???????????}
?????????#endif
???????}
?????}
?????#if?defined(?__amigaos4__?)
???????IIntuition->DisposeObject(?dto?);
??????#else
???????DisposeObject(?dto?);
??????#endif
???}
??return?pt;
?}


C'est le contenu de mon fichier libDataTypes_Functions.c
Tu y vois l'ouverture, la fermeture des datatypes (que tu dois déjà conna?tre)
la création et libération d'un buffer mémoire
et le chargement de l'image dans ce buffer mémoire...
Message édité par : AmiDARK / 08-03-2014 21:36

Merci beaucoup AmiDark, j'essaye tout ça au plus tôt.

:-D

>Comment tu remplis un buffer avec PDTM_READPIXELARRAY ?

Je croyais que tu voulais faire une capture écran ? auxquel cas pas besoin des datatypes utilise ReadPixelArray() avec un rastport perso
struct RastPort monrastport;
InitRastPort(&monrastport);
monrastport.BitMap=bm; /* celle du screen */
ReadPixelArray() avec comme params monrastport et ton buffer de highXlargeX3 et les dimensions de l'ecran

le ReadPixelArray sert a convertir ta bitmap qque soit son format vers un buffer rgb

Je suis pas sur mon PC là donc je peut pas t'envoyer d'exemple tout fait....

Alain

Merci Alain, cette méthode a l'air de fonctionner.

Je n'avais pas compris que tu parlais de la fonction ReadPixelArray8(). Je restais scotché sur PDTM_READPIXELARRAY des Datatypes :-D


J'ai bien qq chose dans le buffer mais quand je le sauvegarde en fichier (via LibDevil) j'obtiens soit une image majoritairement noire en JPG ou majoritairement blanche en PNG.

Tu n'aurais pas une idée d'où peut provenir mon pb, stp ???

D'ailleurs dans la fonction ReadPixelArray8() :
-à quoi sert le RastPort temporaire (temprastport dans le code ci-dessous) ?
-on a pas besoin de libérer le rastport initialisé par InitRastPort() ?

voir la vignette dans FastView en haut à gauche

http://zzd10h.amiga-ng.org/FastView/ScreenCapture.jpg

et le package avec source et exécutable

http://zzd10h.amiga-ng.org/FastView/ScreenCapture.lha

Merci

Voici ma fonction


void screenCapture()
{
             struct Screen *screen = NULL;
            UBYTE *buffer = NULL ;
            LONG count_pixel = 0 ;
            int largeur = 1920 ;
            int hauteur = 1080 ;
            int profondeur = 32 ;
                        
            buffer = AllocVecTags( (largeur * hauteur * profondeur)/8, AVT_ClearWithValue, 0,TAG_END);
      
              screen = LockPubScreen("Workbench");
                      
            struct RastPort monrastport; 
            InitRastPort(&monrastport);
            struct RastPort temprastport; 
            InitRastPort(&temprastport);             
            monrastport.BitMap=screen->RastPort.BitMap; /* celle du screen */ 
            UnlockPubScreen(NULL, screen);
            
            count_pixel = ReadPixelArray8(&monrastport,0,0,1920,1080,buffer,&temprastport) ;
            printf("count_pixel = %ld \n",count_pixel);
              
            char fileName[1024];
         //    strcpy(fileName,"RAM:Capture.JPG");
             strcpy(fileName,"RAM:Capture.PNG");             

            ILuint imageName ;             
             ILenum Format; 
                           
            ilInit();    
            ilGenImages(1, &imageName);    
            ilBindImage(imageName);

        //    if (profondeur == 8) {Format=IL_LUMINANCE;SaveRawBMP8(I,fileName);FreeVec(buffer);return;}     as IL_LUMINANCE is bugged in devIL  
            if (profondeur == 24) Format=IL_RGB; 
            if (profondeur == 32) Format=IL_RGBA; 
            ilTexImage(largeur,hauteur,1,profondeur/8,Format,IL_UNSIGNED_BYTE,buffer); 

            ilEnable(IL_FILE_OVERWRITE); 
            if(!ilSaveImage(fileName)) 
            { 
                printf("ilGetError %d !\n",ilGetError()); 
                FreeVec(buffer);                
                return; 
            } 
            ilDeleteImages(1,&imageName); 
                                 
            FreeVec(buffer);
}




Hello
Ca devrais marcher pourtant ...moi j'utilise writepixelarray de la même manière dans Warp3D .... mais j'ai jamais fait l'inverse...

Je parle de cette fonction "ReadPixelArray"
http://amiga.sourceforge.net/amigadevhelp/phpwebdev.php?keyword=ReadPixelArray&funcgroup=CyberGFX&action=Search

Faut lire le mêmemot :-P

>-à quoi sert le RastPort temporaire (temprastport dans le code ci-dessous) ?
Ici à rien (tu peut l'enlever) puisqu'on à déjà celui du screen mais c'est le principe pour lire une bitmap quelconque

>-on a pas besoin de libérer le rastport initialisé par InitRastPort() ?
Non
1) il est pas alloué mais juste une struct définie dans ton code donc pas besoin de faire free(monrastport);
2) InitRastPort mets juste des valeurs par défauts dedans
voir
http://amiga.sourceforge.net/amigadevhelp/phpwebdev.php?keyword=InitRastPort&funcgroup=AmigaOS&action=Search


Alain

Euh...

Je n'ai pas de CyberGFX/ReadPixelArray sur OS4...

Tu veux parler de Picasso96API/p96ReadPixelArray ?

>Je n'ai pas de CyberGFX/ReadPixelArray sur OS4...

Je sais pas d'où il sors mais j'ai bien un
sdk/include_h/interfaces/cybergraphics.h
avec une interface avec ses 2 fonctions (entre autres)

struct CyberGfxIFace
{
struct InterfaceData Data;

ULONG APICALL (*Obtain)(struct CyberGfxIFace *Self);
ULONG APICALL (*Release)(struct CyberGfxIFace *Self);
void APICALL (*Expunge)(struct CyberGfxIFace *Self);
struct Interface * APICALL (*Clone)(struct CyberGfxIFace *Self);
void APICALL (*Reserved1)(struct CyberGfxIFace *Self);
[...]

ULONG APICALL (*ReadPixelArray)(struct CyberGfxIFace *Self, APTR destRect, WORD destX, WORD destY, UWORD destMod, struct RastPort * a1arg, WORD SrcX, WORD SrcY, UWORD SizeX, UWORD SizeY, UBYTE DestFormat);
ULONG APICALL (*WritePixelArray)(struct CyberGfxIFace *Self, APTR srcRect, WORD SrcX, WORD SrcY, UWORD SrcMod, struct RastPort * a1arg, WORD DestX, WORD DestY, UWORD SizeX, UWORD SizeY, UBYTE SrcFormat);

Sinon utilise la méthode d'Amidark

Au final qque soit la méthode il faut obtenir un buffer avec la bitmap sous forme rgb (*) puis utiliser une fonction de sauvegarde de libjpg ou devIL

Alain

(*) Car la bitmap peut être en 15bits,16bits,rgb,bgr,argb,rgba,bgra,etc...

PS: tu pourrais lire la bitmap à la main mais il faudrait le faire dans un lock/unlockbitmap et récupérer l'adresse et le format des pixels de la bitmap
LockBitMapTags et LBMI_BASEADDRESS
GetCyberMapAttr et CYBRMATTR_PIXFMT

Tiens d'ailleurs Alain,
Comment on récupère le "format" d'un bitmap lorsqu'on l'a locké au préalable ?

Comme je viens d ecrire avec getcybermapattr et cybrmattr_pixfmt

Alain