Blog du projet Odyssea Media Center

Journal de bord de la création d’un logiciel média center, Odyssea

Sotoaleono — Wed, 05 Feb 2014 13:48:37 +0000

Plusieurs tentatives de programmation jonchent le parcours, en effet, au fur et à mesure des avancées, on se rend compte, assez tardivement, que le chemin emprunté n’était pas le bon…

Ce qui est assez énervant, c’est de savoir que l’on fait des allers retours, et que c’est assez peu constructif…

Nouvelle étape dans le processus de création du logiciel : la création d’un serveur.

Pourquoi un serveur, tout simplement pour qu’il serve, mais qu’il serve qui et surtout à quoi?

Simple, dans mon univers ( ma maison, quatre ordinateurs, et uniquement un avec deux tuners tnt, et 3 To de vidéos et séries, et un autre avec un tuner usb), et donc il me faut un moyen, de contrôler ces derniers et éventuellement pouvoir diffuser la télévision sur le réseau. Bref un serveur…

Cependant, au fur et à mesure, je me dis que la gestion des fichiers présents doit aussi être effectuée par ces serveurs, car la phase d’identification et de téléchargement, mise à jour des divers éléments peut être effectuée par ce même logiciel.

Donc je me suis retroussé les manches et mis au travail :

Première étape, la recherche des ordinateurs aux alentours et connectés au réseau. Fait

Deuxième étape, la recherche des fichiers et leurs identifications ( ainsi que la non prise en compte des doublons etc ). Fait.

En effet, les nombreuses tentatives d’indexations m’ont permis de mettre en place assez rapidement des fonctions déjà éprouvées ( Requête internet, utilisation API The Movie DB et The TVDB), et ainsi gagner du temps sur ce processus…

La troisième étape en non des moindres, la communication entre deux ordinateurs, c’est à dire obtention des informations concernant les fichiers, et la disponibilité des serveurs, est en cours de conception, bref je jonglerai avec les thread, directshow et la tnt…. Bref que du bonheur.

La suite au prochain épisode!!

DirectShow Réception de la TNT (DVB-T)

Sotoaleono — Mon, 27 Jan 2014 18:18:30 +0000

Dans ce billet, je tenterai de décrire, certainement maladroitement, la programmation de la réception d’un tuner TNT par le biais de DirectShow.

Après plusieurs heures(voire des jours) de recherches et d’essais, j’ai finalement réussi à recevoir des images via mon tuner tnt usb. Ce n’était pas sans mal car, il faut le reconnaître, le net ne regorge pas de plusieurs exemples en la matière, ni des sources fonctionnant correctement…

La devise et maître mot de ce billet est donc :
« La théorie, c’est quand on sait tout et que rien ne fonctionne. La pratique, c’est quand tout fonctionne et que personne ne sait pourquoi. »

Là il y aura beaucoup de pratique….

D’abord créer une structure pour recevoir les données concernant les tuners et les filtres etc….

struct TUNERSTRUCT
{
BSTR Name;
char *Char_Name;

SmartPtr pTuner;
SmartPtr pDVBTLocator;
SmartPtr TuningSpace;
SmartPtr pTuneRequest;
SmartPtr pDVBTuneRequest;
SmartPtr DirectSoundRenderer;
SmartPtr VideoRenderer;
SmartPtr m_pNetworkProvider;
SmartPtr m_pTunerDemodDevice; // for tuner device filter
SmartPtr m_pBDACaptureDevice; // for tuner device filter
SmartPtr m_pDemux; // for tuner device filter
SmartPtr m_pBDASecTab;
SmartPtr m_pTSFileSink;
SmartPtr m_pBDATIF;
SmartPtr m_pTunerPin; // the tuner pin on the tuner/demod filter
SmartPtr m_pDemodPin; // the demod pin on the tuner/demod filter
SmartPtr m_KsTunerPropSet; // IKsPropertySet for tuner
SmartPtr m_KsDemodPropSet; // IKsPropertySet for demod

};

La première chose à faire est de récupérer le nom des tuners tnt.

HRESULT DVB_Get_Device(void){
DVB_Tuner_Max=0;
HRESULT hr;
BOOL fFoundFilter = FALSE;
SmartPtr pIMoniker;
SmartPtr pIEnumMoniker;

if (!pCreateDevEnum) {
hr=CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,IID_ICreateDevEnum, (PVOID *)&pCreateDevEnum);

if (FAILED(hr)) {
printf("Cannot CoCreate ICreateDevEnum");
return hr;
}
}

// obtain the enumerator
hr = pCreateDevEnum->CreateClassEnumerator(KSCATEGORY_BDA_RECEIVER_COMPONENT, &pIEnumMoniker, 0);
// the call can return S_FALSE if no moniker exists, so explicitly check S_OK
if (FAILED(hr)) {
TOOL_Debug("DVB_Get_Device","Cannot CreateClassEnumerator");
return hr;
}
if (S_OK != hr) { // Class not found
printf("Class not found, CreateClassEnumerator returned S_FALSE");
return E_UNEXPECTED;
}

