jie/mp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

move init opengl and render opengl logic into sub function, add filetype switch

Browse Source
This commit is contained in:
Jie 2024-02-20 15:59:45 +08:00
parent fdd5467208
commit f9b439add8
1 changed files with 118 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

199
main.cc
View File

@ -2,55 +2,41 @@
#include <SDL2/SDL.h> #include <SDL2/SDL.h>
#include <SDL2/SDL_image.h> #include <SDL2/SDL_image.h>
#include <filesystem> #include <filesystem>
#include "util.h"
#include "decoder.h" #include "decoder.h"
#include "shaderService.h" #include "shaderService.h"
#include "shader.h" #include "shader.h"
using std::cout, std::endl; using std::cout, std::endl;
int main(int argc, char **const argv) struct OpenglVideoParam{
{ SDL_GLContext glContext;
if (SDL_Init(SDL_INIT_EVERYTHING) < 0) unsigned int VAO, VBO, EBO;
{ unsigned int texs[3];
cout << SDL_GetError() << "\n"; };
return -1;
}
const char* targetFilepath = argv[1];
if(targetFilepath == nullptr || !std::filesystem::exists(targetFilepath)){
cout<<"File Not Exist\n";
return 0;
}
DecoderParam param{};
InitDecoder(targetFilepath, param);
int client_width = param.width / 2;
int client_height = param.height / 2;
SDL_Window *window = SDL_CreateWindow(
"SDL2Demo",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
client_width,
client_height,
SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL);
int InitVideo(SDL_Window*& window, const char* targetFilepath, DecoderParam& decoderParam, OpenglVideoParam& openglVideoParam, ShaderService*& shaderService){
InitDecoder(targetFilepath, decoderParam);
int client_width = decoderParam.width / 2;
int client_height = decoderParam.height / 2;
window = SDL_CreateWindow(
"MP",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
client_width,
client_height,
SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL);
if (!window) if (!window)
{ {
cout << SDL_GetError() << "\n"; cout << SDL_GetError() << "\n";
return -1; return -1;
} }
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
std::cout << "Failed to initialize SDL2! \n"
<< SDL_GetError() << std::endl;
return -1;
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE); SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GLContext glContext = SDL_GL_CreateContext(window); openglVideoParam.glContext = SDL_GL_CreateContext(window);
if (!glContext) if (!openglVideoParam.glContext)
{ {
cout << SDL_GetError() << "\n"; cout << SDL_GetError() << "\n";
return -1; return -1;
@ -76,39 +62,104 @@ int main(int argc, char **const argv)
3, 3,
}; };
unsigned int VAO, VBO, EBO; glGenVertexArrays(1, &openglVideoParam.VAO);
glGenVertexArrays(1, &VAO); glGenBuffers(1, &openglVideoParam.VBO);
glGenBuffers(1, &VBO); glGenBuffers(1, &openglVideoParam.EBO);
glGenBuffers(1, &EBO); glBindVertexArray(openglVideoParam.VAO);
glBindVertexArray(VAO); glBindBuffer(GL_ARRAY_BUFFER, openglVideoParam.VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, openglVideoParam.EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), 0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), 0);
glEnableVertexAttribArray(0); glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void *)(3 * sizeof(float))); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void *)(3 * sizeof(float)));
glEnableVertexAttribArray(1); glEnableVertexAttribArray(1);
unsigned int texs[3]; glGenTextures(3, openglVideoParam.texs);
glGenTextures(3, texs);
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
{ {
glBindTexture(GL_TEXTURE_2D, texs[i]); glBindTexture(GL_TEXTURE_2D, openglVideoParam.texs[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
} }
/* ShaderService shaderService{
std::filesystem::path("/home/jie/project/mp/shaders/vertexShader.vert"),
std::filesystem::path("/home/jie/project/mp/shaders/fragShader.frag")};
*/ shaderService = new ShaderService{vSource.data(), fSource.data()};
ShaderService shaderService{vSource.data(), fSource.data()}; shaderService->Use();
shaderService.Use(); shaderService->SetUniform<int>("textureY", 0);
shaderService.SetUniform<int>("textureY", 0); shaderService->SetUniform<int>("textureU", 1);
shaderService.SetUniform<int>("textureU", 1); shaderService->SetUniform<int>("textureV", 2);
shaderService.SetUniform<int>("textureV", 2); return 0;
}
void OpenglRender(DecoderParam& decoderParam, OpenglVideoParam& openglVideoParam, ShaderService* shaderService){
auto frame = RequestFrame(decoderParam);
int64_t pts = frame->pts;
static bool first_frame = true;
// TODO: TIMER
SDL_Delay(100);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, openglVideoParam.texs[0]);
glPixelStoref(GL_UNPACK_ROW_LENGTH, frame->linesize[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, frame->width, frame->height, 0, GL_RED, GL_UNSIGNED_BYTE, frame->data[0]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, openglVideoParam.texs[1]);
glPixelStoref(GL_UNPACK_ROW_LENGTH, frame->linesize[1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, frame->width / 2, frame->height / 2, 0, GL_RED, GL_UNSIGNED_BYTE, frame->data[1]);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, openglVideoParam.texs[2]);
glPixelStoref(GL_UNPACK_ROW_LENGTH, frame->linesize[2]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, frame->width / 2, frame->height / 2, 0, GL_RED, GL_UNSIGNED_BYTE, frame->data[2]);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
shaderService->Use();
glBindVertexArray(openglVideoParam.VAO);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
}
int main(int argc, char **const argv)
{
//Check File
const char* targetFilepath = argv[1];
if(targetFilepath == nullptr || !std::filesystem::exists(targetFilepath)){
cout<<"File Not Exist\n";
return 0;
}
const FileType fileType = Util::GetFileType(targetFilepath);
if(fileType == FileType::ERRORTYPE){
cout<<"unsupport file type\n";
return 0;
}
//INIT
int client_width, client_height;
SDL_Window* window = nullptr;
DecoderParam decoderParam{};
OpenglVideoParam openglVideoParam{};
ShaderService* shaderService = nullptr;
if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
{
cout << SDL_GetError() << "\n";
return -1;
}
switch(fileType){
case FileType::VIDEO:{
InitVideo(window, targetFilepath, decoderParam, openglVideoParam, shaderService);
break;
}
case FileType::IMG:{
break;
}
case FileType::MUSIC:{
break;
}
default:
return -1;
}
bool quit = false; bool quit = false;
SDL_Event event; SDL_Event event;
@ -135,39 +186,21 @@ int main(int argc, char **const argv)
} }
// Render // Render
switch (fileType)
{
case FileType::VIDEO:
OpenglRender(decoderParam, openglVideoParam, shaderService);
SDL_GL_SwapWindow(window);
break;
auto frame = RequestFrame(param); default:
int64_t pts = frame->pts; break;
static bool first_frame = true; }
// TODO: TIMER
SDL_Delay(100);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texs[0]);
glPixelStoref(GL_UNPACK_ROW_LENGTH, frame->linesize[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, frame->width, frame->height, 0, GL_RED, GL_UNSIGNED_BYTE, frame->data[0]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, texs[1]);
glPixelStoref(GL_UNPACK_ROW_LENGTH, frame->linesize[1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, frame->width / 2, frame->height / 2, 0, GL_RED, GL_UNSIGNED_BYTE, frame->data[1]);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, texs[2]);
glPixelStoref(GL_UNPACK_ROW_LENGTH, frame->linesize[2]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, frame->width / 2, frame->height / 2, 0, GL_RED, GL_UNSIGNED_BYTE, frame->data[2]);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
shaderService.Use();
glBindVertexArray(VAO);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
SDL_GL_SwapWindow(window);
} }
avcodec_close(param.codecCtx); avcodec_close(decoderParam.codecCtx);
avformat_close_input(&(param.fmtCtx)); avformat_close_input(&(decoderParam.fmtCtx));
SDL_GL_DeleteContext(glContext); SDL_GL_DeleteContext(openglVideoParam.glContext);
SDL_DestroyWindow(window); SDL_DestroyWindow(window);
SDL_Quit(); SDL_Quit();
return 0; return 0;