Lines Matching refs:priv
44 static OMX_ERRORTYPE init_port_structs(vid_enc_PrivateType * priv) {
47 assert(priv);
50 TIZ_INIT_OMX_PORT_STRUCT(priv->in_port_def_,
52 TIZ_INIT_OMX_PORT_STRUCT(priv->out_port_def_,
54 TIZ_INIT_OMX_PORT_STRUCT(priv->bitrate,
56 TIZ_INIT_OMX_PORT_STRUCT(priv->quant,
58 TIZ_INIT_OMX_PORT_STRUCT(priv->profile_level,
62 p_krn = tiz_get_krn(handleOf(priv));
65 tiz_api_GetParameter(p_krn, handleOf(priv),
66 OMX_IndexParamPortDefinition, &(priv->in_port_def_)));
68 tiz_api_GetParameter(p_krn, handleOf(priv),
69 OMX_IndexParamPortDefinition, &(priv->out_port_def_)));
71 tiz_api_GetParameter(p_krn, handleOf(priv),
72 OMX_IndexParamVideoBitrate, &(priv->bitrate)));
74 tiz_api_GetParameter(p_krn, handleOf(priv),
75 OMX_IndexParamVideoQuantization, &(priv->quant)));
77 tiz_api_GetParameter(p_krn, handleOf(priv),
78 OMX_IndexParamVideoProfileLevelCurrent, &(priv->profile_level)));
83 static OMX_BUFFERHEADERTYPE * get_input_buffer(vid_enc_PrivateType * priv) {
84 assert(priv);
86 if (priv->in_port_disabled_) {
90 assert(!priv->p_inhdr_); /* encode_frame expects new buffers every time */
92 tiz_krn_claim_buffer(tiz_get_krn(handleOf(priv)),
94 &priv->p_inhdr_);
95 return priv->p_inhdr_;
98 static OMX_BUFFERHEADERTYPE * get_output_buffer(vid_enc_PrivateType * priv) {
99 assert(priv);
101 if (priv->out_port_disabled_) {
105 if (!priv->p_outhdr_) {
106 tiz_krn_claim_buffer(tiz_get_krn(handleOf(priv)),
108 &priv->p_outhdr_);
110 return priv->p_outhdr_;
113 static OMX_ERRORTYPE h264e_buffer_emptied(vid_enc_PrivateType * priv, OMX_BUFFERHEADERTYPE * p_hdr)
117 assert(priv);
118 assert(priv->p_inhdr_ == p_hdr);
120 if (!priv->out_port_disabled_) {
124 priv->eos_ = true;
127 r = tiz_krn_release_buffer(tiz_get_krn(handleOf(priv)), 0, p_hdr);
128 priv->p_inhdr_ = NULL;
134 static OMX_ERRORTYPE h264e_buffer_filled(vid_enc_PrivateType * priv, OMX_BUFFERHEADERTYPE * p_hdr)
138 assert(priv);
139 assert(priv->p_outhdr_ == p_hdr);
142 if (!priv->in_port_disabled_) {
145 if (priv->eos_) {
148 priv->p_outhdr_->nFlags |= OMX_BUFFERFLAG_EOS;
151 r = tiz_krn_release_buffer(tiz_get_krn(handleOf(priv)),
154 priv->p_outhdr_ = NULL;
161 static void release_input_header(vid_enc_PrivateType * priv) {
162 assert(!priv->in_port_disabled_);
163 if (priv->p_inhdr_) {
164 (void) tiz_krn_release_buffer(tiz_get_krn(handleOf(priv)),
166 priv->p_inhdr_);
168 priv->p_inhdr_ = NULL;
171 static void release_output_header(vid_enc_PrivateType * priv) {
172 if (priv->p_outhdr_) {
173 assert(!priv->out_port_disabled_);
174 (void) tiz_krn_release_buffer(tiz_get_krn(handleOf(priv)),
176 priv->p_outhdr_);
177 priv->p_outhdr_ = NULL;
181 static OMX_ERRORTYPE h264e_release_all_headers(vid_enc_PrivateType * priv)
183 assert(priv);
185 release_input_header(priv);
186 release_output_header(priv);
191 static void reset_stream_parameters(vid_enc_PrivateType * priv)
193 assert(priv);
194 init_port_structs(priv);
195 priv->p_inhdr_ = 0;
196 priv->p_outhdr_ = 0;
197 priv->eos_ = false;
201 static OMX_ERRORTYPE h264e_manage_buffers(vid_enc_PrivateType* priv) {
202 OMX_BUFFERHEADERTYPE * in_buf = priv->p_inhdr_;
203 OMX_BUFFERHEADERTYPE * out_buf = priv->p_outhdr_;
207 vid_enc_BufferEncoded_common(priv, in_buf, out_buf);
216 r = h264e_buffer_emptied(priv, in_buf);
220 if ((out_buf->nFilledLen != 0) || priv->eos_) {
221 r = h264e_buffer_filled(priv, out_buf);
227 static struct encode_task *enc_NeedTask(vid_enc_PrivateType * priv)
229 OMX_VIDEO_PORTDEFINITIONTYPE *def = &priv->in_port_def_.format.video;
231 return enc_NeedTask_common(priv, def);
234 static void enc_ScaleInput(vid_enc_PrivateType * priv, struct pipe_video_buffer **vbuf, unsigned *size)
236 OMX_VIDEO_PORTDEFINITIONTYPE *def = &priv->in_port_def_.format.video;
237 enc_ScaleInput_common(priv, def, vbuf, size);
240 static void enc_HandleTask(vid_enc_PrivateType * priv, struct encode_task *task,
243 unsigned size = priv->out_port_def_.nBufferSize;
248 enc_ScaleInput(priv, &vbuf, &size);
249 priv->s_pipe->flush(priv->s_pipe, NULL, 0);
252 task->bitstream = pipe_buffer_create(priv->s_pipe->screen,
259 if (priv->restricted_b_frames && picture_type == PIPE_H2645_ENC_PICTURE_TYPE_B)
261 enc_ControlPicture_common(priv, &picture);
264 priv->codec->begin_frame(priv->codec, vbuf, &picture.base);
265 priv->codec->encode_bitstream(priv->codec, vbuf, task->bitstream, &task->feedback);
266 priv->codec->end_frame(priv->codec, vbuf, &picture.base);
269 static void enc_ClearBframes(vid_enc_PrivateType * priv, struct input_buf_private *inp)
273 if (list_is_empty(&priv->b_frames))
276 task = list_entry(priv->b_frames.prev, struct encode_task, list);
280 priv->ref_idx_l0 = priv->ref_idx_l1;
281 enc_HandleTask(priv, task, PIPE_H2645_ENC_PICTURE_TYPE_P);
283 priv->ref_idx_l1 = priv->frame_num++;
286 LIST_FOR_EACH_ENTRY(task, &priv->b_frames, list) {
287 enc_HandleTask(priv, task, PIPE_H2645_ENC_PICTURE_TYPE_B);
288 if (!priv->restricted_b_frames)
289 priv->ref_idx_l0 = priv->frame_num;
290 priv->frame_num++;
293 enc_MoveTasks(&priv->b_frames, &inp->tasks);
296 static OMX_ERRORTYPE enc_LoadImage(vid_enc_PrivateType * priv, OMX_BUFFERHEADERTYPE *buf,
299 OMX_VIDEO_PORTDEFINITIONTYPE *def = &priv->in_port_def_.format.video;
300 return enc_LoadImage_common(priv, def, buf, vbuf);
303 static OMX_ERRORTYPE encode_frame(vid_enc_PrivateType * priv, OMX_BUFFERHEADERTYPE * in_buf)
311 enc_MoveTasks(&inp->tasks, &priv->free_tasks);
312 task = enc_NeedTask(priv);
320 enc_ClearBframes(priv, inp);
321 enc_MoveTasks(&priv->stacked_tasks, &inp->tasks);
322 priv->codec->flush(priv->codec);
324 return h264e_manage_buffers(priv);
333 err = enc_LoadImage(priv, in_buf, task->buf);
341 if (!(priv->pic_order_cnt % OMX_VID_ENC_IDR_PERIOD_DEFAULT) ||
342 priv->force_pic_type.IntraRefreshVOP) {
343 enc_ClearBframes(priv, inp);
345 priv->force_pic_type.IntraRefreshVOP = OMX_FALSE;
346 priv->frame_num = 0;
347 } else if (priv->codec->profile == PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE ||
348 !(priv->pic_order_cnt % OMX_VID_ENC_P_PERIOD_DEFAULT) ||
355 task->pic_order_cnt = priv->pic_order_cnt++;
359 list_addtail(&task->list, &priv->b_frames);
362 priv->ref_idx_l0 = priv->ref_idx_l1;
363 enc_HandleTask(priv, task, picture_type);
364 list_addtail(&task->list, &priv->stacked_tasks);
365 LIST_FOR_EACH_ENTRY(task, &priv->stacked_tasks, list) {
368 if (stacked_num == priv->stacked_frames_num) {
370 t = list_entry(priv->stacked_tasks.next, struct encode_task, list);
374 priv->ref_idx_l1 = priv->frame_num++;
377 LIST_FOR_EACH_ENTRY(task, &priv->b_frames, list) {
378 enc_HandleTask(priv, task, PIPE_H2645_ENC_PICTURE_TYPE_B);
379 if (!priv->restricted_b_frames)
380 priv->ref_idx_l0 = priv->frame_num;
381 priv->frame_num++;
384 enc_MoveTasks(&priv->b_frames, &inp->tasks);
388 return h264e_buffer_emptied(priv, in_buf);
390 return h264e_manage_buffers(priv);
396 vid_enc_PrivateType *priv = ap_obj;
399 priv->screen = omx_get_screen();
400 if (!priv->screen)
403 screen = priv->screen->pscreen;
407 priv->s_pipe = pipe_create_multimedia_context(screen);
408 if (!priv->s_pipe)
411 enc_InitCompute_common(priv);
413 if (!vl_compositor_init(&priv->compositor, priv->s_pipe)) {
414 priv->s_pipe->destroy(priv->s_pipe);
415 priv->s_pipe = NULL;
419 if (!vl_compositor_init_state(&priv->cstate, priv->s_pipe)) {
420 vl_compositor_cleanup(&priv->compositor);
421 priv->s_pipe->destroy(priv->s_pipe);
422 priv->s_pipe = NULL;
426 priv->t_pipe = pipe_create_multimedia_context(screen);
427 if (!priv->t_pipe)
430 list_inithead(&priv->free_tasks);
431 list_inithead(&priv->used_tasks);
432 list_inithead(&priv->b_frames);
433 list_inithead(&priv->stacked_tasks);
440 vid_enc_PrivateType *priv = ap_obj;
443 assert (priv);
445 enc_ReleaseTasks(&priv->free_tasks);
446 enc_ReleaseTasks(&priv->used_tasks);
447 enc_ReleaseTasks(&priv->b_frames);
448 enc_ReleaseTasks(&priv->stacked_tasks);
451 if (priv->scale_buffer[i])
452 priv->scale_buffer[i]->destroy(priv->scale_buffer[i]);
454 if (priv->s_pipe) {
455 vl_compositor_cleanup_state(&priv->cstate);
456 vl_compositor_cleanup(&priv->compositor);
457 enc_ReleaseCompute_common(priv);
458 priv->s_pipe->destroy(priv->s_pipe);
461 if (priv->t_pipe)
462 priv->t_pipe->destroy(priv->t_pipe);
464 if (priv->screen)
474 vid_enc_PrivateType *priv = super_ctor(typeOf(ap_obj, "h264eprc"), ap_obj, app);
475 assert (priv);
478 return priv;
480 priv->p_inhdr_ = 0;
481 priv->p_outhdr_ = 0;
482 priv->profile_level.eProfile = OMX_VIDEO_AVCProfileBaseline;
483 priv->profile_level.eLevel = OMX_VIDEO_AVCLevel51;
484 priv->force_pic_type.IntraRefreshVOP = OMX_FALSE;
485 priv->frame_num = 0;
486 priv->pic_order_cnt = 0;
487 priv->restricted_b_frames = debug_get_bool_option("OMX_USE_RESTRICTED_B_FRAMES", FALSE);
488 priv->scale.xWidth = OMX_VID_ENC_SCALING_WIDTH_DEFAULT;
489 priv->scale.xHeight = OMX_VID_ENC_SCALING_WIDTH_DEFAULT;
490 priv->in_port_disabled_ = false;
491 priv->out_port_disabled_ = false;
492 reset_stream_parameters(priv);
494 return priv;
505 vid_enc_PrivateType *priv = ap_obj;
507 assert(priv);
508 if (!priv->screen)
521 vid_enc_PrivateType *priv = ap_obj;
523 assert(priv);
525 init_port_structs(priv);
527 priv->eos_ = false;
531 templat.profile = enc_TranslateOMXProfileToPipe(priv->profile_level.eProfile);
532 templat.level = enc_TranslateOMXLevelToPipe(priv->profile_level.eLevel);
535 templat.width = priv->scale_buffer[priv->current_scale_buffer] ?
536 priv->scale.xWidth : priv->in_port_def_.format.video.nFrameWidth;
537 templat.height = priv->scale_buffer[priv->current_scale_buffer] ?
538 priv->scale.xHeight : priv->in_port_def_.format.video.nFrameHeight;
541 struct pipe_screen *screen = priv->screen->pscreen;
543 priv->stacked_frames_num =
550 priv->stacked_frames_num = 1;
552 priv->codec = priv->s_pipe->create_video_codec(priv->s_pipe, &templat);
564 vid_enc_PrivateType *priv = (vid_enc_PrivateType *) ap_obj;
565 return h264e_release_all_headers(priv);
570 vid_enc_PrivateType *priv = (vid_enc_PrivateType *) ap_obj;
575 assert(priv);
578 while (!priv->eos_ && (out_buf = get_output_buffer(priv)) && (in_buf = get_input_buffer(priv))) {
579 if (!priv->out_port_disabled_) {
580 r = encode_frame(priv, in_buf);
589 vid_enc_PrivateType *priv = (vid_enc_PrivateType *) ap_obj;
591 release_input_header(priv);
592 reset_stream_parameters(priv);
595 release_output_header(priv);
602 vid_enc_PrivateType *priv = (vid_enc_PrivateType *) ap_obj;
603 assert(priv);
606 h264e_release_all_headers(priv);
607 reset_stream_parameters(priv);
608 priv->in_port_disabled_ = true;
611 release_output_header(priv);
612 priv->out_port_disabled_ = true;
619 vid_enc_PrivateType * priv = (vid_enc_PrivateType *) ap_obj;
620 assert(priv);
622 if (priv->in_port_disabled_) {
623 reset_stream_parameters(priv);
624 priv->in_port_disabled_ = false;
628 priv->out_port_disabled_ = false;