// next filter
while (pIEnumMoniker->Next(1, &pIMoniker, 0) == S_OK)
{
// obtain filter's friendly name
SmartPtr pBag;
hr = pIMoniker->BindToStorage(NULL,NULL,IID_IPropertyBag,reinterpret_cast(&pBag));
if (FAILED(hr)) {
TOOL_Debug("DVB_Get_Device","Cannot BindToStorage");
return hr;
}

VARIANT varBSTR;
varBSTR.vt = VT_BSTR;
hr = pBag->Read(L"FriendlyName", &varBSTR, NULL);
TUNER[DVB_Tuner_Max].Name=varBSTR.bstrVal;
BSTRtoASC(TUNER[DVB_Tuner_Max].Name,TUNER[DVB_Tuner_Max].Char_Name);
printf("Ajout du Device_Tuner [%d] : %s",DVB_Tuner_Max,TUNER[DVB_Tuner_Max].Char_Name);

if (FAILED(hr)) {
printf("IPropertyBag->Read method failed");
pIMoniker = NULL;
continue;
}
DVB_Tuner_Max++;

return hr;
}
}

Voilà, alors nous avons récupéré le nom du tuner ( dans mon cas, ça me donne : « DiBcom BDA Digital Capture (Dev1 Path0) »). Cela sera utile pour connecter les filtres entre eux.

Après il est nécessaire un espace de tuning.

HRESULT DVB_Create_Tuning_Space(long DVB_Selected){

HRESULT hr;

hr = CoCreateInstance(CLSID_DVBTuningSpace,NULL, CLSCTX_INPROC_SERVER,IID_IDVBTuningSpace2,(void **) &TUNER[DVB_Selected].TuningSpace);

hr = TUNER[DVB_Selected].TuningSpace->put_SystemType(DVB_Terrestrial);

hr = TUNER[DVB_Selected].TuningSpace->put__NetworkType(CLSID_DVBTNetworkProvider);

return hr;
}

Puis il faut envoyer la requête de chaine :

DVB_Tuning_Request(0,546167,8,-1,-1,-1);

Le chiffre 546167 correspond à la fréquence d’un multiplex.

HRESULT DVB_Tuning_Request(long DVB_Selected,long Mhz, long BW, long ONID, long SID, long TSID){
HRESULT hr;
BSTR TuningName;
TuningName = L"DVB-T";

SmartPtr pDVBTLocator;

hr = CoCreateInstance(CLSID_DVBTLocator,NULL, CLSCTX_INPROC_SERVER,IID_IDVBTLocator,(void **)&TUNER[DVB_Selected].pDVBTLocator);

hr = TUNER[DVB_Selected].pDVBTLocator->put_CarrierFrequency(Mhz);
hr = TUNER[DVB_Selected].pDVBTLocator->put_Bandwidth(BW);
hr = TUNER[DVB_Selected].TuningSpace->put_DefaultLocator(TUNER[DVB_Selected].pDVBTLocator);
TOOL_Debug("DVB_Tuning_Request"," Frequence : %d - BandWith : %d - ONID : %d - SID : %d - TSID : %d",Mhz,BW,ONID,SID,TSID);
hr = TUNER[DVB_Selected].TuningSpace->put_UniqueName(TuningName);
hr = TUNER[DVB_Selected].TuningSpace->put_FriendlyName(TuningName);
hr = TUNER[DVB_Selected].TuningSpace->put_FrequencyMapping(L"");

SmartPtr pTuningSpaceContainer;
hr = CoCreateInstance(CLSID_SystemTuningSpaces,NULL, CLSCTX_INPROC_SERVER,IID_ITuningSpaceContainer,(void **)&pTuningSpaceContainer);

VARIANT tiIndex;
hr = pTuningSpaceContainer->Add(TUNER[DVB_Selected].TuningSpace,&tiIndex);

if (!SUCCEEDED(hr)) {
// Get the enumerator for the collection.
SmartPtr pTuningSpaceEnum;
hr = pTuningSpaceContainer->get_EnumTuningSpaces(&pTuningSpaceEnum);
if (SUCCEEDED(hr)) {
// Loop through the collection.
SmartPtr pTuningSpace;
//ITuningSpace *pTuningSpace;
tiIndex.intVal=0;
while (S_OK == pTuningSpaceEnum->Next(1, &pTuningSpace, NULL)) {
BSTR Name;

hr = pTuningSpace->get_UniqueName(&Name);
if (SUCCEEDED(hr)) {
if (wcscmp(Name, TuningName) == 0) {
hr = pTuningSpaceContainer->put_Item(tiIndex,TUNER[DVB_Selected].TuningSpace);
}
SysFreeString(Name);
}

tiIndex.intVal++;
//pTuningSpace->Release();
pTuningSpace.Release();
}
}
}

hr = TUNER[DVB_Selected].TuningSpace->CreateTuneRequest(&TUNER[DVB_Selected].pTuneRequest);

TUNER[DVB_Selected].pTuneRequest.QueryInterface(&TUNER[DVB_Selected].pDVBTuneRequest);

if(TUNER[DVB_Selected].pDVBTuneRequest) {

hr = TUNER[DVB_Selected].pDVBTuneRequest->put_SID(SID);//1538
hr = TUNER[DVB_Selected].pDVBTuneRequest->put_TSID(TSID);
hr = TUNER[DVB_Selected].pDVBTuneRequest->put_ONID(ONID);//8442
}

GUID CLSIDNetworkType;
hr = TUNER[DVB_Selected].TuningSpace->get__NetworkType(&CLSIDNetworkType);

hr = CoCreateInstance(CLSIDNetworkType, NULL, CLSCTX_INPROC_SERVER,IID_IBaseFilter, (void **) &TUNER[DVB_Selected].m_pNetworkProvider);
hr = g_pGB->AddFilter(TUNER[DVB_Selected].m_pNetworkProvider,L"Network Provider");

TUNER[DVB_Selected].m_pNetworkProvider.QueryInterface(&TUNER[DVB_Selected].pTuner);

// Query for ITuner.

if (TUNER[DVB_Selected].pTuner) {
// Submit the tune request to the network provider.
hr = TUNER[DVB_Selected].pTuner->put_TuneRequest(TUNER[DVB_Selected].pTuneRequest);
}

return hr;
}

