[x265] [PATCH x265] Cleanup
Aruna Matheswaran
aruna at multicorewareinc.com
Mon May 4 07:47:53 CEST 2020
On Mon, May 4, 2020 at 8:42 AM Kavitha Sampath <kavitha at multicorewareinc.com>
wrote:
> Looks good to me overall. One suggestion - since encoder open is now a
> part of threadMain, can we also move the cliopt parse to threadMain?
>
yes, we shall do that. I'll update and resend the patch.
>
> On Tue, Apr 28, 2020 at 3:23 PM Aruna Matheswaran <
> aruna at multicorewareinc.com> wrote:
>
>> # HG changeset patch
>> # User Aruna Matheswaran <aruna at multicorewareinc.com>
>> # Date 1586956494 -19800
>> # Wed Apr 15 18:44:54 2020 +0530
>> # Node ID 23da64aedc8e5dcbed9ecd6e531f5649e6906c91
>> # Parent 94bfe7f2c0c12616145f8fc1a1762ed55204a0a6
>> Cleanup
>>
>> diff -r 94bfe7f2c0c1 -r 23da64aedc8e source/abrEncApp.cpp
>> --- a/source/abrEncApp.cpp Thu Apr 16 18:48:56 2020 +0530
>> +++ b/source/abrEncApp.cpp Wed Apr 15 18:44:54 2020 +0530
>> @@ -41,62 +41,6 @@
>> b_ctrl_c = 1;
>> }
>>
>> -#define START_CODE 0x00000001
>> -#define START_CODE_BYTES 4
>> -
>> -/* Parse the RPU file and extract the RPU corresponding to the current
>> picture
>> -* and fill the rpu field of the input picture */
>> -static int rpuParser(x265_picture * pic, FILE * ptr)
>> -{
>> - uint8_t byteVal;
>> - uint32_t code = 0;
>> - int bytesRead = 0;
>> - pic->rpu.payloadSize = 0;
>> -
>> - if (!pic->pts)
>> - {
>> - while (bytesRead++ < 4 && fread(&byteVal, sizeof(uint8_t), 1,
>> ptr))
>> - code = (code << 8) | byteVal;
>> -
>> - if (code != START_CODE)
>> - {
>> - x265_log(NULL, X265_LOG_ERROR, "Invalid Dolby Vision RPU
>> startcode in POC %d\n", pic->pts);
>> - return 1;
>> - }
>> - }
>> -
>> - bytesRead = 0;
>> - while (fread(&byteVal, sizeof(uint8_t), 1, ptr))
>> - {
>> - code = (code << 8) | byteVal;
>> - if (bytesRead++ < 3)
>> - continue;
>> - if (bytesRead >= 1024)
>> - {
>> - x265_log(NULL, X265_LOG_ERROR, "Invalid Dolby Vision RPU
>> size in POC %d\n", pic->pts);
>> - return 1;
>> - }
>> -
>> - if (code != START_CODE)
>> - pic->rpu.payload[pic->rpu.payloadSize++] = (code >> (3 * 8))
>> & 0xFF;
>> - else
>> - return 0;
>> - }
>> -
>> - int ShiftBytes = START_CODE_BYTES - (bytesRead -
>> pic->rpu.payloadSize);
>> - int bytesLeft = bytesRead - pic->rpu.payloadSize;
>> - code = (code << ShiftBytes * 8);
>> - for (int i = 0; i < bytesLeft; i++)
>> - {
>> - pic->rpu.payload[pic->rpu.payloadSize++] = (code >> (3 * 8)) &
>> 0xFF;
>> - code = (code << 8);
>> - }
>> - if (!pic->rpu.payloadSize)
>> - x265_log(NULL, X265_LOG_WARNING, "Dolby Vision RPU not found for
>> POC %d\n", pic->pts);
>> - return 0;
>> -}
>> -
>> -
>> namespace X265_NS {
>> // private namespace
>> #define X265_INPUT_QUEUE_SIZE 250
>> @@ -150,8 +94,10 @@
>> m_inputPicBuffer[pass] = X265_MALLOC(x265_picture*,
>> m_queueSize);
>> for (uint32_t idx = 0; idx < m_queueSize; idx++)
>> {
>> - m_inputPicBuffer[pass][idx] = NULL;
>> + m_inputPicBuffer[pass][idx] = x265_picture_alloc();
>> + x265_picture_init(m_passEnc[pass]->m_param,
>> m_inputPicBuffer[pass][idx]);
>> }
>> +
>> m_analysisBuffer[pass] = X265_MALLOC(x265_analysis_data,
>> m_queueSize);
>> m_picIdxReadCnt[pass] = new ThreadSafeInteger[m_queueSize];
>> m_analysisWrite[pass] = new ThreadSafeInteger[m_queueSize];
>> @@ -161,32 +107,25 @@
>> return true;
>> }
>>
>> - void AbrEncoder::closeEncoder()
>> - {
>> - for (uint8_t pidx = 0; pidx < m_numEncodes; pidx++)
>> - {
>> - PassEncoder *passWorker = m_passEnc[pidx];
>> - if (passWorker)
>> - passWorker->close();
>> - }
>> - }
>> -
>> void AbrEncoder::destroy()
>> {
>> - closeEncoder();
>> x265_cleanup(); /* Free library singletons */
>> for (uint8_t pass = 0; pass < m_numEncodes; pass++)
>> {
>> for (uint32_t index = 0; index < m_queueSize; index++)
>> {
>> + X265_FREE(m_inputPicBuffer[pass][index]->planes[0]);
>> x265_picture_free(m_inputPicBuffer[pass][index]);
>> }
>> +
>> X265_FREE(m_inputPicBuffer[pass]);
>> X265_FREE(m_analysisBuffer[pass]);
>> + X265_FREE(m_readFlag[pass]);
>> delete[] m_picIdxReadCnt[pass];
>> delete[] m_analysisWrite[pass];
>> delete[] m_analysisRead[pass];
>> m_passEnc[pass]->destroy();
>> + delete m_passEnc[pass];
>> }
>> X265_FREE(m_inputPicBuffer);
>> X265_FREE(m_analysisBuffer);
>> @@ -211,13 +150,13 @@
>> m_parent = parent;
>> if(!(m_cliopt.enableScaler && m_id))
>> m_input = m_cliopt.input;
>> - m_param = x265_param_alloc();
>> - x265_copy_params(m_param, cliopt.param);
>> + m_param = cliopt.param;
>> m_inputOver = false;
>> m_lastIdx = -1;
>> m_encoder = NULL;
>> m_scaler = NULL;
>> m_reader = NULL;
>> + m_ret = 0;
>> }
>>
>> int PassEncoder::init(int &result)
>> @@ -244,25 +183,6 @@
>> }
>> }
>> }
>> -
>> - if (m_cliopt.zoneFile)
>> - {
>> - if (!m_cliopt.parseZoneFile())
>> - {
>> - x265_log(NULL, X265_LOG_ERROR, "Unable to parse
>> zonefile\n");
>> - fclose(m_cliopt.zoneFile);
>> - m_cliopt.zoneFile = NULL;
>> - }
>> - }
>> -
>> - if (m_param)
>> - m_encoder = m_cliopt.api->encoder_open(m_param);
>> - if (!m_encoder)
>> - {
>> - x265_log(NULL, X265_LOG_ERROR, "x265_encoder_open() failed
>> for Enc, \n");
>> - return -1;
>> - }
>> - m_cliopt.api->encoder_parameters(m_encoder, m_param);
>> return 1;
>> }
>>
>> @@ -272,15 +192,13 @@
>>
>> m_param->confWinBottomOffset = m_param->confWinRightOffset = 0;
>>
>> - m_isAnalysisSave = m_cliopt.saveLevel ? true : false;
>> - m_isAnalysisLoad = m_cliopt.loadLevel ? true : false;
>> m_param->analysisLoadReuseLevel = m_cliopt.loadLevel;
>> m_param->analysisSaveReuseLevel = m_cliopt.saveLevel;
>> - m_param->analysisSave = m_isAnalysisSave ? "save.dat" : NULL;
>> - m_param->analysisLoad = m_isAnalysisLoad ? "load.dat" : NULL;
>> + m_param->analysisSave = m_cliopt.saveLevel ? "save.dat" : NULL;
>> + m_param->analysisLoad = m_cliopt.loadLevel ? "load.dat" : NULL;
>> m_param->bUseAnalysisFile = 0;
>>
>> - if (m_isAnalysisLoad)
>> + if (m_cliopt.loadLevel)
>> {
>> x265_param *refParam =
>> m_parent->m_passEnc[m_cliopt.refId]->m_param;
>>
>> @@ -460,7 +378,7 @@
>> int ipread = m_parent->m_picReadCnt[m_id].get();
>> int ipwrite = m_parent->m_picWriteCnt[m_id].get();
>>
>> - bool isAbrLoad = m_isAnalysisLoad && (m_parent->m_numEncodes >
>> 1);
>> + bool isAbrLoad = m_cliopt.loadLevel && (m_parent->m_numEncodes >
>> 1);
>> while (!m_inputOver && (ipread == ipwrite))
>> {
>> ipwrite =
>> m_parent->m_picWriteCnt[m_id].waitForChange(ipwrite);
>> @@ -561,215 +479,289 @@
>>
>> void PassEncoder::threadMain()
>> {
>> + THREAD_NAME("PassEncoder", m_id);
>> +
>> + while (m_threadActive)
>> + {
>>
>> #if ENABLE_LIBVMAF
>> - x265_vmaf_data* vmafdata = cliopt.vmafData;
>> + x265_vmaf_data* vmafdata = m_cliopt.vmafData;
>> #endif
>> - /* This allows muxers to modify bitstream format */
>> - m_cliopt.output->setParam(m_param);
>> - const x265_api* api = m_cliopt.api;
>> - ReconPlay* reconPlay = NULL;
>> - if (m_cliopt.reconPlayCmd)
>> - reconPlay = new ReconPlay(m_cliopt.reconPlayCmd, *m_param);
>> -
>> - if (signal(SIGINT, sigint_handler) == SIG_ERR)
>> - x265_log(m_param, X265_LOG_ERROR, "Unable to register CTRL+C
>> handler: %s\n", strerror(errno));
>> + /* This allows muxers to modify bitstream format */
>> + m_cliopt.output->setParam(m_param);
>> + const x265_api* api = m_cliopt.api;
>> + ReconPlay* reconPlay = NULL;
>> + if (m_cliopt.reconPlayCmd)
>> + reconPlay = new ReconPlay(m_cliopt.reconPlayCmd,
>> *m_param);
>> + char* profileName = m_cliopt.encName ? m_cliopt.encName :
>> (char *)"x265";
>>
>> - x265_picture pic_orig, pic_out;
>> - x265_picture *pic_in = &pic_orig;
>> - /* Allocate recon picture if analysis save/load is enabled */
>> - std::priority_queue<int64_t>* pts_queue =
>> m_cliopt.output->needPTS() ? new std::priority_queue<int64_t>() : NULL;
>> - x265_picture *pic_recon = (m_cliopt.recon ||
>> m_param->analysisSave || m_param->analysisLoad || pts_queue || reconPlay ||
>> m_param->csvLogLevel) ? &pic_out : NULL;
>> - uint32_t inFrameCount = 0;
>> - uint32_t outFrameCount = 0;
>> - x265_nal *p_nal;
>> - x265_stats stats;
>> - uint32_t nal;
>> - int16_t *errorBuf = NULL;
>> - bool bDolbyVisionRPU = false;
>> - uint8_t *rpuPayload = NULL;
>> - int inputPicNum = 1;
>> - x265_picture picField1, picField2;
>> - x265_analysis_data* analysisInfo =
>> (x265_analysis_data*)(&pic_out.analysisData);
>> - bool isAbrSave = m_isAnalysisSave && (m_parent->m_numEncodes >
>> 1);
>> -
>> - if (!m_param->bRepeatHeaders && !m_param->bEnableSvtHevc)
>> - {
>> - if (api->encoder_headers(m_encoder, &p_nal, &nal) < 0)
>> + if (m_cliopt.zoneFile)
>> {
>> - x265_log(m_param, X265_LOG_ERROR, "Failure generating
>> stream headers %d\n", m_id);
>> - goto fail;
>> - }
>> - else
>> - m_cliopt.totalbytes +=
>> m_cliopt.output->writeHeaders(p_nal, nal);
>> - }
>> -
>> - if (m_param->bField && m_param->interlaceMode)
>> - {
>> - api->picture_init(m_param, &picField1);
>> - api->picture_init(m_param, &picField2);
>> - // return back the original height of input
>> - m_param->sourceHeight *= 2;
>> - api->picture_init(m_param, &pic_orig);
>> - }
>> - else
>> - api->picture_init(m_param, &pic_orig);
>> -
>> - if (m_param->dolbyProfile && m_cliopt.dolbyVisionRpu)
>> - {
>> - rpuPayload = X265_MALLOC(uint8_t, 1024);
>> - pic_in->rpu.payload = rpuPayload;
>> - if (pic_in->rpu.payload)
>> - bDolbyVisionRPU = true;
>> - }
>> -
>> - if (m_cliopt.bDither)
>> - {
>> - errorBuf = X265_MALLOC(int16_t, m_param->sourceWidth + 1);
>> - if (errorBuf)
>> - memset(errorBuf, 0, (m_param->sourceWidth + 1) *
>> sizeof(int16_t));
>> - else
>> - m_cliopt.bDither = false;
>> - }
>> -
>> - // main encoder loop
>> - while (pic_in && !b_ctrl_c)
>> - {
>> - pic_orig.poc = (m_param->bField && m_param->interlaceMode) ?
>> inFrameCount * 2 : inFrameCount;
>> - if (m_cliopt.qpfile)
>> - {
>> - if (!m_cliopt.parseQPFile(pic_orig))
>> + if (!m_cliopt.parseZoneFile())
>> {
>> - x265_log(NULL, X265_LOG_ERROR, "can't parse qpfile
>> for frame %d\n", pic_in->poc);
>> - fclose(m_cliopt.qpfile);
>> - m_cliopt.qpfile = NULL;
>> + x265_log(NULL, X265_LOG_ERROR, "Unable to parse
>> zonefile in %s\n", profileName);
>> + fclose(m_cliopt.zoneFile);
>> + m_cliopt.zoneFile = NULL;
>> }
>> }
>>
>> - if (m_cliopt.framesToBeEncoded && inFrameCount >=
>> m_cliopt.framesToBeEncoded)
>> + /* note: we could try to acquire a different libx265 API
>> here based on
>> + * the profile found during option parsing, but it must be
>> done before
>> + * opening an encoder */
>> +
>> + m_encoder = api->encoder_open(m_param);
>> + if (!m_encoder)
>> {
>> - pic_in = NULL;
>> + x265_log(NULL, X265_LOG_ERROR, "failed to open encoder
>> in %s\n", profileName);
>> + api->param_free(m_param);
>> + m_ret = 2;
>> + break;
>> }
>> - else if (readPicture(pic_in))
>> - inFrameCount++;
>> - else
>> - pic_in = NULL;
>> +
>> + /* get the encoder parameters post-initialization */
>> + api->encoder_parameters(m_encoder, m_param);
>> +
>> + if (signal(SIGINT, sigint_handler) == SIG_ERR)
>> + x265_log(m_param, X265_LOG_ERROR, "Unable to register
>> CTRL+C handler: %s in %s\n",
>> + strerror(errno), profileName);
>>
>> - if (pic_in)
>> + x265_picture pic_orig, pic_out;
>> + x265_picture *pic_in = &pic_orig;
>> + /* Allocate recon picture if analysis save/load is enabled */
>> + std::priority_queue<int64_t>* pts_queue =
>> m_cliopt.output->needPTS() ? new std::priority_queue<int64_t>() : NULL;
>> + x265_picture *pic_recon = (m_cliopt.recon ||
>> m_param->analysisSave || m_param->analysisLoad || pts_queue || reconPlay ||
>> m_param->csvLogLevel) ? &pic_out : NULL;
>> + uint32_t inFrameCount = 0;
>> + uint32_t outFrameCount = 0;
>> + x265_nal *p_nal;
>> + x265_stats stats;
>> + uint32_t nal;
>> + int16_t *errorBuf = NULL;
>> + bool bDolbyVisionRPU = false;
>> + uint8_t *rpuPayload = NULL;
>> + int inputPicNum = 1;
>> + x265_picture picField1, picField2;
>> + x265_analysis_data* analysisInfo =
>> (x265_analysis_data*)(&pic_out.analysisData);
>> + bool isAbrSave = m_cliopt.saveLevel &&
>> (m_parent->m_numEncodes > 1);
>> +
>> + if (!m_param->bRepeatHeaders && !m_param->bEnableSvtHevc)
>> {
>> - if (pic_in->bitDepth > m_param->internalBitDepth &&
>> m_cliopt.bDither)
>> + if (api->encoder_headers(m_encoder, &p_nal, &nal) < 0)
>> {
>> - x265_dither_image(pic_in,
>> m_cliopt.input->getWidth(), m_cliopt.input->getHeight(), errorBuf,
>> m_param->internalBitDepth);
>> - pic_in->bitDepth = m_param->internalBitDepth;
>> + x265_log(m_param, X265_LOG_ERROR, "Failure
>> generating stream headers in %s\n", profileName);
>> + m_ret = 3;
>> + goto fail;
>> }
>> - /* Overwrite PTS */
>> - pic_in->pts = pic_in->poc;
>> + else
>> + m_cliopt.totalbytes +=
>> m_cliopt.output->writeHeaders(p_nal, nal);
>> + }
>> +
>> + if (m_param->bField && m_param->interlaceMode)
>> + {
>> + api->picture_init(m_param, &picField1);
>> + api->picture_init(m_param, &picField2);
>> + // return back the original height of input
>> + m_param->sourceHeight *= 2;
>> + api->picture_init(m_param, &pic_orig);
>> + }
>> + else
>> + api->picture_init(m_param, &pic_orig);
>>
>> - // convert to field
>> - if (m_param->bField && m_param->interlaceMode)
>> + if (m_param->dolbyProfile && m_cliopt.dolbyVisionRpu)
>> + {
>> + rpuPayload = X265_MALLOC(uint8_t, 1024);
>> + pic_in->rpu.payload = rpuPayload;
>> + if (pic_in->rpu.payload)
>> + bDolbyVisionRPU = true;
>> + }
>> +
>> + if (m_cliopt.bDither)
>> + {
>> + errorBuf = X265_MALLOC(int16_t, m_param->sourceWidth +
>> 1);
>> + if (errorBuf)
>> + memset(errorBuf, 0, (m_param->sourceWidth + 1) *
>> sizeof(int16_t));
>> + else
>> + m_cliopt.bDither = false;
>> + }
>> +
>> + // main encoder loop
>> + while (pic_in && !b_ctrl_c)
>> + {
>> + pic_orig.poc = (m_param->bField &&
>> m_param->interlaceMode) ? inFrameCount * 2 : inFrameCount;
>> + if (m_cliopt.qpfile)
>> {
>> - int height = pic_in->height >> 1;
>> -
>> - int static bCreated = 0;
>> - if (bCreated == 0)
>> + if (!m_cliopt.parseQPFile(pic_orig))
>> {
>> - bCreated = 1;
>> - inputPicNum = 2;
>> - picField1.fieldNum = 1;
>> - picField2.fieldNum = 2;
>> + x265_log(NULL, X265_LOG_ERROR, "can't parse
>> qpfile for frame %d in %s\n",
>> + pic_in->poc, profileName);
>> + fclose(m_cliopt.qpfile);
>> + m_cliopt.qpfile = NULL;
>> + }
>> + }
>> +
>> + if (m_cliopt.framesToBeEncoded && inFrameCount >=
>> m_cliopt.framesToBeEncoded)
>> + pic_in = NULL;
>> + else if (readPicture(pic_in))
>> + inFrameCount++;
>> + else
>> + pic_in = NULL;
>>
>> - picField1.bitDepth = picField2.bitDepth =
>> pic_in->bitDepth;
>> - picField1.colorSpace = picField2.colorSpace =
>> pic_in->colorSpace;
>> - picField1.height = picField2.height =
>> pic_in->height >> 1;
>> - picField1.framesize = picField2.framesize =
>> pic_in->framesize >> 1;
>> + if (pic_in)
>> + {
>> + if (pic_in->bitDepth > m_param->internalBitDepth &&
>> m_cliopt.bDither)
>> + {
>> + x265_dither_image(pic_in,
>> m_cliopt.input->getWidth(), m_cliopt.input->getHeight(), errorBuf,
>> m_param->internalBitDepth);
>> + pic_in->bitDepth = m_param->internalBitDepth;
>> + }
>> + /* Overwrite PTS */
>> + pic_in->pts = pic_in->poc;
>> +
>> + // convert to field
>> + if (m_param->bField && m_param->interlaceMode)
>> + {
>> + int height = pic_in->height >> 1;
>>
>> - size_t fieldFrameSize =
>> (size_t)pic_in->framesize >> 1;
>> - char* field1Buf = X265_MALLOC(char,
>> fieldFrameSize);
>> - char* field2Buf = X265_MALLOC(char,
>> fieldFrameSize);
>> + int static bCreated = 0;
>> + if (bCreated == 0)
>> + {
>> + bCreated = 1;
>> + inputPicNum = 2;
>> + picField1.fieldNum = 1;
>> + picField2.fieldNum = 2;
>> +
>> + picField1.bitDepth = picField2.bitDepth =
>> pic_in->bitDepth;
>> + picField1.colorSpace = picField2.colorSpace
>> = pic_in->colorSpace;
>> + picField1.height = picField2.height =
>> pic_in->height >> 1;
>> + picField1.framesize = picField2.framesize =
>> pic_in->framesize >> 1;
>> +
>> + size_t fieldFrameSize =
>> (size_t)pic_in->framesize >> 1;
>> + char* field1Buf = X265_MALLOC(char,
>> fieldFrameSize);
>> + char* field2Buf = X265_MALLOC(char,
>> fieldFrameSize);
>>
>> - int stride = picField1.stride[0] =
>> picField2.stride[0] = pic_in->stride[0];
>> - uint64_t framesize = stride * (height >>
>> x265_cli_csps[pic_in->colorSpace].height[0]);
>> - picField1.planes[0] = field1Buf;
>> - picField2.planes[0] = field2Buf;
>> - for (int i = 1; i <
>> x265_cli_csps[pic_in->colorSpace].planes; i++)
>> + int stride = picField1.stride[0] =
>> picField2.stride[0] = pic_in->stride[0];
>> + uint64_t framesize = stride * (height >>
>> x265_cli_csps[pic_in->colorSpace].height[0]);
>> + picField1.planes[0] = field1Buf;
>> + picField2.planes[0] = field2Buf;
>> + for (int i = 1; i <
>> x265_cli_csps[pic_in->colorSpace].planes; i++)
>> + {
>> + picField1.planes[i] = field1Buf +
>> framesize;
>> + picField2.planes[i] = field2Buf +
>> framesize;
>> +
>> + stride = picField1.stride[i] =
>> picField2.stride[i] = pic_in->stride[i];
>> + framesize += (stride * (height >>
>> x265_cli_csps[pic_in->colorSpace].height[i]));
>> + }
>> + assert(framesize == picField1.framesize);
>> + }
>> +
>> + picField1.pts = picField1.poc = pic_in->poc;
>> + picField2.pts = picField2.poc = pic_in->poc + 1;
>> +
>> + picField1.userSEI = picField2.userSEI =
>> pic_in->userSEI;
>> +
>> + //if (pic_in->userData)
>> + //{
>> + // // Have to handle userData here
>> + //}
>> +
>> + if (pic_in->framesize)
>> {
>> - picField1.planes[i] = field1Buf + framesize;
>> - picField2.planes[i] = field2Buf + framesize;
>> + for (int i = 0; i <
>> x265_cli_csps[pic_in->colorSpace].planes; i++)
>> + {
>> + char* srcP1 = (char*)pic_in->planes[i];
>> + char* srcP2 = (char*)pic_in->planes[i] +
>> pic_in->stride[i];
>> + char* p1 = (char*)picField1.planes[i];
>> + char* p2 = (char*)picField2.planes[i];
>> +
>> + int stride = picField1.stride[i];
>>
>> - stride = picField1.stride[i] =
>> picField2.stride[i] = pic_in->stride[i];
>> - framesize += (stride * (height >>
>> x265_cli_csps[pic_in->colorSpace].height[i]));
>> + for (int y = 0; y < (height >>
>> x265_cli_csps[pic_in->colorSpace].height[i]); y++)
>> + {
>> + memcpy(p1, srcP1, stride);
>> + memcpy(p2, srcP2, stride);
>> + srcP1 += 2 * stride;
>> + srcP2 += 2 * stride;
>> + p1 += stride;
>> + p2 += stride;
>> + }
>> + }
>> }
>> - assert(framesize == picField1.framesize);
>> }
>>
>> - picField1.pts = picField1.poc = pic_in->poc;
>> - picField2.pts = picField2.poc = pic_in->poc + 1;
>> -
>> - picField1.userSEI = picField2.userSEI =
>> pic_in->userSEI;
>> -
>> - if (pic_in->framesize)
>> + if (bDolbyVisionRPU)
>> {
>> - for (int i = 0; i <
>> x265_cli_csps[pic_in->colorSpace].planes; i++)
>> + if (m_param->bField && m_param->interlaceMode)
>> {
>> - char* srcP1 = (char*)pic_in->planes[i];
>> - char* srcP2 = (char*)pic_in->planes[i] +
>> pic_in->stride[i];
>> - char* p1 = (char*)picField1.planes[i];
>> - char* p2 = (char*)picField2.planes[i];
>> -
>> - int stride = picField1.stride[i];
>> -
>> - for (int y = 0; y < (height >>
>> x265_cli_csps[pic_in->colorSpace].height[i]); y++)
>> - {
>> - memcpy(p1, srcP1, stride);
>> - memcpy(p2, srcP2, stride);
>> - srcP1 += 2 * stride;
>> - srcP2 += 2 * stride;
>> - p1 += stride;
>> - p2 += stride;
>> - }
>> + if (m_cliopt.rpuParser(&picField1) > 0)
>> + goto fail;
>> + if (m_cliopt.rpuParser(&picField2) > 0)
>> + goto fail;
>> + }
>> + else
>> + {
>> + if (m_cliopt.rpuParser(pic_in) > 0)
>> + goto fail;
>> }
>> }
>> }
>>
>> - if (bDolbyVisionRPU)
>> + for (int inputNum = 0; inputNum < inputPicNum;
>> inputNum++)
>> {
>> - if (m_param->bField && m_param->interlaceMode)
>> + x265_picture *picInput = NULL;
>> + if (inputPicNum == 2)
>> + picInput = pic_in ? (inputNum ? &picField2 :
>> &picField1) : NULL;
>> + else
>> + picInput = pic_in;
>> +
>> + int numEncoded = api->encoder_encode(m_encoder,
>> &p_nal, &nal, picInput, pic_recon);
>> +
>> + int idx = (inFrameCount - 1) % m_parent->m_queueSize;
>> + m_parent->m_picIdxReadCnt[m_id][idx].incr();
>> + m_parent->m_picReadCnt[m_id].incr();
>> + if (m_cliopt.loadLevel && picInput)
>> + {
>> +
>> m_parent->m_analysisReadCnt[m_cliopt.refId].incr();
>> +
>> m_parent->m_analysisRead[m_cliopt.refId][m_lastIdx].incr();
>> + }
>> +
>> + if (numEncoded < 0)
>> {
>> - if (rpuParser(&picField1,
>> m_cliopt.dolbyVisionRpu) > 0)
>> - goto fail;
>> - if (rpuParser(&picField2,
>> m_cliopt.dolbyVisionRpu) > 0)
>> - goto fail;
>> + b_ctrl_c = 1;
>> + m_ret = 4;
>> + break;
>> + }
>> +
>> + if (reconPlay && numEncoded)
>> + reconPlay->writePicture(*pic_recon);
>> +
>> + outFrameCount += numEncoded;
>> +
>> + if (isAbrSave && numEncoded)
>> + {
>> + copyInfo(analysisInfo);
>> }
>> - else
>> +
>> + if (numEncoded && pic_recon && m_cliopt.recon)
>> + m_cliopt.recon->writePicture(pic_out);
>> + if (nal)
>> {
>> - if (rpuParser(pic_in, m_cliopt.dolbyVisionRpu) >
>> 0)
>> - goto fail;
>> + m_cliopt.totalbytes +=
>> m_cliopt.output->writeFrame(p_nal, nal, pic_out);
>> + if (pts_queue)
>> + {
>> + pts_queue->push(-pic_out.pts);
>> + if (pts_queue->size() > 2)
>> + pts_queue->pop();
>> + }
>> }
>> + m_cliopt.printStatus(outFrameCount);
>> }
>> }
>>
>> - for (int inputNum = 0; inputNum < inputPicNum; inputNum++)
>> + /* Flush the encoder */
>> + while (!b_ctrl_c)
>> {
>> - x265_picture *picInput = NULL;
>> - if (inputPicNum == 2)
>> - picInput = pic_in ? (inputNum ? &picField2 :
>> &picField1) : NULL;
>> - else
>> - picInput = pic_in;
>> -
>> - int numEncoded = api->encoder_encode(m_encoder, &p_nal,
>> &nal, picInput, pic_recon);
>> -
>> - int idx = (inFrameCount - 1) % m_parent->m_queueSize;
>> - m_parent->m_picIdxReadCnt[m_id][idx].incr();
>> - m_parent->m_picReadCnt[m_id].incr();
>> - if (m_cliopt.loadLevel && picInput)
>> - {
>> - m_parent->m_analysisReadCnt[m_cliopt.refId].incr();
>> -
>> m_parent->m_analysisRead[m_cliopt.refId][m_lastIdx].incr();
>> - }
>> -
>> + int numEncoded = api->encoder_encode(m_encoder, &p_nal,
>> &nal, NULL, pic_recon);
>> if (numEncoded < 0)
>> {
>> - b_ctrl_c = 1;
>> + m_ret = 4;
>> break;
>> }
>>
>> @@ -777,7 +769,6 @@
>> reconPlay->writePicture(*pic_recon);
>>
>> outFrameCount += numEncoded;
>> -
>> if (isAbrSave && numEncoded)
>> {
>> copyInfo(analysisInfo);
>> @@ -795,106 +786,77 @@
>> pts_queue->pop();
>> }
>> }
>> +
>> m_cliopt.printStatus(outFrameCount);
>> - }
>> - }
>>
>> - /* Flush the encoder */
>> - while (!b_ctrl_c)
>> - {
>> - int numEncoded = api->encoder_encode(m_encoder, &p_nal,
>> &nal, NULL, pic_recon);
>> - if (numEncoded < 0)
>> - break;
>> -
>> - if (reconPlay && numEncoded)
>> - reconPlay->writePicture(*pic_recon);
>> -
>> - outFrameCount += numEncoded;
>> - if (isAbrSave && numEncoded)
>> - {
>> - copyInfo(analysisInfo);
>> + if (!numEncoded)
>> + break;
>> }
>>
>> - if (numEncoded && pic_recon && m_cliopt.recon)
>> - m_cliopt.recon->writePicture(pic_out);
>> - if (nal)
>> + if (bDolbyVisionRPU)
>> {
>> - m_cliopt.totalbytes +=
>> m_cliopt.output->writeFrame(p_nal, nal, pic_out);
>> - if (pts_queue)
>> - {
>> - pts_queue->push(-pic_out.pts);
>> - if (pts_queue->size() > 2)
>> - pts_queue->pop();
>> - }
>> + if (fgetc(m_cliopt.dolbyVisionRpu) != EOF)
>> + x265_log(NULL, X265_LOG_WARNING, "Dolby Vision RPU
>> count is greater than frame count in %s\n",
>> + profileName);
>> + x265_log(NULL, X265_LOG_INFO, "VES muxing with Dolby
>> Vision RPU file successful in %s\n",
>> + profileName);
>> }
>>
>> - m_cliopt.printStatus(outFrameCount);
>> -
>> - if (!numEncoded)
>> - break;
>> - }
>> + /* clear progress report */
>> + if (m_cliopt.bProgress)
>> + fprintf(stderr, "%*s\r", 80, " ");
>>
>> - if (bDolbyVisionRPU)
>> - {
>> - if (fgetc(m_cliopt.dolbyVisionRpu) != EOF)
>> - x265_log(NULL, X265_LOG_WARNING, "Dolby Vision RPU count
>> is greater than frame count\n");
>> - x265_log(NULL, X265_LOG_INFO, "VES muxing with Dolby Vision
>> RPU file successful\n");
>> - }
>> + fail:
>> +
>> + delete reconPlay;
>>
>> - if (bDolbyVisionRPU)
>> - {
>> - if (fgetc(m_cliopt.dolbyVisionRpu) != EOF)
>> - x265_log(NULL, X265_LOG_WARNING, "Dolby Vision RPU count
>> is greater than frame count\n");
>> - x265_log(NULL, X265_LOG_INFO, "VES muxing with Dolby Vision
>> RPU file successful\n");
>> - }
>> -
>> - /* clear progress report */
>> - if (m_cliopt.bProgress)
>> - fprintf(stderr, "%*s\r", 80, " ");
>> -
>> - fail:
>> -
>> - delete reconPlay;
>> + api->encoder_get_stats(m_encoder, &stats, sizeof(stats));
>> + if (m_param->csvfn && !b_ctrl_c)
>> +#if ENABLE_LIBVMAF
>> + api->vmaf_encoder_log(m_encoder, m_cliopt.argCount,
>> m_cliopt.argString, m_cliopt.param, vmafdata);
>> +#else
>> + api->encoder_log(m_encoder, m_cliopt.argCnt,
>> m_cliopt.argString);
>> +#endif
>> + api->encoder_close(m_encoder);
>>
>> - api->encoder_get_stats(m_encoder, &stats, sizeof(stats));
>> - if (m_param->csvfn && !b_ctrl_c)
>> -#if ENABLE_LIBVMAF
>> - api->vmaf_encoder_log(encoder, argc, argv, param, vmafdata);
>> -#else
>> - api->encoder_log(m_encoder, 0, NULL);
>> -#endif
>> -
>> - int64_t second_largest_pts = 0;
>> - int64_t largest_pts = 0;
>> -
>> - m_cliopt.output->closeFile(largest_pts, second_largest_pts);
>> + int64_t second_largest_pts = 0;
>> + int64_t largest_pts = 0;
>> + if (pts_queue && pts_queue->size() >= 2)
>> + {
>> + second_largest_pts = -pts_queue->top();
>> + pts_queue->pop();
>> + largest_pts = -pts_queue->top();
>> + pts_queue->pop();
>> + delete pts_queue;
>> + pts_queue = NULL;
>> + }
>> + m_cliopt.output->closeFile(largest_pts, second_largest_pts);
>>
>> - if (b_ctrl_c)
>> - general_log(m_param, NULL, X265_LOG_INFO, "aborted at input
>> frame %d, output frame %d\n",
>> - m_cliopt.seek + inFrameCount, stats.encodedPictureCount);
>> + if (b_ctrl_c)
>> + general_log(m_param, NULL, X265_LOG_INFO, "aborted at
>> input frame %d, output frame %d in %s\n",
>> + m_cliopt.seek + inFrameCount,
>> stats.encodedPictureCount, profileName);
>>
>> - X265_FREE(errorBuf);
>> - X265_FREE(rpuPayload);
>> + api->param_free(m_param);
>>
>> - m_threadActive = false;
>> - m_parent->m_numActiveEncodes.decr();
>> - }
>> + X265_FREE(errorBuf);
>> + X265_FREE(rpuPayload);
>>
>> - void PassEncoder::close()
>> - {
>> - const x265_api* api = m_cliopt.api;
>> - api->param_free(m_param);
>> - api->encoder_close(m_encoder);
>> + m_threadActive = false;
>> + m_parent->m_numActiveEncodes.decr();
>> + }
>> }
>>
>> void PassEncoder::destroy()
>> {
>> + stop();
>> if (m_reader)
>> {
>> + m_reader->stop();
>> delete m_reader;
>> }
>> else
>> {
>> + m_scaler->stop();
>> m_scaler->destroy();
>> delete m_scaler;
>> }
>> @@ -1107,12 +1069,6 @@
>> read =
>> m_parentEnc->m_parent->m_picIdxReadCnt[m_id][writeIdx].waitForChange(read);
>> }
>>
>> - if (!m_parentEnc->m_parent->m_inputPicBuffer[m_id][writeIdx])
>> - {
>> - m_parentEnc->m_parent->m_inputPicBuffer[m_id][writeIdx]
>> = x265_picture_alloc();
>> - x265_picture_init(m_parentEnc->m_param,
>> m_parentEnc->m_parent->m_inputPicBuffer[m_id][writeIdx]);
>> - }
>> -
>> x265_picture* dest =
>> m_parentEnc->m_parent->m_inputPicBuffer[m_id][writeIdx];
>> if (m_input->readPicture(*src))
>> {
>> diff -r 94bfe7f2c0c1 -r 23da64aedc8e source/abrEncApp.h
>> --- a/source/abrEncApp.h Thu Apr 16 18:48:56 2020 +0530
>> +++ b/source/abrEncApp.h Wed Apr 15 18:44:54 2020 +0530
>> @@ -60,7 +60,6 @@
>>
>> AbrEncoder(CLIOptions cliopt[], uint8_t numEncodes, int& ret);
>> bool allocBuffers();
>> - void closeEncoder();
>> void destroy();
>>
>> };
>> @@ -75,11 +74,6 @@
>> x265_encoder *m_encoder;
>> Reader *m_reader;
>> Scaler *m_scaler;
>> -
>> - bool m_reqScale;
>> - bool m_isScaled;
>> - bool m_isAnalysisSave;
>> - bool m_isAnalysisLoad;
>> bool m_inputOver;
>>
>> int m_threadActive;
>> @@ -98,7 +92,7 @@
>> FILE* m_zoneFile;
>> FILE* m_dolbyVisionRpu;/* File containing Dolby Vision BL RPU
>> metadata */
>>
>> -
>> + int m_ret;
>>
>> PassEncoder(uint32_t id, CLIOptions cliopt, AbrEncoder *parent);
>> int init(int &result);
>> @@ -108,7 +102,6 @@
>> void copyInfo(x265_analysis_data *src);
>>
>> bool readPicture(x265_picture*);
>> - void close();
>> void destroy();
>>
>> private:
>> diff -r 94bfe7f2c0c1 -r 23da64aedc8e source/x265.cpp
>> --- a/source/x265.cpp Thu Apr 16 18:48:56 2020 +0530
>> +++ b/source/x265.cpp Wed Apr 15 18:44:54 2020 +0530
>> @@ -29,11 +29,6 @@
>> #include "x265cli.h"
>> #include "abrEncApp.h"
>>
>> -#include "input/input.h"
>> -#include "output/output.h"
>> -#include "output/reconplay.h"
>> -#include "svt.h"
>> -
>> #if HAVE_VLD
>> /* Visual Leak Detector */
>> #include <vld.h>
>> @@ -50,16 +45,12 @@
>>
>> using namespace X265_NS;
>>
>> +#define X265_HEAD_ENTRIES 3
>> +
>> #ifdef _WIN32
>> #define strdup _strdup
>> #endif
>>
>> -/* Ctrl-C handler */
>> -static volatile sig_atomic_t b_ctrl_c /* = 0 */;
>> -
>> -#define START_CODE 0x00000001
>> -#define START_CODE_BYTES 4
>> -
>> #ifdef _WIN32
>> /* Copy of x264 code, which allows for Unicode characters in the command
>> line.
>> * Retrieve command line arguments as UTF-8. */
>> @@ -97,7 +88,7 @@
>> * Returns true if abr-config file is present. Returns
>> * false otherwise */
>>
>> -static bool IsAbrLadder(int argc, char **argv, FILE **abrConfig)
>> +static bool checkAbrLadder(int argc, char **argv, FILE **abrConfig)
>> {
>> for (optind = 0;;)
>> {
>> @@ -156,20 +147,10 @@
>> return numEncodes;
>> }
>>
>> -#define X265_HEAD_ENTRIES 3
>> -
>> -static bool parseAbrConfig(FILE* abrConfig, CLIOptions cliopt[])
>> +static bool parseAbrConfig(FILE* abrConfig, CLIOptions cliopt[], uint8_t
>> numEncodes)
>> {
>> char line[1024];
>> char* argLine;
>> - uint32_t numEncodes = 0;
>> -
>> - while (fgets(line, sizeof(line), abrConfig))
>> - {
>> - if (!((*line == '#') || (strcmp(line, "\r\n") == 0)))
>> - numEncodes++;
>> - }
>> - rewind(abrConfig);
>>
>> for (uint32_t i = 0; i < numEncodes; i++)
>> {
>> @@ -182,10 +163,10 @@
>> argLine = line;
>> char* start = strchr(argLine, ' ');
>> while (isspace((unsigned char)*start)) start++;
>> - int argCount = 0;
>> - char **args = (char**)malloc(256 * sizeof(char *));
>> + int argc = 0;
>> + char **argv = (char**)malloc(256 * sizeof(char *));
>> // Adding a dummy string to avoid file parsing error
>> - args[argCount++] = (char *)"x265";
>> + argv[argc++] = (char *)"x265";
>>
>> /* Parse CLI header to identify the ID of the load encode
>> and the reuse level */
>> char *header = strtok(argLine, "[]");
>> @@ -215,11 +196,11 @@
>> char* token = strtok(start, " ");
>> while (token)
>> {
>> - args[argCount++] = token;
>> + argv[argc++] = token;
>> token = strtok(NULL, " ");
>> }
>> - args[argCount] = NULL;
>> - if (cliopt[i].parse(argCount, args))
>> + argv[argc++] = NULL;
>> + if (cliopt[i].parse(argc++, argv))
>> {
>> cliopt[i].destroy();
>> if (cliopt[i].api)
>> @@ -291,7 +272,7 @@
>>
>> uint8_t numEncodes = 1;
>> FILE *abrConfig = NULL;
>> - bool isAbrLadder = IsAbrLadder(argc, argv, &abrConfig);
>> + bool isAbrLadder = checkAbrLadder(argc, argv, &abrConfig);
>>
>> if (isAbrLadder)
>> numEncodes = getNumAbrEncodes(abrConfig);
>> @@ -300,12 +281,12 @@
>>
>> if (isAbrLadder)
>> {
>> - if(!parseAbrConfig(abrConfig, cliopt))
>> + if (!parseAbrConfig(abrConfig, cliopt, numEncodes))
>> exit(1);
>> - if(!setRefContext(cliopt, numEncodes))
>> + if (!setRefContext(cliopt, numEncodes))
>> exit(1);
>> }
>> - else if(cliopt[0].parse(argc, argv))
>> + else if (cliopt[0].parse(argc, argv))
>> {
>> cliopt[0].destroy();
>> if (cliopt[0].api)
>> @@ -320,12 +301,27 @@
>> while (threadsActive)
>> {
>> threadsActive =
>> abrEnc->m_numActiveEncodes.waitForChange(threadsActive);
>> + for (uint8_t idx = 0; idx < numEncodes; idx++)
>> + {
>> + if (abrEnc->m_passEnc[idx]->m_ret)
>> + {
>> + if (isAbrLadder)
>> + x265_log(NULL, X265_LOG_INFO, "Error generating
>> ABR-ladder \n");
>> + ret = abrEnc->m_passEnc[idx]->m_ret;
>> + threadsActive = 0;
>> + break;
>> + }
>> + }
>> }
>>
>> abrEnc->destroy();
>> + delete abrEnc;
>> +
>> for (uint8_t idx = 0; idx < numEncodes; idx++)
>> cliopt[idx].destroy();
>>
>> + delete[] cliopt;
>> +
>> SetConsoleTitle(orgConsoleTitle);
>> SetThreadExecutionState(ES_CONTINUOUS);
>>
>> diff -r 94bfe7f2c0c1 -r 23da64aedc8e source/x265cli.cpp
>> --- a/source/x265cli.cpp Thu Apr 16 18:48:56 2020 +0530
>> +++ b/source/x265cli.cpp Wed Apr 15 18:44:54 2020 +0530
>> @@ -27,6 +27,9 @@
>>
>> #include "x265cli.h"
>>
>> +#define START_CODE 0x00000001
>> +#define START_CODE_BYTES 4
>> +
>> #ifdef __cplusplus
>> namespace X265_NS {
>> #endif
>> @@ -532,6 +535,8 @@
>> const char *tune = NULL;
>> const char *profile = NULL;
>> int svtEnabled = 0;
>> + argCnt = argc;
>> + argString = argv;
>>
>> if (argc <= 1)
>> {
>> @@ -992,6 +997,58 @@
>> return 1;
>> }
>>
>> + /* Parse the RPU file and extract the RPU corresponding to the
>> current picture
>> + * and fill the rpu field of the input picture */
>> + int CLIOptions::rpuParser(x265_picture * pic)
>> + {
>> + uint8_t byteVal;
>> + uint32_t code = 0;
>> + int bytesRead = 0;
>> + pic->rpu.payloadSize = 0;
>> +
>> + if (!pic->pts)
>> + {
>> + while (bytesRead++ < 4 && fread(&byteVal, sizeof(uint8_t),
>> 1, dolbyVisionRpu))
>> + code = (code << 8) | byteVal;
>> +
>> + if (code != START_CODE)
>> + {
>> + x265_log(NULL, X265_LOG_ERROR, "Invalid Dolby Vision RPU
>> startcode in POC %d\n", pic->pts);
>> + return 1;
>> + }
>> + }
>> +
>> + bytesRead = 0;
>> + while (fread(&byteVal, sizeof(uint8_t), 1, dolbyVisionRpu))
>> + {
>> + code = (code << 8) | byteVal;
>> + if (bytesRead++ < 3)
>> + continue;
>> + if (bytesRead >= 1024)
>> + {
>> + x265_log(NULL, X265_LOG_ERROR, "Invalid Dolby Vision RPU
>> size in POC %d\n", pic->pts);
>> + return 1;
>> + }
>> +
>> + if (code != START_CODE)
>> + pic->rpu.payload[pic->rpu.payloadSize++] = (code >> (3 *
>> 8)) & 0xFF;
>> + else
>> + return 0;
>> + }
>> +
>> + int ShiftBytes = START_CODE_BYTES - (bytesRead -
>> pic->rpu.payloadSize);
>> + int bytesLeft = bytesRead - pic->rpu.payloadSize;
>> + code = (code << ShiftBytes * 8);
>> + for (int i = 0; i < bytesLeft; i++)
>> + {
>> + pic->rpu.payload[pic->rpu.payloadSize++] = (code >> (3 * 8))
>> & 0xFF;
>> + code = (code << 8);
>> + }
>> + if (!pic->rpu.payloadSize)
>> + x265_log(NULL, X265_LOG_WARNING, "Dolby Vision RPU not found
>> for POC %d\n", pic->pts);
>> + return 0;
>> + }
>> +
>> #ifdef __cplusplus
>> }
>> #endif
>> \ No newline at end of file
>> diff -r 94bfe7f2c0c1 -r 23da64aedc8e source/x265cli.h
>> --- a/source/x265cli.h Thu Apr 16 18:48:56 2020 +0530
>> +++ b/source/x265cli.h Wed Apr 15 18:44:54 2020 +0530
>> @@ -378,7 +378,7 @@
>> { 0, 0, 0, 0 },
>> { 0, 0, 0, 0 },
>> { 0, 0, 0, 0 }
>> - };
>> +};
>>
>> struct CLIOptions
>> {
>> @@ -401,6 +401,9 @@
>> int64_t startTime;
>> int64_t prevUpdateTime;
>>
>> + int argCnt;
>> + char** argString;
>> +
>> /* ABR ladder settings */
>> bool enableScaler;
>> char* encName;
>> @@ -411,7 +414,6 @@
>> uint32_t saveLevel;
>> uint32_t numRefs;
>>
>> -
>> /* in microseconds */
>> static const int UPDATE_INTERVAL = 250000;
>> CLIOptions()
>> @@ -434,11 +436,14 @@
>> prevUpdateTime = 0;
>> bDither = false;
>> enableScaler = false;
>> + encName = NULL;
>> + reuseName = NULL;
>> encId = 0;
>> refId = -1;
>> loadLevel = 0;
>> saveLevel = 0;
>> numRefs = 0;
>> + argCnt = 0;
>> }
>>
>> void destroy();
>> @@ -447,6 +452,7 @@
>> bool parseZoneParam(int argc, char **argv, x265_param*
>> globalParam, int zonefileCount);
>> bool parseQPFile(x265_picture &pic_org);
>> bool parseZoneFile();
>> + int rpuParser(x265_picture * pic);
>> };
>> #ifdef __cplusplus
>> }
>> _______________________________________________
>> x265-devel mailing list
>> x265-devel at videolan.org
>> https://mailman.videolan.org/listinfo/x265-devel
>>
>
>
> --
> Regards,
> Kavitha
> _______________________________________________
> x265-devel mailing list
> x265-devel at videolan.org
> https://mailman.videolan.org/listinfo/x265-devel
>
--
Regards,
*Aruna Matheswaran,*
Video Codec Engineer,
Media & AI analytics BU,
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.videolan.org/pipermail/x265-devel/attachments/20200504/02d24dda/attachment-0001.html>
More information about the x265-devel
mailing list