portable-devtools / video_codec_sdk /Samples /AppEncode /AppEncMultiInstance /AppEncMultiInstance.cpp
| /* | |
| * Copyright 2017-2024 NVIDIA Corporation. All rights reserved. | |
| * | |
| * Please refer to the NVIDIA end user license agreement (EULA) associated | |
| * with this source code for terms and conditions that govern your use of | |
| * this software. Any use, reproduction, disclosure, or distribution of | |
| * this software and related documentation outside the terms of the EULA | |
| * is strictly prohibited. | |
| * | |
| */ | |
| /* | |
| * This sample application was created to accelerate file compression storage applications. | |
| * It does this by splitting the input video into N separate and independent video portions, | |
| * i.e., independent GOPs (Split GOP). After being encoded independently, the compressed video | |
| * portions are then written to file preserving the original order generating a single output | |
| * bitstream. | |
| * More than one encoding session thread can be used to encode the several independent video | |
| * portions. Using more than 1 encoding session threads should allow for speedups when using | |
| * NVIDIA GPUs with more than 1 NVENC. | |
| * The number of portions the input video should be partitioned in is controlled by the CLI | |
| * option "-nf" and the number of encoding session threads "-thread". Note that on systems | |
| * with GeForce GPUs, the number of simultaneous encode sessions allowed on the system is | |
| * restricted to 5 sessions. | |
| * There are separate threads for: 1. reading the RAW input frames from disk; 2. copying the RAW | |
| * frames from RAM to VRAM, encoding and copying the compressed data from VRAM to RAM; 3. writing | |
| * the compressed data to the output file. Additionally, the main thread is only used for | |
| * initialization and to create work queues for the described threads. | |
| */ | |
| simplelogger::Logger *logger = simplelogger::LoggerFactory::CreateConsoleLogger(); | |
| inline void gatherEncodedData(std::vector<uint8_t>& encOutBuf, uint8_t* hostOutVidBuf, uint64_t &totalBitStreamSize, std::vector<EncodedFrameData>& hostEncodedData) | |
| { | |
| EncodedFrameData frameData; | |
| frameData.offset = 0; | |
| frameData.data = hostOutVidBuf + totalBitStreamSize; | |
| frameData.size = static_cast<uint32_t>(encOutBuf.size()); // get size of the bitstream chunk | |
| std::memcpy(frameData.data, reinterpret_cast<char*>(encOutBuf.data()), encOutBuf.size()); | |
| totalBitStreamSize += frameData.size + frameData.offset; // increment copied size | |
| hostEncodedData.push_back(std::ref(frameData)); | |
| } | |
| void asyncFread(ConcurrentQueue<fileReadData>& freadeQueue, std::atomic<bool>& freadWorking) | |
| { | |
| fileReadData input; | |
| while (freadWorking) { | |
| if (freadeQueue.size()) { | |
| input = freadeQueue.pop_front(); // always pop front to preserve order of video portions | |
| safeBuffer* inSafeBuf = input.ioVideoMem->hostInBuf; | |
| std::ifstream fpIn(input.filePath, std::ifstream::in | std::ifstream::binary); // open input file | |
| fpIn.seekg(input.offset, fpIn.beg); // get desired video portion | |
| if (!fpIn) { | |
| LOG(ERROR) << "Unable to open input file: " << input.filePath; | |
| break; | |
| } | |
| uint64_t nFrameSize = input.threadData->encSession->GetFrameSize(); | |
| ck(cuCtxSetCurrent((CUcontext)input.threadData->encSession->GetDevice())); | |
| for (uint32_t i = 0; i < input.numFrames; i++) | |
| { | |
| int bufIdx = i % bufSize; | |
| std::unique_lock<std::mutex> inLock{ inSafeBuf[bufIdx].mutex }; | |
| while (!inSafeBuf[bufIdx].readyToEdit) { | |
| inSafeBuf[bufIdx].condVarReady.wait(inLock); // wait until INPUT buffer is ready to be EDITED | |
| } | |
| std::streamsize nRead = fpIn.read(reinterpret_cast<char*>(inSafeBuf[bufIdx].data), nFrameSize).gcount(); // read one frame from desired video portion | |
| inSafeBuf[bufIdx].readyToEdit = false; // ENCODE step can start | |
| inSafeBuf[bufIdx].condVarReady.notify_all(); | |
| } | |
| fpIn.close(); // close file | |
| if (input.isLast) { // if last end thread | |
| freadWorking = false; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| void asyncEncode(ConcurrentQueue<encodeData>& encodeQueue, std::atomic<bool>& encoderWorking) | |
| { | |
| encodeData enc; | |
| while (encoderWorking) { | |
| if (encodeQueue.size()) { | |
| enc = encodeQueue.pop_front(); // always pop front to preserve order of video portions | |
| safeBuffer* inSafeBuf = enc.ioVideoMem->hostInBuf; | |
| safeBuffer* outSafeBuf = &enc.ioVideoMem->hostOutBuf; | |
| std::unique_lock<std::mutex> outLock{ outSafeBuf->mutex }; | |
| while (!outSafeBuf->readyToEdit) { | |
| outSafeBuf->condVarReady.wait(outLock); // wait until OUTPUT buffer is ready to be EDITED | |
| } | |
| std::ifstream fpIn(enc.filePath, std::ifstream::in | std::ifstream::binary); // open input file | |
| fpIn.seekg(enc.offset, fpIn.beg); // get desired video portion | |
| if (!fpIn) { | |
| LOG(ERROR) << "Unable to open input file: " << enc.filePath; | |
| break; | |
| } | |
| enc.ioVideoMem->hostEncodedData.clear(); // clear last ouput data | |
| uint64_t nFrameSize = enc.threadData->encSession->GetFrameSize(); | |
| uint64_t totalBitStreamSize = 0; // need to keep track of the size of each compressed frame | |
| ck(cuCtxSetCurrent((CUcontext)enc.threadData->encSession->GetDevice())); | |
| std::vector<NvEncOutputFrame> encOutBuf; | |
| NV_ENC_PIC_PARAMS nvEncPicParams = { NV_ENC_PIC_PARAMS_VER }; | |
| if (!enc.isSingleThread) | |
| nvEncPicParams.encodePicFlags = NV_ENC_PIC_FLAG_FORCEIDR; // force IDR frame for the first frame of each video portion | |
| std::vector <std::unique_lock<std::mutex>> inBufLocks; | |
| for (uint32_t i = 0; i < bufSize; i++) | |
| inBufLocks.push_back(std::unique_lock<std::mutex>(inSafeBuf[i].mutex, std::defer_lock)); | |
| for (uint32_t i = 0; i < enc.numFrames; i++) | |
| { | |
| int bufIdx = i % bufSize; | |
| int lastBufIdx = bufIdx == 0 ? (bufSize-1) : (bufIdx-1); | |
| if(i > 0){ | |
| ck(cuStreamSynchronize(enc.threadData->cuStream->GetInputCUStream())); // make sure the last memcpy is complete | |
| inSafeBuf[lastBufIdx].readyToEdit = true; // ENCODE step can start | |
| inSafeBuf[lastBufIdx].condVarReady.notify_all(); | |
| inBufLocks[lastBufIdx].unlock(); | |
| } | |
| inBufLocks[bufIdx].lock(); | |
| while (inSafeBuf[bufIdx].readyToEdit) { | |
| inSafeBuf[bufIdx].condVarReady.wait(inBufLocks[bufIdx]); // wait until INPUT buffer is ready to be EDITED | |
| } | |
| const NvEncInputFrame* encoderInputFrame = enc.threadData->encSession->GetNextInputFrame(); | |
| NvEncoderCuda::CopyToDeviceFrame((CUcontext)enc.threadData->encSession->GetDevice(), | |
| (uint8_t*)inSafeBuf[bufIdx].data, | |
| 0, | |
| (CUdeviceptr)encoderInputFrame->inputPtr, | |
| encoderInputFrame->pitch, | |
| enc.threadData->encSession->GetEncodeWidth(), | |
| enc.threadData->encSession->GetEncodeHeight(), | |
| CU_MEMORYTYPE_HOST, | |
| encoderInputFrame->bufferFormat, | |
| encoderInputFrame->chromaOffsets, | |
| encoderInputFrame->numChromaPlanes, | |
| false, | |
| enc.threadData->cuStream->GetInputCUStream()); // do async frame copy from host to device | |
| enc.threadData->encSession->EncodeFrame(encOutBuf, i || enc.isSingleThread ? NULL : &nvEncPicParams); // if first frame than use IDR frame | |
| for (uint32_t j = 0; j < encOutBuf.size(); ++j) { // gather encoded data in output buffer to write to file later | |
| gatherEncodedData(encOutBuf[j].frame, outSafeBuf->data, totalBitStreamSize, enc.ioVideoMem->hostEncodedData); | |
| } | |
| } | |
| if (!enc.isSingleThread || enc.isLast) { | |
| enc.threadData->encSession->EndEncode(encOutBuf); // get last compressed frames | |
| for (uint32_t j = 0; j < encOutBuf.size(); ++j) { // gather encoded data in output buffer to write to file later | |
| gatherEncodedData(encOutBuf[j].frame, outSafeBuf->data, totalBitStreamSize, enc.ioVideoMem->hostEncodedData); | |
| } | |
| } | |
| outSafeBuf->readyToEdit = false; // OUTPUT buffer is ready to be READ | |
| outSafeBuf->condVarReady.notify_all(); | |
| int lastBufIdx = (enc.numFrames-1) % bufSize; | |
| inSafeBuf[lastBufIdx].readyToEdit = true; | |
| inSafeBuf[lastBufIdx].condVarReady.notify_all(); | |
| if (enc.isLast) { // if last end thread | |
| encoderWorking = false; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| void asyncFwrite(ConcurrentQueue<fileWriteData>& fwriteQueue, std::atomic<bool>& fwriteWorking) | |
| { | |
| fileWriteData output; | |
| uint8_t skipIVF = 32; | |
| while (fwriteWorking) { | |
| if (fwriteQueue.size()) { | |
| output = fwriteQueue.pop_front(); // always pop front to preserve order of video portions | |
| safeBuffer* sB = &output.ioVideoMem->hostOutBuf; | |
| std::unique_lock<std::mutex> lock{ sB->mutex }; | |
| while (sB->readyToEdit) { | |
| sB->condVarReady.wait(lock); // wait until OUTPUT buffer is ready to be READ | |
| } | |
| bool firstPackage = true; | |
| for(auto compressedData : output.ioVideoMem->hostEncodedData) { | |
| if(output.isAV1 && output.vidThreadIdx > 0 && output.isFirst && firstPackage){ // for AV1 we only need an IVF header on the first video portion | |
| output.fpOut->write((char*)(compressedData.data + skipIVF), compressedData.size - skipIVF); // write all the compressed data to file skipping IVF header | |
| firstPackage = false; | |
| } | |
| else{ | |
| output.fpOut->write((char*)(compressedData.data), compressedData.size); // write all the compressed data to file | |
| } | |
| } | |
| sB->readyToEdit = true; | |
| sB->condVarReady.notify_all(); | |
| if (output.isLast) { // if last end thread | |
| output.fpOut->close(); // close file | |
| std::cout << "Bitstream saved in file " << output.outPath << std::endl; | |
| fwriteWorking = false; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| void ShowEncoderBriefHelp() | |
| { | |
| std::ostringstream oss; | |
| oss << "NVIDIA Video Multi-Instance Encoder Sample Application\n"; | |
| oss << "==============================================\n\n"; | |
| oss << "Usage: AppEncMultiInstance -i <input_file> [options]\n\n"; | |
| // Brief table of core arguments | |
| oss << "Common Arguments:\n"; | |
| oss << std::left << std::setw(25) << "Argument" | |
| << std::setw(12) << "Type" | |
| << "Default Value\n"; | |
| oss << std::string(50, '-') << "\n"; | |
| oss << std::left << std::setw(25) << "-i <path>" | |
| << std::setw(12) << "Required" | |
| << "N/A\n"; | |
| oss << std::left << std::setw(25) << "-o <path>" | |
| << std::setw(12) << "Required" | |
| << "N/A\n"; | |
| oss << std::left << std::setw(25) << "-s <WxH>" | |
| << std::setw(12) << "Required" | |
| << "N/A\n"; | |
| oss << std::left << std::setw(25) << "-if <format>" | |
| << std::setw(12) << "Optional" | |
| << "iyuv\n"; | |
| oss << std::left << std::setw(25) << "-gpu <n>" | |
| << std::setw(12) << "Optional" | |
| << "0\n"; | |
| oss << std::left << std::setw(25) << "-nf <n>" | |
| << std::setw(12) << "Optional" | |
| << "120\n"; | |
| oss << std::left << std::setw(25) << "-thread <n>" | |
| << std::setw(12) << "Optional" | |
| << "2\n"; | |
| oss << "\nFor detailed help, use -A/--advanced-options\n"; | |
| oss << "To view encoder capabilities, use -ec/--encode-caps\n"; | |
| std::cout << oss.str(); | |
| exit(0); | |
| } | |
| void ShowEncoderDetailedHelp() | |
| { | |
| std::ostringstream oss; | |
| oss << "NVIDIA Video Multi-Instance Encoder Sample Application - Detailed Help\n"; | |
| oss << "=======================================================\n\n"; | |
| oss << "Usage: AppEncMultiInstance -i <input_file> [options]\n\n"; | |
| // Full table of all arguments | |
| oss << "All Arguments:\n"; | |
| oss << std::left << std::setw(25) << "Argument" | |
| << std::setw(12) << "Type" | |
| << std::setw(20) << "Default Value" | |
| << "Example\n"; | |
| oss << std::string(80, '-') << "\n"; | |
| // Required arguments | |
| oss << std::left << std::setw(25) << "-i <path>" | |
| << std::setw(12) << "Required" | |
| << std::setw(20) << "N/A" | |
| << "-i input.yuv\n"; | |
| oss << std::left << std::setw(25) << "-s <WxH>" | |
| << std::setw(12) << "Required" | |
| << std::setw(20) << "N/A" | |
| << "-s 1920x1080\n"; | |
| // Optional arguments | |
| oss << std::left << std::setw(25) << "-o <path>" | |
| << std::setw(12) << "Optional" | |
| << std::setw(20) << "codec-based" | |
| << "-o output.h264\n"; | |
| oss << std::left << std::setw(25) << "-if <format>" | |
| << std::setw(12) << "Optional" | |
| << std::setw(20) << "iyuv" | |
| << "-if yuv444\n"; | |
| oss << std::left << std::setw(25) << "-gpu <n>" | |
| << std::setw(12) << "Optional" | |
| << std::setw(20) << "0" | |
| << "-gpu 1\n"; | |
| oss << std::left << std::setw(25) << "-nf <n>" | |
| << std::setw(12) << "Optional" | |
| << std::setw(20) << "120" | |
| << "-nf 240\n"; | |
| oss << std::left << std::setw(25) << "-thread <n>" | |
| << std::setw(12) << "Optional" | |
| << std::setw(20) << "2" | |
| << "-thread 2\n"; | |
| // Detailed descriptions | |
| oss << "\nDetailed Descriptions:\n"; | |
| oss << "-------------------\n"; | |
| oss << std::left << std::setw(25) << "-i" << ": Input file path\n"; | |
| oss << std::left << std::setw(25) << "-o" << ": Output file path\n"; | |
| oss << std::left << std::setw(25) << "-s" << ": Input resolution in WxH format\n"; | |
| oss << std::left << std::setw(25) << "-if" << ": Input format (iyuv/nv12/yv12/yuv444/p010/yuv444p16/bgra/argb10/ayuv/abgr/abgr10)\n"; | |
| oss << std::left << std::setw(25) << "-gpu" << ": Ordinal of GPU to use\n"; | |
| oss << std::left << std::setw(25) << "-nf" << ": Number of frames per video portion\n"; | |
| oss << std::left << std::setw(25) << "-thread" << ": Number of encoding session threads\n"; | |
| oss << std::left << std::setw(25) << "-h/--help" << ": Print basic usage information\n"; | |
| oss << std::left << std::setw(25) << "-A/--advanced-options" << ": Print detailed usage information\n"; | |
| oss << std::left << std::setw(25) << "-ec/--encode-caps" << ": Print encode capabilities of GPU\n"; | |
| // Important notes | |
| oss << "\nNotes:\n"; | |
| oss << "------\n"; | |
| oss << "* This sample demonstrates multi-instance encoding for faster compression\n"; | |
| oss << "* Input video is split into N portions (controlled by -nf)\n"; | |
| oss << "* Each portion is encoded independently with separate threads\n"; | |
| oss << "* Encode session limits: 8 concurrent sessions (GeForce) or unlimited (Quadro/Tesla)\n"; | |
| oss << "* Uses separate threads for reading, encoding, and writing\n"; | |
| oss << "* Output preserves original video order\n"; | |
| oss << std::endl; | |
| oss << NvEncoderInitParam().GetHelpMessage(false, false, true, false, false, false, false, true) << std::endl; | |
| oss << "\nTo view encode capabilities, use -ec/--encode-caps\n"; | |
| std::cout << oss.str(); | |
| exit(0); | |
| } | |
| void ShowHelpAndExit(const char *szBadOption = NULL) | |
| { | |
| if (szBadOption) | |
| { | |
| std::ostringstream oss; | |
| oss << "Error parsing \"" << szBadOption << "\"\n"; | |
| oss << "Use -h/--help for basic usage or -A/--advanced-options for detailed information\n"; | |
| throw std::invalid_argument(oss.str()); | |
| } | |
| } | |
| void ParseCommandLine(int argc, char *argv[], uint64_t &nNumVideoPortions, char *szInputFileName, char *szOutputFileName, uint32_t &nWidth, uint32_t &nHeight, | |
| NV_ENC_BUFFER_FORMAT &eFormat, int &iGpu, int &nThread, NvEncoderInitParam &initParam) | |
| { | |
| std::ostringstream oss; | |
| if (argc == 1) { | |
| std::cout << "No Arguments provided! Please refer to the following for options:\n"; | |
| ShowEncoderBriefHelp(); | |
| } | |
| for (int i = 1; i < argc; i++) | |
| { | |
| if (!_stricmp(argv[i], "-h") || !_stricmp(argv[i], "--help")) { | |
| ShowEncoderBriefHelp(); | |
| } | |
| if (!_stricmp(argv[i], "-A") || !_stricmp(argv[i], "--advanced-options")) { | |
| ShowEncoderDetailedHelp(); | |
| } | |
| if (!_stricmp(argv[i], "-ec") || !_stricmp(argv[i], "--encode-caps")) { | |
| ShowEncoderCapability(); | |
| } | |
| if (!_stricmp(argv[i], "-i")) | |
| { | |
| if (++i == argc) | |
| { | |
| ShowHelpAndExit("-i"); | |
| } | |
| sprintf(szInputFileName, "%s", argv[i]); | |
| continue; | |
| } | |
| if (!_stricmp(argv[i], "-s")) | |
| { | |
| if (++i == argc || 2 != sscanf(argv[i], "%dx%d", &nWidth, &nHeight)) | |
| { | |
| ShowHelpAndExit("-s"); | |
| } | |
| continue; | |
| } | |
| if (!_stricmp(argv[i], "-nf")) | |
| { | |
| if (++i == argc) | |
| { | |
| ShowHelpAndExit("-nf"); | |
| } | |
| nNumVideoPortions = atoi(argv[i]); | |
| continue; | |
| } | |
| if (!_stricmp(argv[i], "-o")) | |
| { | |
| if (++i == argc) | |
| { | |
| ShowHelpAndExit("-o"); | |
| } | |
| sprintf(szOutputFileName, "%s", argv[i]); | |
| continue; | |
| } | |
| std::vector<std::string> vszFileFormatName = | |
| { | |
| "iyuv", "nv12", "yv12", "yuv444", "p010", "yuv444p16", "bgra", "argb10", "ayuv", "abgr", "abgr10" | |
| }; | |
| NV_ENC_BUFFER_FORMAT aFormat[] = | |
| { | |
| NV_ENC_BUFFER_FORMAT_IYUV, | |
| NV_ENC_BUFFER_FORMAT_NV12, | |
| NV_ENC_BUFFER_FORMAT_YV12, | |
| NV_ENC_BUFFER_FORMAT_YUV444, | |
| NV_ENC_BUFFER_FORMAT_YUV420_10BIT, | |
| NV_ENC_BUFFER_FORMAT_YUV444_10BIT, | |
| NV_ENC_BUFFER_FORMAT_ARGB, | |
| NV_ENC_BUFFER_FORMAT_ARGB10, | |
| NV_ENC_BUFFER_FORMAT_AYUV, | |
| NV_ENC_BUFFER_FORMAT_ABGR, | |
| NV_ENC_BUFFER_FORMAT_ABGR10, | |
| }; | |
| if (!_stricmp(argv[i], "-if")) | |
| { | |
| if (++i == argc) | |
| { | |
| ShowHelpAndExit("-if"); | |
| } | |
| auto it = std::find(vszFileFormatName.begin(), vszFileFormatName.end(), argv[i]); | |
| if (it == vszFileFormatName.end()) | |
| { | |
| ShowHelpAndExit("-if"); | |
| } | |
| eFormat = aFormat[it - vszFileFormatName.begin()]; | |
| continue; | |
| } | |
| if (!_stricmp(argv[i], "-gpu")) | |
| { | |
| if (++i == argc) | |
| { | |
| ShowHelpAndExit("-gpu"); | |
| } | |
| iGpu = atoi(argv[i]); | |
| continue; | |
| } | |
| if (!_stricmp(argv[i], "-thread")) | |
| { | |
| if (++i == argc) | |
| { | |
| ShowHelpAndExit("-thread"); | |
| } | |
| nThread = atoi(argv[i]); | |
| continue; | |
| } | |
| // Regard as encoder parameter | |
| if (argv[i][0] != '-') | |
| { | |
| ShowHelpAndExit(argv[i]); | |
| } | |
| oss << argv[i] << " "; | |
| while (i + 1 < argc && argv[i + 1][0] != '-') | |
| { | |
| oss << argv[++i] << " "; | |
| } | |
| } | |
| initParam = NvEncoderInitParam(oss.str().c_str()); | |
| } | |
| uint64_t getFileSize(const char *szFileName) | |
| { | |
| struct _stat64 st; | |
| if (_stat64(szFileName, &st) != 0) | |
| { | |
| return 0; | |
| } | |
| return st.st_size; | |
| } | |
| uint64_t getNumberOfFrames(const char *szFileName, uint32_t width, uint32_t height, uint64_t frameSize) | |
| { | |
| struct _stat64 st; | |
| if (_stat64(szFileName, &st) != 0) | |
| { | |
| return 0; | |
| } | |
| return (uint64_t)(st.st_size / frameSize); | |
| } | |
| int main(int argc, char **argv) | |
| { | |
| char szInFilePath[256] = "", | |
| szOutFilePath[256] = ""; | |
| uint32_t nWidth = 0, nHeight = 0; | |
| NV_ENC_BUFFER_FORMAT eFormat = NV_ENC_BUFFER_FORMAT_IYUV; | |
| int iGpu = 0; | |
| int nThread = 2; | |
| uint64_t numFramesPerVideoPortion = 120; | |
| try | |
| { | |
| StopWatch globalTime; | |
| globalTime.Start(); | |
| NvEncoderInitParam encodeCLIOptions; | |
| ParseCommandLine(argc, argv, numFramesPerVideoPortion, szInFilePath, szOutFilePath, nWidth, nHeight, eFormat, | |
| iGpu, nThread, encodeCLIOptions); | |
| if (numFramesPerVideoPortion == 0) { // number of video frames per video portion cannot be 0 | |
| std::cout << "numFramesPerVideoPortion (-nf) should be greater than 0!" << std::endl; | |
| return 1; | |
| } | |
| CheckInputFile(szInFilePath); | |
| ValidateResolution(nWidth, nHeight); | |
| if (!*szOutFilePath) { | |
| sprintf(szOutFilePath, encodeCLIOptions.IsCodecH264() ? "out.h264" : encodeCLIOptions.IsCodecHEVC() ? "out.hevc" : "out.av1"); | |
| } | |
| ck(cuInit(0)); | |
| int nGpu = 0; | |
| ck(cuDeviceGetCount(&nGpu)); | |
| if (iGpu < 0 || iGpu >= nGpu) { | |
| std::cout << "GPU ordinal out of range. Should be within [" << 0 << ", " << nGpu - 1 << "]" << std::endl; | |
| return 1; | |
| } | |
| CUdevice cuDevice = 0; | |
| ck(cuDeviceGet(&cuDevice, iGpu)); | |
| char szDeviceName[80]; | |
| ck(cuDeviceGetName(szDeviceName, sizeof(szDeviceName), cuDevice)); | |
| std::cout << "GPU in use: " << szDeviceName << std::endl; | |
| std::ofstream fpOut(szOutFilePath, std::ios::out | std::ios::binary); | |
| if (!fpOut) { | |
| std::ostringstream err; | |
| err << "Unable to open output file: " << szOutFilePath << std::endl; | |
| throw std::invalid_argument(err.str()); | |
| } | |
| NV_ENC_INITIALIZE_PARAMS initializeParams = { NV_ENC_INITIALIZE_PARAMS_VER }; | |
| NV_ENC_CONFIG encodeConfig = { NV_ENC_CONFIG_VER }; | |
| initializeParams.encodeConfig = &encodeConfig; | |
| CUcontext cuContext; | |
| ck(NVCODEC_CUDA_CTX_CREATE(&(cuContext), CU_CTX_SCHED_BLOCKING_SYNC, cuDevice)); // Create single CUDA context | |
| // Create and initialize array of data required for each encoding session thread | |
| std::vector<ThreadData> vidEncThreads(nThread); | |
| for (int i = 0; i < nThread; i++) { | |
| vidEncThreads[i].cuContext = &cuContext; // same CUDA context for every encoding session thread | |
| vidEncThreads[i].encSession = make_unique<NvEncoderCuda>(cuContext, nWidth, nHeight, eFormat); | |
| vidEncThreads[i].encSession->CreateDefaultEncoderParams(&initializeParams, encodeCLIOptions.GetEncodeGUID(), encodeCLIOptions.GetPresetGUID(), encodeCLIOptions.GetTuningInfo()); | |
| encodeCLIOptions.SetInitParams(&initializeParams, eFormat); | |
| vidEncThreads[i].encSession->CreateEncoder(&initializeParams); | |
| vidEncThreads[i].cuStream.reset(new NvCUStream(cuContext, 1, vidEncThreads[i].encSession)); // each encoding session thread is going to use one cuda stream | |
| } | |
| uint64_t frameSize = vidEncThreads[0].encSession->GetFrameSize(); // calculate frame size | |
| uint64_t numFramesTotal = getNumberOfFrames(szInFilePath, nWidth, nHeight, frameSize); // calculate total number of frames | |
| uint64_t nNumVideoPortions = 0; | |
| if (numFramesPerVideoPortion > numFramesTotal) { // the number of frames per video portion should not be larger than the total number of frames | |
| numFramesPerVideoPortion = numFramesTotal; | |
| std::cout << "Warning: Number of frames per video portions should be smaller or equal to total number of frames! Adjusting numFramesPerVideoPortion = " << numFramesPerVideoPortion << std::endl; | |
| } | |
| // calculations required for cases where the number of frames per video portions is not a multiple of the total number of frames | |
| if (nThread == 1) { | |
| std::cout << "SINGLE ENCODE SESSSION MODE - The video encoding pipeline is processed with no GOP splits, i.e., the input video is not split into video portions." << std::endl; | |
| numFramesPerVideoPortion = 16; | |
| } | |
| nNumVideoPortions = (numFramesTotal / numFramesPerVideoPortion) + ((numFramesTotal % numFramesPerVideoPortion) != 0); | |
| uint64_t sizePerVideoPortion = numFramesPerVideoPortion * frameSize; | |
| uint64_t numFramesLastVideoPortion = (numFramesTotal % numFramesPerVideoPortion); | |
| if (!numFramesLastVideoPortion) // if this is 0 it means the last video portion has the same number of frames as the other video portions | |
| numFramesLastVideoPortion = numFramesPerVideoPortion; | |
| uint64_t totalMemoryAllocation = (sizePerVideoPortion + 1) * nThread; | |
| // calculate and report total memory allocation required for the current settings | |
| std::cout << "Number of video portions: " << nNumVideoPortions << std::endl; | |
| std::cout << "Number of frames per video portions: " << numFramesPerVideoPortion << std::endl; | |
| std::cout << "Size of each video portion: " << sizePerVideoPortion / 1000000 << " MB." << std::endl; | |
| std::cout << "Number of video encoding threads: " << nThread << std::endl; | |
| std::cout << "Allocating " << totalMemoryAllocation / 1000000 << " MB of memory." << std::endl; | |
| // Allocate all the required memory for IO | |
| std::vector<IOEncoderMem> ioVideoMem(nThread); | |
| for (int i = 0; i < nThread; i++) { | |
| for (int inBuf = 0; inBuf < bufSize; inBuf++){ | |
| ioVideoMem[i].hostInBuf[inBuf].readyToEdit = true; | |
| ck(cuMemAllocHost((void**)&ioVideoMem[i].hostInBuf[inBuf].data, frameSize)); // Allocate pinned memory for input RAW frame | |
| } | |
| ioVideoMem[i].hostOutBuf.readyToEdit = true; | |
| ck(cuMemAllocHost((void**)&ioVideoMem[i].hostOutBuf.data, sizePerVideoPortion)); // Allocate pinned memory for output compressed video portions | |
| } | |
| // Create fwrite and encode work queues | |
| ConcurrentQueue<fileWriteData> fwriteQueue; | |
| std::vector<ConcurrentQueue<encodeData>> encodeQueue(nThread); | |
| std::vector<ConcurrentQueue<fileReadData>> freadQueue(nThread); | |
| uint64_t nFrame = 0; // frame counter per video portion | |
| uint32_t videoPortion = 0; // video portion counter | |
| uint64_t nTotal = 0; // total frame counter | |
| float totalProcessingTime = 0; | |
| while (videoPortion < nNumVideoPortions) // go through every video portion | |
| { | |
| nFrame = 0; // reset number of frames per video portion | |
| for (int i = 0; i < nThread && videoPortion + i < nNumVideoPortions; i++) // split video portions across the several available encoding session threads | |
| { | |
| // FREAD thread work queue generation | |
| fileReadData currFreadData; | |
| currFreadData.offset = (videoPortion + i) * sizePerVideoPortion; | |
| currFreadData.filePath = szInFilePath; | |
| currFreadData.numFrames = static_cast<uint32_t>(((videoPortion + i + 1) == nNumVideoPortions) ? numFramesLastVideoPortion : numFramesPerVideoPortion); | |
| currFreadData.threadData = &vidEncThreads[i]; | |
| currFreadData.vidPortionNum = videoPortion + i; | |
| currFreadData.vidThreadIdx = i; | |
| currFreadData.ioVideoMem = &ioVideoMem[i]; | |
| currFreadData.isLast = (videoPortion + i + 1 == nNumVideoPortions); // check if last to end thread | |
| currFreadData.isSingleThread = (nThread == 1); | |
| freadQueue[i].push_back(currFreadData); // queue fread work | |
| // video ENCODING thread work queue generation | |
| encodeData currEncData; | |
| currEncData.offset = (videoPortion + i) * sizePerVideoPortion; | |
| currEncData.filePath = szInFilePath; | |
| currEncData.numFrames = static_cast<uint32_t>(((videoPortion + i + 1) == nNumVideoPortions) ? numFramesLastVideoPortion : numFramesPerVideoPortion); | |
| currEncData.threadData = &vidEncThreads[i]; | |
| currEncData.vidPortionNum = videoPortion + i; | |
| currEncData.vidThreadIdx = i; | |
| currEncData.ioVideoMem = &ioVideoMem[i]; | |
| currEncData.isLast = (videoPortion + i + 1 == nNumVideoPortions); // check if last to end thread | |
| currEncData.isSingleThread = (nThread == 1); | |
| encodeQueue[i].push_back(currEncData); // queue encode work | |
| // FWRITE thread work queue generation | |
| fileWriteData currFwriteData; | |
| currFwriteData.vidPortionNum = videoPortion + i; | |
| currFwriteData.fpOut = &fpOut; | |
| currFwriteData.vidThreadIdx = i; | |
| currFwriteData.ioVideoMem = &ioVideoMem[i]; | |
| currFwriteData.isFirst = (videoPortion+i == i); // check if first | |
| currFwriteData.isLast = (videoPortion + i + 1 == nNumVideoPortions); // check if last to end thread | |
| currFwriteData.outPath = szOutFilePath; | |
| currFwriteData.isAV1 = encodeCLIOptions.IsCodecAV1(); | |
| fwriteQueue.push_back(currFwriteData); // queue fwrite work | |
| nFrame += currEncData.numFrames; // increment number of frames | |
| } | |
| videoPortion += nThread; | |
| nTotal += nFrame; | |
| } | |
| // Launch fwite and encoding threads | |
| std::atomic<bool> fwriteWorking(true); | |
| std::thread fwriteThread = std::thread(&asyncFwrite, std::ref(fwriteQueue), std::ref(fwriteWorking)); | |
| std::atomic<bool> encoderWorking(true); | |
| std::atomic<bool> freadWorking(true); | |
| std::vector<std::thread> encodeThread(nThread); | |
| std::vector<std::thread> freadThread(nThread); | |
| for (int i = 0; i < nThread; i++){ | |
| encodeThread[i] = std::thread(&asyncEncode, std::ref(encodeQueue[i]), std::ref(encoderWorking)); | |
| freadThread[i] = std::thread(&asyncFread, std::ref(freadQueue[i]), std::ref(freadWorking)); | |
| } | |
| StopWatch processingTime; | |
| processingTime.Start(); | |
| for (int i = 0; i < nThread; i++){ | |
| freadThread[i].join(); | |
| encodeThread[i].join(); | |
| } | |
| fwriteThread.join(); | |
| double gT = globalTime.Stop(); | |
| double pT = processingTime.Stop(); | |
| std::cout << "Total time = " << gT << " seconds, FPS=" << nTotal / gT << " (#frames=" << nTotal << ")" << std::endl; | |
| std::cout << "Total processing time [fread + H->D memcpy + Encode time + D->H memcpy + fwrite] = " << pT << " seconds, FPS=" << nTotal / pT << " (#frames=" << nTotal << ")" << std::endl; | |
| for (int i = 0; i < nThread; i++) | |
| vidEncThreads[i].encSession->DestroyEncoder(); | |
| ck(cuCtxDestroy(cuContext)); | |
| } | |
| catch (const std::exception &ex) | |
| { | |
| std::cout << ex.what(); | |
| return 1; | |
| } | |
| return 0; | |
| } | |