Après nous avons la délicate tâche de lier les différents filtres dans un ordre logique afin de les connecter ensemble. Un petit exemple de ce que cela doit donner :

A l’aide de cette fonction, nous ajouterons au fur et à mesure les filtres

HRESULT TUNER_Load_Filter(REFCLSID clsid,IBaseFilter** ppFilter,IBaseFilter* pConnectFilter,BOOL fIsUpstream,BSTR Name){
HRESULT hr = S_OK;
BOOL fFoundFilter = FALSE;
SmartPtr pIMoniker;
SmartPtr pIEnumMoniker;
char *Temp;
TOOL_Debug("TUNER_Load_Filter","Debut de la fonction [%s]",TOOL_Convert_to_char(Name));

if (!pCreateDevEnum) {
hr=CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,IID_ICreateDevEnum, (PVOID *)&pCreateDevEnum);

if (FAILED(hr)) {
TOOL_Debug("TUNER_Load_Filter","Cannot CoCreate ICreateDevEnum");
return hr;
}
}

// obtain the enumerator
hr = pCreateDevEnum->CreateClassEnumerator(clsid, &pIEnumMoniker, 0);
// the call can return S_FALSE if no moniker exists, so explicitly check S_OK
if (FAILED(hr)) {
TOOL_Debug("TUNER_Load_Filter","Cannot CreateClassEnumerator");
return hr;
}
if (S_OK != hr) { // Class not found
TOOL_Debug("TUNER_Load_Filter","Class not found, CreateClassEnumerator returned S_FALSE");
return E_UNEXPECTED;
}

// next filter
while (pIEnumMoniker->Next(1, &pIMoniker, 0) == S_OK) {
// obtain filter's friendly name
SmartPtr pBag;

hr = pIMoniker->BindToStorage(NULL,NULL,IID_IPropertyBag,reinterpret_cast(&pBag));
if (FAILED(hr)) {
TOOL_Debug("TUNER_Load_Filter","Cannot BindToStorage");
return hr;
}

VARIANT varBSTR;
varBSTR.vt = VT_BSTR;
hr = pBag->Read(L"FriendlyName", &varBSTR, NULL);
if (FAILED(hr)) {
TOOL_Debug("TUNER_Load_Filter","IPropertyBag->Read method failed");
pIMoniker = NULL;
continue;
}

pBag = NULL;
if (wcsncmp(varBSTR.bstrVal, Name,sizeof(Name)) == 0) {
//BSTRtoASC(Name,Temp);
TOOL_Debug("TUNER_Load_Filter","Correspondance decouverte avec [%s]",TOOL_Convert_to_char(Name));
// bind the filter
SmartPtr pFilter;

hr = pIMoniker->BindToObject(NULL,NULL,IID_IBaseFilter,reinterpret_cast(&pFilter));

if (FAILED(hr)) {
pIMoniker = NULL;
pFilter = NULL;
continue;
}

hr = g_pGB->AddFilter (pFilter, varBSTR.bstrVal);
if (FAILED(hr)) {
TOOL_Debug("TUNER_Load_Filter","Cannot add filter [%s]",TOOL_Convert_to_char(Name));
return hr;
}

//MessageBox (NULL, _T(""), _T(""), MB_OK);
// test connections
// to upstream filter
if(pConnectFilter==NULL){
fFoundFilter = TRUE;
pFilter.QueryInterface(ppFilter);
return S_OK;
}
if (pConnectFilter) {
if (fIsUpstream) {
hr = DVB_ConnectFilters(pConnectFilter, pFilter);
}
else {
hr = DVB_ConnectFilters(pFilter, pConnectFilter);
}

if (SUCCEEDED(hr)) {
//that's the filter we want
TOOL_Debug("TUNER_Load_Filter","Filters connected [%s]",TOOL_Convert_to_char(Name));
fFoundFilter = TRUE;
pFilter.QueryInterface(ppFilter);
break;
}
else {
fFoundFilter = FALSE;
// that wasn't the the filter we wanted
// so unload and try the next one
hr = g_pGB->RemoveFilter(pFilter);
if (FAILED(hr)) {
TOOL_Debug("TUNER_Load_Filter","Filters not connected");
return hr;
}
}
}
else {
fFoundFilter = TRUE;
pFilter.QueryInterface(ppFilter);
break;
}

pIMoniker = NULL;
pFilter = NULL;
}
}// while

