Recherche avancée
Médias (1)
-
DJ Dolores - Oslodum 2004 (includes (cc) sample of “Oslodum” by Gilberto Gil)
15 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
Autres articles (67)
-
Submit bugs and patches
13 avril 2011Unfortunately a software is never perfect.
If you think you have found a bug, report it using our ticket system. Please to help us to fix it by providing the following information : the browser you are using, including the exact version as precise an explanation as possible of the problem if possible, the steps taken resulting in the problem a link to the site / page in question
If you think you have solved the bug, fill in a ticket and attach to it a corrective patch.
You may also (...) -
Des sites réalisés avec MediaSPIP
2 mai 2011, parCette page présente quelques-uns des sites fonctionnant sous MediaSPIP.
Vous pouvez bien entendu ajouter le votre grâce au formulaire en bas de page. -
La sauvegarde automatique de canaux SPIP
1er avril 2010, parDans le cadre de la mise en place d’une plateforme ouverte, il est important pour les hébergeurs de pouvoir disposer de sauvegardes assez régulières pour parer à tout problème éventuel.
Pour réaliser cette tâche on se base sur deux plugins SPIP : Saveauto qui permet une sauvegarde régulière de la base de donnée sous la forme d’un dump mysql (utilisable dans phpmyadmin) mes_fichiers_2 qui permet de réaliser une archive au format zip des données importantes du site (les documents, les éléments (...)
Sur d’autres sites (8173)
-
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


-
Revision 37457 : en étant moins verbeux c’est mieux
20 avril 2010, par kent1@… — Logen étant moins verbeux c’est mieux
-
lavf/apetag : move common stuff between writer and reader to single file
29 juillet 2012, par Paul B Mahollavf/apetag : move common stuff between writer and reader to single file
Syndiquer tout le site
