Recherche avancée
Médias (91)
-
MediaSPIP Simple : futur thème graphique par défaut ?
26 septembre 2013, par
Mis à jour : Octobre 2013
Langue : français
Type : Video
-
avec chosen
13 septembre 2013, par
Mis à jour : Septembre 2013
Langue : français
Type : Image
-
sans chosen
13 septembre 2013, par
Mis à jour : Septembre 2013
Langue : français
Type : Image
-
config chosen
13 septembre 2013, par
Mis à jour : Septembre 2013
Langue : français
Type : Image
-
SPIP - plugins - embed code - Exemple
2 septembre 2013, par
Mis à jour : Septembre 2013
Langue : français
Type : Image
-
GetID3 - Bloc informations de fichiers
9 avril 2013, par
Mis à jour : Mai 2013
Langue : français
Type : Image
Autres articles (97)
-
MediaSPIP 0.1 Beta version
25 avril 2011, parMediaSPIP 0.1 beta is the first version of MediaSPIP proclaimed as "usable".
The zip file provided here only contains the sources of MediaSPIP in its standalone version.
To get a working installation, you must manually install all-software dependencies on the server.
If you want to use this archive for an installation in "farm mode", you will also need to proceed to other manual (...) -
ANNEXE : Les plugins utilisés spécifiquement pour la ferme
5 mars 2010, parLe site central/maître de la ferme a besoin d’utiliser plusieurs plugins supplémentaires vis à vis des canaux pour son bon fonctionnement. le plugin Gestion de la mutualisation ; le plugin inscription3 pour gérer les inscriptions et les demandes de création d’instance de mutualisation dès l’inscription des utilisateurs ; le plugin verifier qui fournit une API de vérification des champs (utilisé par inscription3) ; le plugin champs extras v2 nécessité par inscription3 (...)
-
HTML5 audio and video support
13 avril 2011, parMediaSPIP uses HTML5 video and audio tags to play multimedia files, taking advantage of the latest W3C innovations supported by modern browsers.
The MediaSPIP player used has been created specifically for MediaSPIP and can be easily adapted to fit in with a specific theme.
For older browsers the Flowplayer flash fallback is used.
MediaSPIP allows for media playback on major mobile platforms with the above (...)
Sur d’autres sites (8268)
-
FFmpeg decoded video is garbled mess with no audio. How can I fix it ? [closed]
14 septembre 2023, par Señor TontoI am trying to use FFmpeg 6.0 (which seems to have a terrible lack of documentation) to decode a .mp4/.mov file & play its audio. I am testing this on a .mov file (I tried also with a .mp4, same result) of an old animation I found. This turns out as a garbled mess that looks like an old film movie with no audio. Now, I used some old tutorials & managed to with much trial get the code I have now, which is of course half-working. I am using SDL to output the video. I'm not sure if it's a problem on the SDL end or the FFmpeg end at the moment (but I'm sure the video is a mix of the two & the audio because of SDL) I would appreciate some help as there's very little documentation I can find that isn't outdated & the deprecated list on FFmpeg hardly helps when I need to fix API-related changes. Here's my code


LRESULT CALLBACK WindowProcessMessages(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
 OPENFILENAME ofn;

 wchar_t g_filePath[MAX_PATH] = L"";
 char szFile[MAX_PATH] = "";
 wchar_t wFile[MAX_PATH] = L"";
 char data[MAX_PATH];
 DWORD bytesRead = 0;
 BOOL bSuccess = FALSE;
 static int iVscrollPos, cyClient, cyChar, cxChar, cxCaps, iMaxVerticalScroll = 0, iNumLines = 0;
 HDC hdc;
 TEXTMETRIC tm;
 static int tabIndex;
 std::wstring filePath;

 //FFmpeg variables
 static AVFormatContext* format_ctx = nullptr; 
 static AVCodecContext* video_codec_ctx = nullptr;
 static AVCodecContext* audio_codec_ctx = nullptr;
 static AVFrame* video_frame = nullptr;
 static AVFrame* audio_frame = nullptr;
 static AVPacket packet;
 static struct SwsContext* sws_ctx = nullptr;
 static int video_stream_idx = -1;
 static int audio_stream_idx = -1;
 static int video_width = 0;
 static int video_height = 0;
 static HWND hVideoWnd = nullptr;
 static HDC hVideoDC = nullptr;
 static HBITMAP hVideoBitmap = nullptr;

 switch (msg) {
 case WM_CREATE:
 break;
 case WM_SIZE:
 break;
 case WM_NOTIFY:
 //code for handling tab switching & creating all content inside the tabs, currently half-working, perhaps give each tab a show & update win call?
 if (((LPNMHDR)lParam)->code == TCN_SELCHANGE) {
 tabIndex = TabCtrl_GetCurSel(g_hWndTabs);
 if (tabIndex == 0) {
 DestroyWindow(openFileBtn);
 DestroyWindow(saveFileBtn);
 DestroyWindow(emboldenBtn);
 DestroyWindow(italiciseBtn);
 DestroyWindow(hEditControl);
 DestroyWindow(hScrollContainer);

 //this code reloads table data & reconstructs the table whenever the 'table view' tab is opened,
 std::wifstream infile("tabledata.txt");
 while (numRows > 0) {
 numRows--;
 }
 while (true) {
 // Read in data for a row
 wchar_t buf1[MAX_PATH], buf2[MAX_PATH], buf3[MAX_PATH];
 if (!(infile >> buf1 >> buf2 >> buf3)) {
 // End of file reached, break out of loop
 break;
 }

 // Create new row window for this row of data
 HWND hRow = CreateWindowEx(0, L"STATIC", nullptr,
 WS_CHILD | WS_VISIBLE | WS_BORDER,
 startX, startY + numRows * ROW_HEIGHT,
 3 * CELL_WIDTH, ROW_HEIGHT,
 g_hWndMain, nullptr, g_hInstance, nullptr);

 // Create cell edit controls within the new row
 HWND hCell1 = CreateWindowEx(0, L"EDIT", nullptr,
 WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL | WS_BORDER,
 0, 0, CELL_WIDTH, ROW_HEIGHT,
 hRow, nullptr, g_hInstance, nullptr);
 HWND hCell2 = CreateWindowEx(0, L"EDIT", nullptr,
 WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL | WS_BORDER,
 CELL_WIDTH, 0, CELL_WIDTH, ROW_HEIGHT,
 hRow, nullptr, g_hInstance, nullptr);
 HWND hCell3 = CreateWindowEx(0, L"EDIT", nullptr,
 WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL | WS_BORDER,
 2 * CELL_WIDTH, 0, CELL_WIDTH, ROW_HEIGHT,
 hRow, nullptr, g_hInstance, nullptr);

 // Set the text of each cell edit control
 SetWindowTextW(hCell1, buf1);
 SetWindowTextW(hCell2, buf2);
 SetWindowTextW(hCell3, buf3);

 // Update the row window
 InvalidateRect(hRow, nullptr, TRUE);
 UpdateWindow(hRow);

 numRows++;
 }



 tblHeaderOne = CreateWindow(L"STATIC", L"Header 1",
 WS_CHILD | WS_VISIBLE | SS_CENTER | WS_BORDER,
 0, 40, 110, 20,
 g_hWndMain, (HMENU)CELL_1_ID, g_hInstance, NULL);
 InvalidateRect(tblHeaderOne, NULL, TRUE);
 UpdateWindow(tblHeaderOne);


 tblHeaderTwo = CreateWindow(L"STATIC", L"Header 2",
 WS_CHILD | WS_VISIBLE | SS_CENTER | WS_BORDER,
 110, 40, 110, 20,
 g_hWndMain, (HMENU)CELL_2_ID, g_hInstance, NULL);
 InvalidateRect(tblHeaderTwo, NULL, TRUE);
 UpdateWindow(tblHeaderTwo);

 tblHeaderThree = CreateWindow(L"STATIC", L"Header 3",
 WS_CHILD | WS_VISIBLE | SS_CENTER | WS_BORDER,
 220, 40, 110, 20,
 g_hWndMain, (HMENU)CELL_3_ID, g_hInstance, NULL);
 InvalidateRect(tblHeaderThree, NULL, TRUE);
 UpdateWindow(tblHeaderThree);

 // Create button to add new row
 addRowBtn = CreateWindow(L"BUTTON", L"Add Row",
 WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON,
 390, 40, 100, 30,
 g_hWndMain, (HMENU)ADD_ROW_BTN, g_hInstance, NULL);
 InvalidateRect(addRowBtn, NULL, TRUE);
 UpdateWindow(addRowBtn);

 }
 else if (tabIndex == 1) {

 DestroyWindow(hRow);
 DestroyWindow(tableContainer);
 DestroyWindow(tblHeaderOne);
 DestroyWindow(tblHeaderTwo);
 DestroyWindow(tblHeaderThree);
 DestroyWindow(addRowBtn);



 openFileBtn = CreateWindow(L"BUTTON", L"Open File",
 WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON,
 10, 40, 150, 25,
 g_hWndMain, (HMENU)OPEN_FILE_BTN, NULL, NULL);
 InvalidateRect(openFileBtn, NULL, TRUE);
 UpdateWindow(openFileBtn);

 saveFileBtn = CreateWindow(L"BUTTON", L"Save File",
 WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON,
 10, 80, 150, 25,
 g_hWndMain, (HMENU)SAVE_FILE_BTN, nullptr, nullptr);
 InvalidateRect(saveFileBtn, NULL, TRUE);
 UpdateWindow(saveFileBtn);

 hScrollContainer = CreateWindowEx(WS_EX_CLIENTEDGE, L"SCROLLBAR", NULL,
 WS_CHILD | WS_VISIBLE | WS_VSCROLL | SBS_VERT,
 170, 40, 600, 300,
 g_hWndMain, (HMENU)SCROLL_CONTAINER, g_hInstance, NULL);


 hEditControl = CreateWindowEx(WS_EX_CLIENTEDGE, L"EDIT", NULL,
 WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_HSCROLL | ES_MULTILINE | ES_AUTOVSCROLL | ES_AUTOHSCROLL,
 0, 0, 600, 300,
 hScrollContainer, (HMENU)EDIT_CONTROL, g_hInstance, NULL);
 InvalidateRect(hEditControl, NULL, TRUE);
 UpdateWindow(hEditControl);

 SetFocus(hEditControl);

 SetScrollRange(hScrollContainer, SB_VERT, 0, 5, TRUE);
 SetScrollPos(hScrollContainer, SB_VERT, 0, TRUE);

 // Add embolden button
 emboldenBtn = CreateWindow(L"BUTTON", L"Embolden",
 WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
 10, 120, 100, 25,
 g_hWndMain, (HMENU)EMBOLDEN_BTN, nullptr, nullptr);
 InvalidateRect(emboldenBtn, NULL, TRUE);
 UpdateWindow(emboldenBtn);

 // Add italicise button
 italiciseBtn = CreateWindow(L"BUTTON", L"Italicise",
 WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
 10, 150, 100, 25,
 g_hWndMain, (HMENU)ITALICISE_BTN, nullptr, nullptr);
 InvalidateRect(italiciseBtn, NULL, TRUE);
 UpdateWindow(italiciseBtn);
 }
 else if (tabIndex == 2) {
 DestroyWindow(hRow);
 DestroyWindow(tableContainer);
 DestroyWindow(tblHeaderOne);
 DestroyWindow(tblHeaderTwo);
 DestroyWindow(tblHeaderThree);
 DestroyWindow(addRowBtn);
 DestroyWindow(openFileBtn);
 DestroyWindow(saveFileBtn);
 DestroyWindow(emboldenBtn);
 DestroyWindow(italiciseBtn);
 DestroyWindow(hEditControl);
 DestroyWindow(hScrollContainer);

 // Create container for player
 hWMPContainer = CreateWindowEx(WS_EX_CLIENTEDGE, L"STATIC", nullptr,
 WS_CHILD | WS_VISIBLE | SS_CENTER | SS_GRAYFRAME,
 50, 50, 700, 400,
 g_hWndMain, nullptr, g_hInstance, nullptr);

 // Create Open .mp4/.mov button
 OpenMp4Btn = CreateWindow(L"BUTTON", L"Open .mp4/.mov",
 WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON,
 50, 460, 150, 30,
 g_hWndMain, (HMENU)FILEMENU_OPEN_FILE_BTN, nullptr, nullptr);
 InvalidateRect(OpenMp4Btn, nullptr, TRUE);
 UpdateWindow(OpenMp4Btn);


 // Create play/pause button
 hPlayBtn = CreateWindow(L"BUTTON", L"Play",
 WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
 350, 460, 100, 30,
 g_hWndMain, nullptr, g_hInstance, nullptr);
 InvalidateRect(hPlayBtn, nullptr, TRUE);
 UpdateWindow(hPlayBtn);

 }
 }
 return DefWindowProc(hwnd, msg, wParam, lParam);
 break;
 case WM_MOUSEWHEEL:
 //also WIP, will be developed after WM_VSCROLL is established
 break;
 case WM_VSCROLL:
 //to be developed 9516555
 case WM_PAINT:
 break;
 case WM_COMMAND:
 //all commands passed to the window through buttons, menus, forms, etc.
 if (HIWORD(wParam) == BN_CLICKED) {
 if ((HWND)lParam == addRowBtn) {
 const wchar_t* ROW_CLASS_NAME = L"Row Window";
 WNDCLASS rowWc{};
 rowWc.hInstance = g_hInstance;
 rowWc.lpszClassName = ROW_CLASS_NAME;
 rowWc.hCursor = LoadCursor(nullptr, IDC_ARROW);
 rowWc.hbrBackground = (HBRUSH)COLOR_WINDOW;
 rowWc.lpfnWndProc = AddRowDlgProc;
 RegisterClass(&rowWc);

 hWnd = CreateWindow(ROW_CLASS_NAME, L"Row Window",
 WS_OVERLAPPEDWINDOW,
 CW_USEDEFAULT, CW_USEDEFAULT,
 250, 200,
 nullptr, nullptr, nullptr, nullptr);

 // Create text box controls
 hWndCell1Label = CreateWindowW(
 L"STATIC", L"Cell 1:",
 WS_CHILD | WS_VISIBLE | SS_LEFT,
 10, 10, 50, 20,
 hWnd, NULL, g_hInstance, NULL);


 hWndCell1Edit = CreateWindowW(
 L"EDIT", NULL,
 WS_CHILD | WS_VISIBLE | WS_BORDER | ES_LEFT | ES_AUTOHSCROLL,
 65, 10, 100, 20,
 hWnd, NULL, g_hInstance, NULL);


 hWndCell2Label = CreateWindowW(
 L"STATIC", L"Cell 2:",
 WS_CHILD | WS_VISIBLE | SS_LEFT,
 10, 40, 50, 20,
 hWnd, NULL, g_hInstance, NULL);


 hWndCell2Edit = CreateWindowW(
 L"EDIT", NULL,
 WS_CHILD | WS_VISIBLE | WS_BORDER | ES_LEFT | ES_AUTOHSCROLL,
 65, 40, 100, 20,
 hWnd, NULL, g_hInstance, NULL);

 hWndCell3Label = CreateWindowW(
 L"STATIC", L"Cell 3:",
 WS_CHILD | WS_VISIBLE | SS_LEFT,
 10, 70, 50, 20,
 hWnd, NULL, g_hInstance, NULL);


 hWndCell3Edit = CreateWindowW(
 L"EDIT", NULL,
 WS_CHILD | WS_VISIBLE | WS_BORDER | ES_LEFT | ES_AUTOHSCROLL,
 65, 70, 100, 20,
 hWnd, NULL, g_hInstance, NULL);


 // Create OK and Cancel button controls
 hWndOkButton = CreateWindowW(
 L"BUTTON", L"OK",
 WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON,
 40, 110, 50, 25,
 hWnd, (HMENU)IDOK, g_hInstance, NULL);


 hWndCancelButton = CreateWindowW(
 L"BUTTON", L"Cancel",
 WS_CHILD | WS_VISIBLE,
 100, 110, 50, 25,
 hWnd, (HMENU)IDCANCEL, g_hInstance, NULL);


 ShowWindow(hWnd, SW_SHOW);
 UpdateWindow(hWnd);

 MSG msg{};
 while (GetMessage(&msg, nullptr, 0, 0)) {
 TranslateMessage(&msg);
 DispatchMessage(&msg);
 }

 }
 if ((HWND)lParam == openFileBtn) {
 // Open File button clicked, show open file dialoge and load the selected file into the edit control
 OPENFILENAME ofn = { };
 WCHAR szFile[MAX_PATH] = L"";
 ofn.lStructSize = sizeof(OPENFILENAME);
 ofn.hwndOwner = hWnd;
 ofn.lpstrFilter = L"Text files\0*.txt\0All files\0*.*\0";
 ofn.lpstrFile = szFile;
 ofn.nMaxFile = MAX_PATH;
 ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST;
 if (GetOpenFileName(&ofn)) {
 // Read file and set text of edit box
 std::ifstream infile(ofn.lpstrFile, std::ios::in | std::ios::binary);
 if (infile) {
 std::wstring text((std::istreambuf_iterator<char>(infile)), std::istreambuf_iterator<char>());
 SetWindowText(hEditControl, text.c_str());
 filePath = ofn.lpstrFile;
 }
 }
 }
 if ((HWND)lParam == saveFileBtn) {
 if (!filePath.empty()) {
 std::wofstream outfile(filePath, std::ios::out | std::ios::binary); // use std::wofstream instead of std::ofstream
 if (outfile) {
 int textLength = GetWindowTextLength(hEditControl);
 if (textLength != 0) {
 wchar_t* textBuffer = new wchar_t[textLength + 1];
 GetWindowTextW(hEditControl, textBuffer, textLength + 1);
 outfile.write(textBuffer, textLength * sizeof(wchar_t));
 delete[] textBuffer;
 }
 }
 outfile.close();
 MessageBox(NULL, L"File saved successfully!", L"File save", MB_OK);
 }

 }
 //The following are not currently working due to an issue in connecting to the edit box for char type manipulation
 if ((HWND)lParam == emboldenBtn) {

 }
 if ((HWND)lParam == italiciseBtn) {

 }
 //cannot or failed to open video file 
 if ((HWND)lParam == OpenMp4Btn) {
 OPENFILENAMEA ofn = {};
 ofn.lStructSize = sizeof(ofn);
 ofn.hwndOwner = hwnd;
 ofn.lpstrFilter = "Video Files (*.mp4;*.mov)\0*.mp4;*.mov\0All Files (*.*)\0*.*\0";
 char szFile[MAX_PATH] = {};
 ofn.lpstrFile = szFile;
 ofn.nMaxFile = MAX_PATH;
 ofn.lpstrTitle = "Open Video File";
 ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST;
 if (GetOpenFileNameA(&ofn)) {
 // Initialize SDL
 SDL_Init(SDL_INIT_VIDEO);

 // Open the selected video file
 AVFormatContext* format_ctx = nullptr;
 if (avformat_open_input(&format_ctx, szFile, nullptr, nullptr) != 0) {
 // Error handling
 }

 // Retrieve stream information
 if (avformat_find_stream_info(format_ctx, nullptr) < 0) {
 // Error handling
 }

 // Find the video and audio streams
 int video_stream_idx = av_find_best_stream(format_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
 int audio_stream_idx = av_find_best_stream(format_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, nullptr, 0);

 // Open the video and audio codecs
 AVCodecContext* video_codec_ctx = avcodec_alloc_context3(nullptr);
 avcodec_parameters_to_context(video_codec_ctx, format_ctx->streams[video_stream_idx]->codecpar);
 AVCodec* video_codec = const_cast(avcodec_find_decoder(video_codec_ctx->codec_id));
 if (avcodec_open2(video_codec_ctx, video_codec, nullptr) < 0) {
 // Error handling
 }

 AVCodecContext* audio_codec_ctx = avcodec_alloc_context3(nullptr);
 avcodec_parameters_to_context(audio_codec_ctx, format_ctx->streams[audio_stream_idx]->codecpar);
 AVCodec* audio_codec = const_cast(avcodec_find_decoder(audio_codec_ctx->codec_id));
 if (avcodec_open2(audio_codec_ctx, audio_codec, nullptr) < 0) {
 // Error handling
 }
 // Allocate memory for the video and audio frames
 AVFrame* video_frame = av_frame_alloc();
 AVFrame* audio_frame = av_frame_alloc();

 // Create a window for displaying the video frames
 SDL_Window* window = SDL_CreateWindow("Video Player", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, video_codec_ctx->width, video_codec_ctx->height, SDL_WINDOW_SHOWN);

 // Create a renderer for displaying the video frames
 SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, 0);

 // Create a texture for displaying the video frames
 SDL_Texture* texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_BGR24, SDL_TEXTUREACCESS_STREAMING, video_codec_ctx->width, video_codec_ctx->height);

 // Create a scaling context for converting the video frames to RGB
 SwsContext* sws_ctx = sws_getContext(video_codec_ctx->width, video_codec_ctx->height, video_codec_ctx->pix_fmt,
 video_codec_ctx->width, video_codec_ctx->height, AV_PIX_FMT_BGR24,
 SWS_BILINEAR, nullptr, nullptr, nullptr);

 // Decode and display the video frames
 AVPacket packet;
 while (av_read_frame(format_ctx, &packet) >= 0) {
 if (packet.stream_index == video_stream_idx) {
 avcodec_send_packet(video_codec_ctx, &packet);
 while (avcodec_receive_frame(video_codec_ctx, video_frame) == 0) {
 sws_scale(sws_ctx, video_frame->data, video_frame->linesize, 0, video_codec_ctx->height,
 video_frame->data, video_frame->linesize);
 SDL_UpdateTexture(texture, NULL, video_frame->data[0], video_frame->linesize[0]);
 SDL_RenderClear(renderer);
 SDL_RenderCopy(renderer, texture, NULL, NULL);
 SDL_RenderPresent(renderer);
 }
 }
 av_packet_unref(&packet);
 }

 // Free the allocated memory and close the codecs
 av_frame_free(&video_frame);
 av_frame_free(&audio_frame);
 avcodec_free_context(&video_codec_ctx);
 avcodec_free_context(&audio_codec_ctx);
 avformat_close_input(&format_ctx);

 // Destroy the window, renderer, and texture
 SDL_DestroyTexture(texture);
 SDL_DestroyRenderer(renderer);
 SDL_DestroyWindow(window);

 // Quit SDL
 SDL_Quit();
 }
 }
 }
 break;
 case WM_DESTROY:
 //code that executes on window destruction
 PostQuitMessage(0);
 return 0;
 default:
 return DefWindowProc(hwnd, msg, wParam, lParam);
 }
}
</char></char>

I am doing this on MVSC2022 in a C++ win32 application if it's relevant, I will attach some images of the video : some of the videosome more of the videoA screenshot of the output screen


-
How to use hardware acceleration for ffmpeg [closed]
11 mars 2024, par Kevin GilbertI am try to get hardware acceleration going on my Dell Inspiron AMD laptop. It appears that
vaapiis installed but how to I use it inffmpeg?

For testing, all I want is to accelerate


ffmpeg -i input.ts output.mp4


Currently, the unaccelerated command I am currently using is


ffmpeg -y -i input.ts -c:v libx264 -preset slower -tune film -filter_complex scale=1080:608 -sws_flags lanczos output.mp4


BTW : Environment is fully up-to-date Fedora 39 with stock
ffmpeg.

-
avcodec/h2645_sei : signal new AVFilmGrainParams members
18 mars 2024, par Niklas Haas
Syndiquer tout le site