pIEnumMoniker = NULL;

return S_OK;
}

HRESULT DVB_ConnectFilters(IBaseFilter* pFilterUpstream,IBaseFilter* pFilterDownstream){
HRESULT hr = E_FAIL;

SmartPtr pIPinUpstream;

PIN_INFO PinInfoUpstream;
PIN_INFO PinInfoDownstream;

TOOL_Debug("DVB_ConnectFilters","ConnectFilters");

// grab upstream filter's enumerator
SmartPtr pIEnumPinsUpstream;
hr = pFilterUpstream->EnumPins(&pIEnumPinsUpstream);

if(FAILED(hr))
{
TOOL_Debug("DVB_ConnectFilters","Enumerate Upstream Filter's Pins");
return hr;
}

// iterate through upstream filter's pins
while (pIEnumPinsUpstream->Next (1, &pIPinUpstream, 0) == S_OK)
{
hr = pIPinUpstream->QueryPinInfo (&PinInfoUpstream);
if(FAILED(hr))
{
TOOL_Debug("DVB_ConnectFilters","Cannot Obtain Upstream Filter's PIN_INFO");
return hr;
}

SmartPtr pPinDown;
pIPinUpstream->ConnectedTo (&pPinDown);

// bail if pins are connected
// otherwise check direction and connect
if ((PINDIR_OUTPUT == PinInfoUpstream.dir) && (pPinDown == NULL))
{
// grab downstream filter's enumerator
SmartPtr pIEnumPinsDownstream;
hr = pFilterDownstream->EnumPins (&pIEnumPinsDownstream);
if(FAILED(hr))
{
TOOL_Debug("DVB_ConnectFilters","Cannot enumerate pins on downstream filter!");
return hr;
}

// iterate through downstream filter's pins
SmartPtr pIPinDownstream;
while (pIEnumPinsDownstream->Next (1, &pIPinDownstream, 0) == S_OK)
{
// make sure it is an input pin
hr = pIPinDownstream->QueryPinInfo(&PinInfoDownstream);
if(SUCCEEDED(hr))
{
SmartPtr pPinUp;

// Determine if the pin is already connected. Note that
// VFW_E_NOT_CONNECTED is expected if the pin isn't yet connected.
hr = pIPinDownstream->ConnectedTo (&pPinUp);
if(FAILED(hr) && hr != VFW_E_NOT_CONNECTED)
{
TOOL_Debug("DVB_ConnectFilters","Failed in pIPinDownstream->ConnectedTo()!");
continue;
}

if ((PINDIR_INPUT == PinInfoDownstream.dir) && (pPinUp == NULL))
{

if (SUCCEEDED (g_pGB->Connect(pIPinUpstream, pIPinDownstream)))
{
PinInfoDownstream.pFilter->Release();
PinInfoUpstream.pFilter->Release();
return S_OK;
}
}
}

PinInfoDownstream.pFilter->Release();
pIPinDownstream = NULL;

} // while next downstream filter pin

//We are now back into the upstream pin loop
} // if output pin

pIPinUpstream = NULL;
PinInfoUpstream.pFilter->Release();

} // while next upstream filter pin

return E_FAIL;
}

Nous lierons alors, le m_pNetworkProvider au m_pTunerDemodDevice, puis le m_pBDACaptureDevice au m_pTunerDemodDevice :

hr=TUNER_Load_Filter(KSCATEGORY_BDA_NETWORK_TUNER, &TUNER[0].m_pTunerDemodDevice,TUNER[0].m_pNetworkProvider, TRUE,TUNER[0].Name);

hr=TUNER_Load_Filter(KSCATEGORY_BDA_RECEIVER_COMPONENT, &TUNER[0].m_pBDACaptureDevice,TUNER[0].m_pTunerDemodDevice, TRUE,TUNER[0].Name);

Une fois cela effectué il faut charger le demux ( le démultiplexeur)

HRESULT hr = S_OK;
hr = CoCreateInstance(CLSID_MPEG2Demultiplexer,NULL, CLSCTX_INPROC_SERVER,IID_IBaseFilter,(void **) &TUNER[TUNER_Number].m_pDemux);

