static inline int ep_parse_param_assign_intfloat(struct effect_parser *ep,
struct ep_param *param, bool is_float)
{
int code;
bool is_negative = false;
if (!cf_next_valid_token(&ep->cfp))
return PARSE_EOF;
if (cf_token_is(&ep->cfp, "-")) {
is_negative = true;
if (!cf_next_token(&ep->cfp))
return PARSE_EOF;
}
code = cf_token_is_type(&ep->cfp, CFTOKEN_NUM, "numeric value", ";");
if (code != PARSE_SUCCESS)
return code;
if (is_float) {
float f = (float)os_strtod(ep->cfp.cur_token->str.array);
if (is_negative) f = -f;
da_push_back_array(param->default_val, &f, sizeof(float));
} else {
long l = strtol(ep->cfp.cur_token->str.array, NULL, 10);
if (is_negative) l = -l;
da_push_back_array(param->default_val, &l, sizeof(long));
}
return PARSE_SUCCESS;
}
static void load_headers(struct obs_x264 *obsx264)
{
x264_nal_t *nals;
int nal_count;
DARRAY(uint8_t) header;
DARRAY(uint8_t) sei;
da_init(header);
da_init(sei);
x264_encoder_headers(obsx264->context, &nals, &nal_count);
for (int i = 0; i < nal_count; i++) {
x264_nal_t *nal = nals+i;
if (nal->i_type == NAL_SEI)
da_push_back_array(sei, nal->p_payload, nal->i_payload);
else
da_push_back_array(header, nal->p_payload,
nal->i_payload);
}
obsx264->extra_data = header.array;
obsx264->extra_data_size = header.num;
obsx264->sei = sei.array;
obsx264->sei_size = sei.num;
}
static void send_first_video_packet(struct obs_encoder *encoder,
struct encoder_callback *cb, struct encoder_packet *packet)
{
struct encoder_packet first_packet;
DARRAY(uint8_t) data;
uint8_t *sei;
size_t size;
/* always wait for first keyframe */
if (!packet->keyframe)
return;
da_init(data);
if (!get_sei(encoder, &sei, &size)) {
cb->new_packet(cb->param, packet);
cb->sent_first_packet = true;
return;
}
da_push_back_array(data, sei, size);
da_push_back_array(data, packet->data, packet->size);
first_packet = *packet;
first_packet.data = data.array;
first_packet.size = data.num;
cb->new_packet(cb->param, &first_packet);
cb->sent_first_packet = true;
da_free(data);
}
static size_t http_write(uint8_t *ptr, size_t size, size_t nmemb,
struct update_info *info)
{
size_t total = size * nmemb;
if (total)
da_push_back_array(info->file_data, ptr, total);
return total;
}
static inline int ep_parse_param_assign_bool(struct effect_parser *ep,
struct ep_param *param)
{
if (!cf_next_valid_token(&ep->cfp))
return PARSE_EOF;
if (cf_token_is(&ep->cfp, "true")) {
long l = 1;
da_push_back_array(param->default_val, &l, sizeof(long));
return PARSE_SUCCESS;
} else if (cf_token_is(&ep->cfp, "false")) {
long l = 0;
da_push_back_array(param->default_val, &l, sizeof(long));
return PARSE_SUCCESS;
}
cf_adderror_expecting(&ep->cfp, "true or false");
return PARSE_EOF;
}
static void parse_packet(struct obs_qsv *obsqsv, struct encoder_packet *packet, mfxBitstream *pBS, uint32_t fps_num, bool *received_packet)
{
if (pBS == NULL || pBS->DataLength == 0) {
*received_packet = false;
return;
}
da_resize(obsqsv->packet_data, 0);
da_push_back_array(obsqsv->packet_data, &pBS->Data[pBS->DataOffset],
pBS->DataLength);
packet->data = obsqsv->packet_data.array;
packet->size = obsqsv->packet_data.num;
packet->type = OBS_ENCODER_VIDEO;
packet->pts = pBS->TimeStamp * fps_num / 90000;
packet->keyframe = (pBS->FrameType &
(MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF));
//bool iFrame = pBS->FrameType & MFX_FRAMETYPE_I;
//bool bFrame = pBS->FrameType & MFX_FRAMETYPE_B;
bool pFrame = pBS->FrameType & MFX_FRAMETYPE_P;
//int iType = iFrame ? 0 : (bFrame ? 1 : (pFrame ? 2 : -1));
//int64_t interval = obsqsv->params.nbFrames + 1;
// In case MSDK does't support automatic DecodeTimeStamp, do manual
// calculation
if (g_pts2dtsShift >= 0)
{
if (g_bFirst) {
packet->dts = packet->pts - 3 * obsqsv->params.nFpsDen;
} else if (pFrame) {
packet->dts = packet->pts - 10 * obsqsv->params.nFpsDen;
g_prevDts = packet->dts;
} else {
packet->dts = g_prevDts + obsqsv->params.nFpsDen;
g_prevDts = packet->dts;
}
} else {
packet->dts = pBS->DecodeTimeStamp * fps_num / 90000;
}
#if 0
info("parse packet:\n"
"\tFrameType: %d\n"
"\tpts: %d\n"
"\tdts: %d",
iType, packet->pts, packet->dts);
#endif
*received_packet = true;
pBS->DataLength = 0;
g_bFirst = false;
}
static bool do_aac_encode(struct aac_encoder *enc,
struct encoder_packet *packet, bool *received_packet)
{
AVRational time_base = {1, enc->context->sample_rate};
AVPacket avpacket = {0};
int got_packet;
int ret;
enc->aframe->nb_samples = enc->frame_size;
enc->aframe->pts = av_rescale_q(enc->total_samples,
(AVRational){1, enc->context->sample_rate},
enc->context->time_base);
ret = avcodec_fill_audio_frame(enc->aframe, enc->context->channels,
enc->context->sample_fmt, enc->samples[0],
enc->frame_size_bytes * enc->context->channels, 1);
if (ret < 0) {
aac_warn("do_aac_encode", "avcodec_fill_audio_frame failed: %s",
av_err2str(ret));
return false;
}
enc->total_samples += enc->frame_size;
ret = avcodec_encode_audio2(enc->context, &avpacket, enc->aframe,
&got_packet);
if (ret < 0) {
aac_warn("do_aac_encode", "avcodec_encode_audio2 failed: %s",
av_err2str(ret));
return false;
}
*received_packet = !!got_packet;
if (!got_packet)
return true;
da_resize(enc->packet_buffer, 0);
da_push_back_array(enc->packet_buffer, avpacket.data, avpacket.size);
packet->pts = rescale_ts(avpacket.pts, enc->context, time_base);
packet->dts = rescale_ts(avpacket.dts, enc->context, time_base);
packet->data = enc->packet_buffer.array;
packet->size = avpacket.size;
packet->type = OBS_ENCODER_AUDIO;
packet->timebase_num = 1;
packet->timebase_den = (int32_t)enc->context->sample_rate;
av_free_packet(&avpacket);
return true;
}
static void load_headers(struct obs_qsv *obsqsv)
{
DARRAY(uint8_t) header;
uint8_t sei = 0;
// Not sure if SEI is needed.
// Just filling in empty meaningless SEI message.
// Seems to work fine.
// DARRAY(uint8_t) sei;
da_init(header);
// da_init(sei);
uint8_t *pSPS, *pPPS;
uint16_t nSPS, nPPS;
qsv_encoder_headers(obsqsv->context, &pSPS, &pPPS, &nSPS, &nPPS);
da_push_back_array(header, pSPS, nSPS);
da_push_back_array(header, pPPS, nPPS);
obsqsv->extra_data = header.array;
obsqsv->extra_data_size = header.num;
obsqsv->sei = &sei;
obsqsv->sei_size = 1;
}
static void parse_packet(struct obs_qsv *obsqsv, struct encoder_packet *packet, mfxBitstream *pBS, uint32_t fps_num, bool *received_packet)
{
uint8_t *start, *end;
int type;
if (pBS == NULL || pBS->DataLength == 0) {
*received_packet = false;
return;
}
da_resize(obsqsv->packet_data, 0);
da_push_back_array(obsqsv->packet_data, &pBS->Data[pBS->DataOffset],
pBS->DataLength);
packet->data = obsqsv->packet_data.array;
packet->size = obsqsv->packet_data.num;
packet->type = OBS_ENCODER_VIDEO;
packet->pts = pBS->TimeStamp * fps_num / 90000;
packet->keyframe = (pBS->FrameType &
(MFX_FRAMETYPE_I | MFX_FRAMETYPE_REF));
/* ------------------------------------ */
start = obsqsv->packet_data.array;
end = start + obsqsv->packet_data.num;
start = (uint8_t*)obs_avc_find_startcode(start, end);
while (true) {
while (start < end && !*(start++));
if (start == end)
break;
type = start[0] & 0x1F;
if (type == OBS_NAL_SLICE_IDR || type == OBS_NAL_SLICE) {
uint8_t prev_type = (start[0] >> 5) & 0x3;
start[0] &= ~(3 << 5);
if (pBS->FrameType & MFX_FRAMETYPE_I)
start[0] |= OBS_NAL_PRIORITY_HIGHEST << 5;
else if (pBS->FrameType & MFX_FRAMETYPE_P)
start[0] |= OBS_NAL_PRIORITY_HIGH << 5;
else
start[0] |= prev_type << 5;
}
start = (uint8_t*)obs_avc_find_startcode(start, end);
}
static void parse_packet(struct obs_x264 *obsx264,
struct encoder_packet *packet, x264_nal_t *nals,
int nal_count, x264_picture_t *pic_out)
{
if (!nal_count) return;
da_resize(obsx264->packet_data, 0);
for (int i = 0; i < nal_count; i++) {
x264_nal_t *nal = nals+i;
da_push_back_array(obsx264->packet_data, nal->p_payload,
nal->i_payload);
}
packet->data = obsx264->packet_data.array;
packet->size = obsx264->packet_data.num;
packet->type = OBS_ENCODER_VIDEO;
packet->pts = pic_out->i_pts;
packet->dts = pic_out->i_dts;
packet->keyframe = pic_out->b_keyframe != 0;
}
