void
omx_component_destroy(omx_component_t *oc)
{
omxchk(OMX_FreeHandle(oc->oc_handle));
free(oc->oc_name);
hts_cond_destroy(&oc->oc_event_cond);
free(oc);
}
static void
decoder_close(struct media_codec *mc)
{
vdec_decoder_t *vdd = mc->opaque;
TRACE(TRACE_DEBUG, "VDEC", "Freeing picture list");
free_picture_list(&vdd->pictures);
vdec_close(vdd->handle);
Lv2Syscall1(349, (uint64_t)vdd->mem);
hts_cond_destroy(&vdd->audone);
hts_cond_destroy(&vdd->seqdone);
hts_mutex_destroy(&vdd->mtx);
prop_ref_dec(vdd->metainfo);
h264_to_annexb_cleanup(&vdd->annexb);
free(vdd);
TRACE(TRACE_DEBUG, "VDEC", "Cell decoder closed");
}
/**
* prop_mutex can be held here, so we need to avoid locking it
*/
void
mp_release(media_pipe_t *mp)
{
if(atomic_dec(&mp->mp_refcount))
return;
event_t *e;
/* Make sure a clean shutdown has been made */
assert(mp->mp_audio_decoder == NULL);
assert(mp != media_primary);
if(media_pipe_fini_extra != NULL)
media_pipe_fini_extra(mp);
while((e = TAILQ_FIRST(&mp->mp_eq)) != NULL) {
TAILQ_REMOVE(&mp->mp_eq, e, e_link);
event_release(e);
}
mq_flush(mp, &mp->mp_audio, 1);
mq_flush(mp, &mp->mp_video, 1);
mq_destroy(&mp->mp_audio);
mq_destroy(&mp->mp_video);
video_overlay_flush_locked(mp, 0);
dvdspu_destroy_all(mp);
hts_cond_destroy(&mp->mp_backpressure);
hts_mutex_destroy(&mp->mp_mutex);
hts_mutex_destroy(&mp->mp_clock_mutex);
hts_mutex_destroy(&mp->mp_overlay_mutex);
pool_destroy(mp->mp_mb_pool);
if(mp->mp_satisfied == 0)
atomic_dec(&media_buffer_hungry);
cancellable_release(mp->mp_cancellable);
/**
* We need to destroy mp_prop_root but there is a risk that prop_mutex
* is held here, so we need to dispatch
*/
task_run(mp_final_release, mp);
}
static void
rpi_codec_close(struct media_codec *mc)
{
rpi_video_codec_t *rvc = mc->opaque;
omx_flush_port(rvc->rvc_decoder, 130);
omx_flush_port(rvc->rvc_decoder, 131);
omx_wait_buffers(rvc->rvc_decoder);
omx_set_state(rvc->rvc_decoder, OMX_StateIdle);
omx_release_buffers(rvc->rvc_decoder, 130);
omx_set_state(rvc->rvc_decoder, OMX_StateLoaded);
omx_component_destroy(rvc->rvc_decoder);
hts_cond_destroy(&rvc->rvc_avail_cond);
free(rvc);
}
static pixmap_t *
rpi_pixmap_decode(pixmap_t *pm, const image_meta_t *im,
char *errbuf, size_t errlen)
{
if(pm->pm_type != PIXMAP_JPEG)
return NULL;
#ifdef TIMING
int64_t ts = showtime_get_ts(), ts2;
#endif
rpi_pixmap_decoder_t *rpd = pixmap_decoder_create(OMX_IMAGE_CodingJPEG);
if(rpd == NULL)
return NULL;
rpd->rpd_im = im;
#ifdef NOCOPY
#error check rpd->rpd_decoder->oc_stream_corrupt
OMX_PARAM_PORTDEFINITIONTYPE portdef;
memset(&portdef, 0, sizeof(portdef));
portdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
portdef.nVersion.nVersion = OMX_VERSION;
portdef.nPortIndex = rpd->rpd_decoder->oc_inport;
omxchk(OMX_GetParameter(rpd->rpd_decoder->oc_handle,
OMX_IndexParamPortDefinition, &portdef));
omx_send_command(rpd->rpd_decoder, OMX_CommandPortEnable,
rpd->rpd_decoder->oc_inport, NULL, 0);
OMX_BUFFERHEADERTYPE *buf;
for(int i = 0; i < portdef.nBufferCountActual; i++) {
omxchk(OMX_UseBuffer(rpd->rpd_decoder->oc_handle, &buf,
rpd->rpd_decoder->oc_inport,
NULL, pm->pm_size, pm->pm_data));
}
// Waits for the OMX_CommandPortEnable command
omx_wait_command(rpd->rpd_decoder);
omx_set_state(rpd->rpd_decoder, OMX_StateExecuting);
CHECKPOINT("Initialized");
buf->nOffset = 0;
buf->nFilledLen = pm->pm_size;
buf->nFlags |= OMX_BUFFERFLAG_EOS;
rpd->rpd_decoder->oc_inflight_buffers++;
omxchk(OMX_EmptyThisBuffer(rpd->rpd_decoder->oc_handle, buf));
hts_mutex_lock(&rpd->rpd_mtx);
while(rpd->rpd_change == 0)
hts_cond_wait(&rpd->rpd_cond, &rpd->rpd_mtx);
hts_mutex_unlock(&rpd->rpd_mtx);
CHECKPOINT("Setup tunnel");
setup_tunnel(rpd);
#else
const void *data = pm->pm_data;
size_t len = pm->pm_size;
hts_mutex_lock(&rpd->rpd_mtx);
while(len > 0) {
OMX_BUFFERHEADERTYPE *buf;
if(rpd->rpd_decoder->oc_stream_corrupt)
break;
if(rpd->rpd_change == 1) {
rpd->rpd_change = 2;
hts_mutex_unlock(&rpd->rpd_mtx);
setup_tunnel(rpd);
hts_mutex_lock(&rpd->rpd_mtx);
continue;
}
if(rpd->rpd_decoder->oc_avail == NULL) {
hts_cond_wait(&rpd->rpd_cond, &rpd->rpd_mtx);
continue;
}
buf = rpd->rpd_decoder->oc_avail;
rpd->rpd_decoder->oc_avail = buf->pAppPrivate;
rpd->rpd_decoder->oc_inflight_buffers++;
hts_mutex_unlock(&rpd->rpd_mtx);
buf->nOffset = 0;
buf->nFilledLen = MIN(len, buf->nAllocLen);
memcpy(buf->pBuffer, data, buf->nFilledLen);
buf->nFlags = 0;
if(len <= buf->nAllocLen)
buf->nFlags |= OMX_BUFFERFLAG_EOS;
data += buf->nFilledLen;
len -= buf->nFilledLen;
omxchk(OMX_EmptyThisBuffer(rpd->rpd_decoder->oc_handle, buf));
hts_mutex_lock(&rpd->rpd_mtx);
}
if(rpd->rpd_decoder->oc_stream_corrupt) {
hts_mutex_unlock(&rpd->rpd_mtx);
goto err;
}
if(rpd->rpd_change != 2) {
while(rpd->rpd_change == 0 && !rpd->rpd_decoder->oc_stream_corrupt)
hts_cond_wait(&rpd->rpd_cond, &rpd->rpd_mtx);
hts_mutex_unlock(&rpd->rpd_mtx);
if(rpd->rpd_decoder->oc_stream_corrupt)
goto err;
setup_tunnel(rpd);
} else {
hts_mutex_unlock(&rpd->rpd_mtx);
}
#endif
omx_wait_fill_buffer(rpd->rpd_resizer, rpd->rpd_buf);
CHECKPOINT("Got buffer");
err:
omx_flush_port(rpd->rpd_decoder, rpd->rpd_decoder->oc_inport);
omx_flush_port(rpd->rpd_decoder, rpd->rpd_decoder->oc_outport);
omx_flush_port(rpd->rpd_resizer, rpd->rpd_resizer->oc_inport);
omx_flush_port(rpd->rpd_resizer, rpd->rpd_resizer->oc_outport);
if(rpd->rpd_tunnel != NULL) {
omx_tunnel_destroy(rpd->rpd_tunnel);
rpd->rpd_tunnel = NULL;
}
omx_set_state(rpd->rpd_decoder, OMX_StateIdle);
omx_set_state(rpd->rpd_resizer, OMX_StateIdle);
if(rpd->rpd_buf != NULL) {
omxchk(OMX_FreeBuffer(rpd->rpd_resizer->oc_handle,
rpd->rpd_resizer->oc_outport, rpd->rpd_buf));
}
omx_release_buffers(rpd->rpd_decoder, rpd->rpd_decoder->oc_inport);
omx_set_state(rpd->rpd_resizer, OMX_StateLoaded);
omx_set_state(rpd->rpd_decoder, OMX_StateLoaded);
omx_component_destroy(rpd->rpd_resizer);
omx_component_destroy(rpd->rpd_decoder);
hts_cond_destroy(&rpd->rpd_cond);
hts_mutex_destroy(&rpd->rpd_mtx);
pixmap_t *out = rpd->rpd_pm;
if(out) {
pixmap_release(pm);
} else {
snprintf(errbuf, errlen, "Load error");
}
free(rpd);
CHECKPOINT("All done");
return out;
}
static int
rpi_codec_create(media_codec_t *mc, const media_codec_params_t *mcp,
media_pipe_t *mp)
{
int fmt;
switch(mc->codec_id) {
case CODEC_ID_H264:
fmt = OMX_VIDEO_CodingAVC;
break;
case CODEC_ID_MPEG2VIDEO:
if(!omx_enable_mpg2)
return 1;
fmt = OMX_VIDEO_CodingMPEG2;
break;
#if 0
case CODEC_ID_VC1:
case CODEC_ID_WMV3:
if(mcp->extradata_size == 0)
return 1;
mc->decode = vc1_pt_decode;
return 0;
#endif
default:
return 1;
}
rpi_video_codec_t *rvc = calloc(1, sizeof(rpi_video_codec_t));
hts_cond_init(&rvc->rvc_avail_cond, &mp->mp_mutex);
omx_component_t *d = omx_component_create("OMX.broadcom.video_decode",
&mp->mp_mutex,
&rvc->rvc_avail_cond);
if(d == NULL) {
hts_cond_destroy(&rvc->rvc_avail_cond);
free(rvc);
return 1;
}
rvc->rvc_decoder = d;
omx_set_state(d, OMX_StateIdle);
OMX_VIDEO_PARAM_PORTFORMATTYPE format;
OMX_INIT_STRUCTURE(format);
format.nPortIndex = 130;
format.eCompressionFormat = fmt;
omxchk(OMX_SetParameter(d->oc_handle,
OMX_IndexParamVideoPortFormat, &format));
OMX_PARAM_BRCMVIDEODECODEERRORCONCEALMENTTYPE ec;
OMX_INIT_STRUCTURE(ec);
ec.bStartWithValidFrame = OMX_FALSE;
omxchk(OMX_SetParameter(d->oc_handle,
OMX_IndexParamBrcmVideoDecodeErrorConcealment, &ec));
OMX_CONFIG_BOOLEANTYPE bt;
OMX_INIT_STRUCTURE(bt);
bt.bEnabled = 1;
omxchk(OMX_SetConfig(d->oc_handle,
OMX_IndexParamBrcmInterpolateMissingTimestamps, &bt));
omx_alloc_buffers(d, 130);
omx_set_state(d, OMX_StateExecuting);
if(mcp->extradata_size) {
hts_mutex_lock(&mp->mp_mutex);
OMX_BUFFERHEADERTYPE *buf = omx_get_buffer_locked(rvc->rvc_decoder);
hts_mutex_unlock(&mp->mp_mutex);
buf->nOffset = 0;
buf->nFilledLen = mcp->extradata_size;
memcpy(buf->pBuffer, mcp->extradata, buf->nFilledLen);
buf->nFlags = OMX_BUFFERFLAG_CODECCONFIG;
omxchk(OMX_EmptyThisBuffer(rvc->rvc_decoder->oc_handle, buf));
}
mc->opaque = rvc;
mc->close = rpi_codec_close;
mc->decode = rpi_codec_decode;
mc->flush = rpi_codec_flush;
return 0;
}