if (FAILED(hr)) {
TOOL_Debug("Could not CoCreateInstance CLSID_MPEG2Demultiplexer\n","");
return hr;
}

hr = g_pGB->AddFilter(TUNER[TUNER_Number].m_pDemux, L"Demux");
if (FAILED(hr)) {
TOOL_Debug("Unable to add demux filter to graph\n","");
return hr;
}

Puis il faut connecter directement les filtres du m_pDemux au m_pBDACaptureDevice :

hr = DVB_ConnectFilters(TUNER[0].m_pBDACaptureDevice, TUNER[0].m_pDemux);

Puis nous connectons le reste des filtres :

hr=TUNER_Load_Filter(KSCATEGORY_BDA_TRANSPORT_INFORMATION,&TUNER[0].m_pBDATIF,TUNER[0].m_pDemux, TRUE,L"BDA MPEG2 Transport Information Filter");

hr=TUNER_Load_Filter(KSCATEGORY_BDA_TRANSPORT_INFORMATION,&TUNER[0].m_pBDASecTab,NULL, TRUE,L"MPEG-2 Sections and Tables");

Puis nous y mappons la section et tables du MPEG2 et ce pour obtenir la PAT, SDT etc… Encore une chose qui n’est pas spécialement documentée sur le net… A vous de chercher un peu, car çà à l’air d’être assez simple mais très fastidieux à faire….

HRESULT hr;
SmartPtr PinOut;
SmartPtr pDemux;
hr = TUNER[TUNER_Selected].m_pDemux->QueryInterface(IID_IMpeg2Demultiplexer, (void**)&pDemux);
if (SUCCEEDED(hr)){
// Create a new output pin.
AM_MEDIA_TYPE mt;
ZeroMemory(&mt, sizeof(AM_MEDIA_TYPE));
GetPSIMedia(&mt);

// Create the pin.
IPin *pPsiPin;
hr = pDemux->CreateOutputPin(&mt, L"PSI", &pPsiPin);
if (SUCCEEDED(hr))
{
IMPEG2PIDMap *pPid = NULL;
hr = pPsiPin->QueryInterface(IID_IMPEG2PIDMap, (void**)&pPid);

// Map to PID 0.
ULONG Pid = 0x00;
hr = pPid->MapPID(1, &Pid, MEDIA_MPEG2_PSI);

//NIT
Pid = 0x10;
hr = pPid->MapPID(1, &Pid, MEDIA_MPEG2_PSI);

//SDT;
Pid = 0x11;
hr = pPid->MapPID(1, &Pid, MEDIA_MPEG2_PSI);

PinOut = GetPin(TUNER[TUNER_Selected].m_pBDASecTab,PINDIR_INPUT);
hr= g_pGB->Connect(PinOut,pPsiPin);

}
}
return hr;

Et puis pour lier le pin vidéo du demux au filtre de rendu…

HRESULT hr;
SmartPtr PinOut;
SmartPtr pDemux;
hr = TUNER[TUNER_Selected].m_pDemux->QueryInterface(IID_IMpeg2Demultiplexer, (void**)&pDemux);
if (SUCCEEDED(hr)){
// Create a new output pin.
AM_MEDIA_TYPE mt;
ZeroMemory(&mt, sizeof(AM_MEDIA_TYPE));
GetVideoMedia(&mt);

// Create the pin.
IPin *VideoPin;
hr = pDemux->CreateOutputPin(&mt, L"Video", &VideoPin);
if (SUCCEEDED(hr))
{
IMPEG2PIDMap *pPid = NULL;
hr = VideoPin->QueryInterface(IID_IMPEG2PIDMap, (void**)&pPid);

ULONG Pid = 120; ( Pid video de la chaine )

long Filter=2;
hr = pPid->MapPID(1, &Pid, MEDIA_ELEMENTARY_STREAM);
SmartPtr Colour_In;
SmartPtr Colour_Out;
Colour_In = GetPin(Colour_Converter,PINDIR_INPUT);
hr= g_pGB->Connect(VideoPin,Colour_In);

Colour_Out = GetPin(Colour_Converter,PINDIR_OUTPUT);

hr= g_pGB->Render(Colour_Out);

}
}
return hr;

Et le tour est joué!!!

Vous parviendrez à obtenir les pid audio et video en utilisant un logiciel du style pouchtin tv cela vous donnera un truc du style :

Voili voilou, j’espère que je vous aurai aidé dans vos recherche et que finalement vous arrêterez de maudire ce @*¤# de msdn qui ne dit rien du tout….

Et vous n’oublierez pas de lancer le graph aussi!!!!

Si vous avez des questions, des soucis, des remarques, je suis à votre écoute!!!!!!!!!!

Obtenir une preview d’une video, un thumbnail quoi!!

Sotoaleono — Thu, 11 Feb 2010 22:19:13 +0000

Simple :

long Get_Thumbnail(long Object)
{
Debug("Get_Thumbnail","Début de la fonction Get_Thumbnail");

HRESULT hr;

CoInitialize (NULL);

SmartPtr < IMediaDet > pDet;

hr = CoCreateInstance( CLSID_MediaDet, NULL, CLSCTX_INPROC_SERVER, IID_IMediaDet, (void**) &pDet );

if (FAILED(hr))return FALSE;

BSTR Origin_File = SysAllocString(Convert_to_LPC(Odyssea_Media[Object].FileName));

hr = pDet->put_Filename(Origin_File);

if (FAILED(hr)) return FALSE;

double StreamLength;

pDet->get_StreamLength(&StreamLength);

long lStreams;

hr = pDet->get_OutputStreams(&lStreams);

if (FAILED(hr))return FALSE;

bool bFound = false;

for (int i=0; i {

GUID major_type;

hr = pDet->put_CurrentStream(i);

if (SUCCEEDED(hr))

hr = pDet->get_StreamType(&major_type);

if (FAILED(hr))
break;

if (major_type == MEDIATYPE_Video)
{

bFound = true;

break;
}

}

if (!bFound)
return VFW_E_INVALIDMEDIATYPE;

long width = 0, height = 0;

AM_MEDIA_TYPE mt;

hr = pDet->get_StreamMediaType(&mt);

if (SUCCEEDED(hr))

{
if ((mt.formattype == FORMAT_VideoInfo) &&
(mt.cbFormat >= sizeof(VIDEOINFOHEADER)))
{

VIDEOINFOHEADER *pVih = (VIDEOINFOHEADER*)(mt.pbFormat);

width = pVih->bmiHeader.biWidth;

height = pVih->bmiHeader.biHeight;

}

else

hr = VFW_E_INVALIDMEDIATYPE;
}

if (FAILED(hr))return FALSE;

BSTR Texture_File = SysAllocString(Convert_to_LPC(Odyssea_Media[Object].TexF));

hr = pDet->WriteBitmapBits((double)(StreamLength/2), width, height, Texture_File);

hr=D3DXCreateTextureFromFileEx(g_pd3dDevice,Convert_to_LPC(Odyssea_Media[Object].TexF),D3DX_DEFAULT_NONPOW2,D3DX_DEFAULT_NONPOW2, 1, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL,&Temporary_Texture);

D3DXSaveTextureToFileA(Odyssea_Media[Object].TexF, D3DXIFF_JPG,Temporary_Texture,NULL);

if (FAILED(hr)) return FALSE;
Debug("Get_Thumbnail","Fin de la fonction Get_Thumbnail");
return S_OK;
}

Tout simplement…

Chose promise chose due

Sotoaleono — Fri, 29 Jan 2010 23:06:41 +0000

Voici les extraits de codes réalisés afin de permettre l’écriture(ajout et modification) de balise à la fin des fichiers :

////////////////////
////////////////////
////////////////////
//TAG V4
////////////////////
////////////////////
////////////////////
long Get_TAGV4_Size(long Object){
//Obtient la taille normale du fichier donc logiquement la taille du TAG
long TAGSize=0;

FILE *FileSourceGTS;

if(Odyssea_Media[Object].Type==OSERIE || Odyssea_Media[Object].Type==OMOVIE || Odyssea_Media[Object].Type==OVIDEO)FileSourceGTS=fopen(Odyssea_Media[Object].TexF,"rb");
//Verification de la présence du obligatoire en fin de fichier
if(FileSourceGTS){
char TAGODC[10];

fseek(FileSourceGTS,-10L,SEEK_END);

fread(&TAGODC,sizeof(char),6,FileSourceGTS);

if(strncmp(TAGODC,"",6)==0){

fread(&TAGSize,sizeof(long),1,FileSourceGTS);
//Car en fait la taille est marquée sous un long, en fin du fichier, précédé par la chaine
}

fclose(FileSourceGTS);

return TAGSize;
}
else return -1;

}

void Delete_TAGV4(long Object)
{

long TAGSize=Get_TAGV4_Size(Object);

FILE *FileTAG;

if(Odyssea_Media[Object].Type==OSERIE || Odyssea_Media[Object].Type==OMOVIE || Odyssea_Media[Object].Type==OVIDEO)FileTAG=fopen(Odyssea_Media[Object].TexF,"rb");

char *Temp = (char*)malloc(TAGSize);

fseek(FileTAG,0,SEEK_SET);

fread(Temp,sizeof(char),TAGSize,FileTAG);

fclose(FileTAG);

if(Odyssea_Media[Object].Type==OSERIE || Odyssea_Media[Object].Type==OMOVIE || Odyssea_Media[Object].Type==OVIDEO)FileTAG=fopen(Odyssea_Media[Object].TexF,"wb");
fwrite(Temp,sizeof(char),TAGSize,FileTAG);

fclose(FileTAG);

}

void SetTagV4(long Object,char *Balise, char *Information)
{
Debug("SetTAGV4");

long TAGSize=Get_TAGV4_Size(Object);

char StrlenTAGSize[10];

sprintf(StrlenTAGSize,"%d",TAGSize);

FILE *FileSource;
//Présence du
if(TAGSize>0){

if(Odyssea_Media[Object].Type==OSERIE || Odyssea_Media[Object].Type==OMOVIE || Odyssea_Media[Object].Type==OVIDEO)FileSource=fopen(Odyssea_Media[Object].TexF,"rb");

fpos_t posend = 0;

fseek(FileSource,0,SEEK_END);

fgetpos(FileSource, &posend);

long SizeTampon=(posend-TAGSize);

char *TempTampon = (char*)malloc(SizeTampon-10);

fseek(FileSource,TAGSize,SEEK_SET);

fread(TempTampon,sizeof(char),SizeTampon-10,FileSource);

TempTampon[SizeTampon-10]=NULL;

fclose(FileSource);
//On efface

Delete_TAGV4(Object);

char *FinalTampon = (char*)malloc(SizeTampon+strlen(Information));

long PositionBaliseHead=0;

long PositionBaliseQueue=0;

for(long i=0;i
char *TempBalise = (char*)malloc(strlen(Balise)+2);

char *TempBaliseRef = (char*)malloc(strlen(Balise)+2);

if(PositionBaliseHead==0){

sprintf(TempBaliseRef,"<%s>",Balise);

for(long j=0;j
if(strncmp(TempBalise,TempBaliseRef,strlen(TempBaliseRef))==0)PositionBaliseHead=i+strlen(Balise)+2;

}

if(PositionBaliseHead!=0 && PositionBaliseQueue==0){

sprintf(TempBaliseRef,"",Balise);

for(long j=0;j
if(strncmp(TempBalise,TempBaliseRef,strlen(TempBaliseRef))==0)PositionBaliseQueue=i;

}

}

long Count=0;

if(PositionBaliseHead!=0 && PositionBaliseQueue!=0){

for(long i=0;i
if(iPositionBaliseQueue-1)FinalTampon[Count]=TempTampon[i],Count++;

else {

for(long j=0;j
Count+=strlen(Information);

i=PositionBaliseQueue-1;

}

}

FinalTampon[Count]=NULL;

}

else{

char *Tampon = (char*)malloc(strlen(Information)+5+(strlen(Balise)*2));

sprintf(Tampon,"<%s>%s",Balise,Information,Balise);

strcpy(FinalTampon,TempTampon);

strcat(FinalTampon,Tampon);

Count=strlen(FinalTampon);

}

char ODCInformation[256];

sprintf(ODCInformation,"");

if(Odyssea_Media[Object].Type==OSERIE || Odyssea_Media[Object].Type==OMOVIE || Odyssea_Media[Object].Type==OVIDEO)FileSource=fopen(Odyssea_Media[Object].TexF,"ab");

posend = 0;

fseek(FileSource,0,SEEK_END);

fgetpos(FileSource, &posend);

long ComputeTag=posend;

fwrite(FinalTampon,sizeof(char),strlen(FinalTampon),FileSource);

fwrite(ODCInformation,sizeof(char),strlen(ODCInformation),FileSource);

fwrite(&ComputeTag,sizeof(long),1,FileSource);

}

else{

if(Odyssea_Media[Object].Type==OSERIE || Odyssea_Media[Object].Type==OMOVIE || Odyssea_Media[Object].Type==OVIDEO)FileSource=fopen(Odyssea_Media[Object].TexF,"ab");

long ComputeTag=0;

char *Tampon = (char*)malloc(strlen(Information)+5+(strlen(Balise)*2));

sprintf(Tampon,"<%s>%s",Balise,Information,Balise);

char ODCInformation[256];

sprintf(ODCInformation,"");

fpos_t posend = 0;

fseek(FileSource,0,SEEK_END);

fgetpos(FileSource, &posend);

ComputeTag=posend;

fwrite(Tampon,sizeof(char),strlen(Tampon),FileSource);

fwrite(ODCInformation,sizeof(char),strlen(ODCInformation),FileSource);

fwrite(&ComputeTag,sizeof(long),1,FileSource);

}

fclose(FileSource);

}

long GetTagV4(long Object,char *Balise, char *Dest){

long TAGSize=Get_TAGV4_Size(Object);

char StrlenTAGSize[10];

sprintf(StrlenTAGSize,"%d",TAGSize);

FILE *FileSource;

if(TAGSize>0){

if(Odyssea_Media[Object].Type==OSERIE || Odyssea_Media[Object].Type==OMOVIE || Odyssea_Media[Object].Type==OVIDEO)FileSource=fopen(Odyssea_Media[Object].TexF,"rb");

fpos_t posend = 0;

fseek(FileSource,0,SEEK_END);

fgetpos(FileSource, &posend);

long SizeTampon=(posend-TAGSize);

char *TempTampon = (char*)malloc(SizeTampon-10);

fseek(FileSource,TAGSize,SEEK_SET);

fread(TempTampon,sizeof(char),SizeTampon-10,FileSource);

TempTampon[SizeTampon-10]=NULL;

fclose(FileSource);

long PositionBaliseHead=0;

long PositionBaliseQueue=0;

for(long i=0;i
char *TempBalise = (char*)malloc(strlen(Balise)+2);

char *TempBaliseRef = (char*)malloc(strlen(Balise)+2);

if(PositionBaliseHead==0){

sprintf(TempBaliseRef,"<%s>",Balise);

for(long j=0;j
if(strncmp(TempBalise,TempBaliseRef,strlen(TempBaliseRef))==0)PositionBaliseHead=i+strlen(Balise)+2;
}

if(PositionBaliseHead!=0 && PositionBaliseQueue==0){

sprintf(TempBaliseRef,"",Balise);

for(long j=0;j
if(strncmp(TempBalise,TempBaliseRef,strlen(TempBaliseRef))==0)PositionBaliseQueue=i;
}
}

char *TDest=(char*)malloc(PositionBaliseQueue-PositionBaliseHead);

for(long i=PositionBaliseHead;i
TDest[PositionBaliseQueue-PositionBaliseHead]=NULL;

strcpy(Dest,TDest);

return TRUE;

}

return FALSE;
}

Deux jours de travail….Trois fois rien!!!!

Premier billet : l’indexation

Sotoaleono — Fri, 29 Jan 2010 10:37:37 +0000

Bonjour!

Premier billet de réflexion, l’indexation des fichiers multimédia.

Passons outre la recherche des fichiers (dont le code sera exposé ultérieurement). Comment effectuer une indexation rapide dont la gestion serait simple?

Car l’indexation se doit d’être rapide(moins de quelques minutes au démarrage du logiciel), et actualisée. Il s’agit de la pierre angulaire de ce logiciel, ne pas avoir à renommer tous les fichiers à chaque fois, et surtout prendre en compte chacune des modifications(synopsis, paroles etc…)

Une bonne indexation des fichiers permet alors une bonne gestion de ces fichiers et surtout rendant utile la recherche de données sur les médias(acteur, synopsis, paroles, titre, saison….)

Voici les essais et les réflexions liés à cet indexation :

Première tentative : indexation dans un fichier unique

Le logiciel scanne une fois la totalité du répertoire(comme windows media player) puis les modifications effectuées sont répercutées dans le fichier de données.

Bon principe de départ, car l’indexation s’effectue une seule fois, mais à l’usage, après plusieurs suppressions & modifications, la gestion de cette base devient vraiment très compliquée, et difficilement applicable à une collection entière de 4000 fichiers….Passons.

Deuxième tentative : application de tags « rigides » dans les fichiers

On y applique un tag unique du style : Fichier de texture – Synopsis – Renseignement 1 – Renseignement 2 – Renseignement 3. Hyper pratique au début, car au début, tout est formaté toujours au même format, (150 octets en fin de fichier) contenant les informations de base. La récupération s’effectue alors très rapidement.

Super hyper pratique….quand on a que trois types d’information à récolter, par contre lorsqu’une foule d’informations diverses doit être recueillie…Il devient difficile de tout gérer, et de créer une fonction par type de fichier (lecture, écriture, effacement des tags, et ce pour chacun des types de fichier (serie, film, mp3, chaine tv)) Bref une vraie galère en fin de compte.

Troisième tentative : application de balises à la fin des fichiers

Meilleure façon trouvée à ce jour : des balises du type (SYNOPSIS) xxxx(/SYNOPSIS) ou (ARTISTE)xxx(/ARTISTE), ces dernières permettent de recueillir les informations désirées sur n’importe quel fichier, à l’aide de fonctions uniques pour tout les types de fichiers. Par exemple GetTAG(« c:/essai.txt », »SYNOPSIS »,Temporary), renvoyant automatiquement le contenu de la balise synopsis du fichier.

Cela permet d’obtenir rapidement les informations demandées, sans avoir à les récupérer sur internet à chaque fois. Ces fonctions sont en cours d’élaboration actuellement.

Le prochain billet de ce blog y sera consacré.

Kenavo!!!

Passage dans une nouvelle ère!!!!

Sotoaleono — Wed, 27 Jan 2010 21:28:39 +0000

Bonjour,

Dernièrement, j’ai rempli mon sac du courage qu’il me restait et me suis proposé à demander un hébergement?

Examen de ma candidature faite, et réussi, je me retrouve dans cette belle fenêtre ouverte sur le web qu’est DEVELOPPEZ.COM.

Tout n’est pas encore en place, et j’avoue, je tâtonne encore un peu dans cet univers (redmine et autre). Mais il faudra bien commencer à prendre ses marques.

J’espère juste avoir assez de temps(24 heures – (boulot + famille + sommeil)) me laisse finalement quelques heures pour mener à bien le projet et ces outils.

Allez…KENAVO