static int read_page_first_pass (OGGZ * ap_oggz, const ogg_page * ap_og, long a_serialno, void * ap_user_data) { int rc = OGGZ_CONTINUE; oggdmux_prc_t * p_prc = ap_user_data; assert (p_prc); assert (ap_oggz); if (oggz_get_bos (ap_oggz, a_serialno) > 0) { TIZ_TRACE (handleOf (p_prc), "serialno = [%d]", a_serialno); if (!oggz_table_insert ( p_prc->p_tracks_, a_serialno, &read_page_first_pass)) /* NULL makes it barf, needs * something */ { TIZ_ERROR (handleOf (p_prc), "serialno = [%d] - " "Could not insert serialno in oggz table", a_serialno); rc = OGGZ_STOP_ERR; } } if (oggz_get_bos (ap_oggz, ALL_OGG_STREAMS) == 0) { TIZ_TRACE (handleOf (p_prc), "Number of tracks [%d]", oggz_get_numtracks (ap_oggz)); return OGGZ_STOP_OK; } return rc; }
static OMX_ERRORTYPE httpr_mp3port_SetParameter (const void *ap_obj, OMX_HANDLETYPE ap_hdl, OMX_INDEXTYPE a_index, OMX_PTR ap_struct) { httpr_mp3port_t *p_obj = (httpr_mp3port_t *)ap_obj; OMX_ERRORTYPE rc = OMX_ErrorNone; TIZ_TRACE (ap_hdl, "[%s]...", tiz_idx_to_str (a_index)); assert (NULL != p_obj); if (OMX_TizoniaIndexParamIcecastMountpoint == a_index) { memcpy (&(p_obj->mountpoint_), ap_struct, sizeof(OMX_TIZONIA_ICECASTMOUNTPOINTTYPE)); p_obj->mountpoint_.cStationName[OMX_MAX_STRINGNAME_SIZE - 1] = '\000'; p_obj->mountpoint_.cStationDescription[OMX_MAX_STRINGNAME_SIZE - 1] = '\000'; p_obj->mountpoint_.cStationGenre[OMX_MAX_STRINGNAME_SIZE - 1] = '\000'; p_obj->mountpoint_.cStationUrl[OMX_MAX_STRINGNAME_SIZE - 1] = '\000'; TIZ_TRACE (ap_hdl, "Station Name [%s]...", p_obj->mountpoint_.cStationName); } else { /* Try the parent's indexes */ rc = super_SetParameter (typeOf (ap_obj, "httprmp3port"), ap_obj, ap_hdl, a_index, ap_struct); } return rc; }
static bool claim_input_buffer (mp3d_prc_t * ap_prc) { bool rc = false; assert (ap_prc); if (!ap_prc->in_port_disabled_) { if (OMX_ErrorNone == tiz_krn_claim_buffer (tiz_get_krn (handleOf (ap_prc)), 0, 0, &ap_prc->p_inhdr_)) { if (ap_prc->p_inhdr_) { TIZ_TRACE (handleOf (ap_prc), "Claimed INPUT HEADER [%p]...nFilledLen [%d] " "OUTPUT HEADER [%p]...nFilledLen [%d]", ap_prc->p_inhdr_, ap_prc->p_inhdr_->nFilledLen, ap_prc->p_outhdr_, ap_prc->p_outhdr_ ? ap_prc->p_outhdr_->nFilledLen : 0); rc = true; } else { TIZ_TRACE (handleOf (ap_prc), "No INPUT headers available"); } } } return rc; }
static bool claim_output_buffer (mp3d_prc_t * ap_prc) { bool rc = false; assert (ap_prc); if (!ap_prc->out_port_disabled_) { if (OMX_ErrorNone == tiz_krn_claim_buffer (tiz_get_krn (handleOf (ap_prc)), 1, 0, &ap_prc->p_outhdr_)) { if (ap_prc->p_outhdr_) { TIZ_TRACE (handleOf (ap_prc), "Claimed OUTPUT HEADER [%p] BUFFER [%p] " "nFilledLen [%d]...", ap_prc->p_outhdr_, ap_prc->p_outhdr_->pBuffer, ap_prc->p_outhdr_->nFilledLen); rc = true; } else { TIZ_TRACE (handleOf (ap_prc), "No OUTPUT headers available"); } } } return rc; }
static void buffer_emptied (OMX_BUFFERHEADERTYPE * ap_hdr, void * ap_arg) { httpr_prc_t * p_prc = ap_arg; assert (p_prc); assert (ap_hdr); assert (p_prc->p_inhdr_ == ap_hdr); assert (ap_hdr->nFilledLen == 0); ap_hdr->nOffset = 0; TIZ_TRACE (handleOf (p_prc), "HEADER [%p]", ap_hdr); if ((ap_hdr->nFlags & OMX_BUFFERFLAG_EOS) != 0) { TIZ_TRACE (handleOf (p_prc), "OMX_BUFFERFLAG_EOS in HEADER [%p]", ap_hdr); tiz_srv_issue_event ((OMX_PTR) p_prc, OMX_EventBufferFlag, ARATELIA_HTTP_RENDERER_PORT_INDEX, ap_hdr->nFlags, NULL); } tiz_krn_release_buffer (tiz_get_krn (handleOf (p_prc)), ARATELIA_HTTP_RENDERER_PORT_INDEX, ap_hdr); p_prc->p_inhdr_ = NULL; }
static OMX_ERRORTYPE mp3d_proc_prepare_to_transfer (void * ap_obj, OMX_U32 a_pid) { mp3d_prc_t * p_prc = ap_obj; OMX_AUDIO_PARAM_MP3TYPE mp3type; assert (p_prc); /* NOTE: init the decoder here, as it might have been de-inited in a transition Exe->Idle */ init_mad_decoder (ap_obj); TIZ_INIT_OMX_PORT_STRUCT (mp3type, ARATELIA_MP3_DECODER_INPUT_PORT_INDEX); tiz_check_omx (tiz_api_GetParameter (tiz_get_krn (handleOf (p_prc)), handleOf (p_prc), OMX_IndexParamAudioMp3, &mp3type)); TIZ_INIT_OMX_PORT_STRUCT (p_prc->pcmmode_, ARATELIA_MP3_DECODER_OUTPUT_PORT_INDEX); tiz_check_omx (tiz_api_GetParameter (tiz_get_krn (handleOf (p_prc)), handleOf (p_prc), OMX_IndexParamAudioPcm, &(p_prc->pcmmode_))); TIZ_TRACE (handleOf (p_prc), "sample rate decoder = [%d] channels decoder = [%d]", mp3type.nSampleRate, mp3type.nChannels); TIZ_TRACE (handleOf (p_prc), "sample rate renderer = [%d] channels renderer = [%d]", p_prc->pcmmode_.nSamplingRate, p_prc->pcmmode_.nChannels); reset_stream_parameters (ap_obj); return OMX_ErrorNone; }
static int read_packet (OGGZ * ap_oggz, oggz_packet * ap_zp, long serialno, void * ap_user_data, const OMX_U32 a_pid) { oggdmux_prc_t * p_prc = ap_user_data; OMX_U32 op_offset = 0; bool * p_eos = NULL; ogg_packet * p_op = NULL; int rc = OGGZ_CONTINUE; assert (ap_oggz); assert (ap_zp); assert (p_prc); assert (a_pid <= ARATELIA_OGG_DEMUXER_VIDEO_PORT_BASE_INDEX); p_op = &(ap_zp->op); p_eos = get_eos_ptr (p_prc, a_pid); TIZ_TRACE (handleOf (p_prc), "%010lu: pid [%d] reading bytes [%d]", serialno, a_pid, p_op->bytes); #ifdef _DEBUG if (a_pid == ARATELIA_OGG_DEMUXER_AUDIO_PORT_BASE_INDEX) { g_total_read += p_op->bytes; g_last_read = p_op->bytes; } #endif if (oggz_get_eos (ap_oggz, serialno) == 1) { TIZ_TRACE (handleOf (p_prc), "%010lu: This is EOS\n", serialno); *p_eos = true; } /* Try to empty the ogg packet out to an omx buffer */ op_offset = flush_ogg_packet (p_prc, a_pid, p_op->packet, p_op->bytes); if (0 == op_offset) { if (*p_eos || !get_header (p_prc, a_pid) || (*get_store_offset_ptr (p_prc, a_pid)) > 0) { rc = OGGZ_STOP_OK; } else { rc = OGGZ_CONTINUE; } } else /* (op_offset != 0) */ { rc = OGGZ_STOP_ERR; } TIZ_TRACE (handleOf (p_prc), "%010lu: rc [%d] op_offset [%d]", serialno, rc, op_offset); return rc; }
static void obtain_audio_encoding_from_headers (scloud_prc_t * ap_prc, const char * ap_header, const size_t a_size) { assert (ap_prc); assert (ap_header); { const char * p_end = ap_header + a_size; const char * p_value = (const char *) memchr (ap_header, ':', a_size); char name[64]; if (p_value && (size_t) (p_value - ap_header) < sizeof (name)) { memcpy (name, ap_header, p_value - ap_header); name[p_value - ap_header] = 0; /* skip the colon */ ++p_value; /* strip the value */ while (p_value < p_end && !is_valid_character (*p_value)) { ++p_value; } while (p_end > p_value && !is_valid_character (p_end[-1])) { --p_end; } { char * p_info = tiz_mem_calloc (1, (p_end - p_value) + 1); memcpy (p_info, p_value, p_end - p_value); p_info[(p_end - p_value)] = '\0'; TIZ_TRACE (handleOf (ap_prc), "header name : [%s]", name); TIZ_TRACE (handleOf (ap_prc), "header value : [%s]", p_info); if (strncasecmp (name, "Content-Type", 12) == 0) { obtain_coding_type (ap_prc, p_info); /* Now set the new coding type value on the output port */ (void) set_audio_coding_on_port (ap_prc); } else if (strncasecmp (name, "Content-Length", 14) == 0) { obtain_content_length (ap_prc, p_info); } tiz_mem_free (p_info); } } } }
static OMX_ERRORTYPE release_headers (const void * ap_obj, OMX_U32 a_pid) { mp3d_prc_t * p_obj = (mp3d_prc_t *) ap_obj; assert (ap_obj); if (OMX_ALL == a_pid || ARATELIA_MP3_DECODER_INPUT_PORT_INDEX == a_pid) { if (p_obj->p_inhdr_) { if ((p_obj->p_inhdr_->nFlags & OMX_BUFFERFLAG_EOS) != 0) { TIZ_TRACE (handleOf (ap_obj), "EOS received"); p_obj->eos_ = true; } p_obj->p_inhdr_->nOffset = 0; tiz_check_omx (tiz_krn_release_buffer ( tiz_get_krn (handleOf (ap_obj)), ARATELIA_MP3_DECODER_INPUT_PORT_INDEX, p_obj->p_inhdr_)); p_obj->p_inhdr_ = NULL; p_obj->remaining_ = 0; } } if (OMX_ALL == a_pid || ARATELIA_MP3_DECODER_OUTPUT_PORT_INDEX == a_pid) { if (p_obj->p_outhdr_) { if (p_obj->eos_) { /* EOS has been received and all the input data has been consumed * already, so its time to propagate the EOS flag */ p_obj->p_outhdr_->nFlags |= OMX_BUFFERFLAG_EOS; p_obj->eos_ = false; } TIZ_TRACE ( handleOf (p_obj), "Releasing output HEADER [%p] nFilledLen [%d] nAllocLen [%d]", p_obj->p_outhdr_, p_obj->p_outhdr_->nFilledLen, p_obj->p_outhdr_->nAllocLen); tiz_check_omx (tiz_krn_release_buffer ( tiz_get_krn (handleOf (ap_obj)), ARATELIA_MP3_DECODER_OUTPUT_PORT_INDEX, p_obj->p_outhdr_)); p_obj->p_outhdr_ = NULL; } } return OMX_ErrorNone; }
static OMX_ERRORTYPE httpr_mp3port_SetConfig (const void *ap_obj, OMX_HANDLETYPE ap_hdl, OMX_INDEXTYPE a_index, OMX_PTR ap_struct) { httpr_mp3port_t *p_obj = (httpr_mp3port_t *)ap_obj; OMX_ERRORTYPE rc = OMX_ErrorNone; TIZ_TRACE (ap_hdl, "[%s]...", tiz_idx_to_str (a_index)); assert (NULL != p_obj); if (OMX_TizoniaIndexConfigIcecastMetadata == a_index) { OMX_TIZONIA_ICECASTMETADATATYPE *p_metadata = (OMX_TIZONIA_ICECASTMETADATATYPE *)ap_struct; OMX_U32 stream_title_len = strnlen ((char *)p_metadata->cStreamTitle, OMX_TIZONIA_MAX_SHOUTCAST_METADATA_SIZE + 1); if (stream_title_len > OMX_TIZONIA_MAX_SHOUTCAST_METADATA_SIZE) { rc = OMX_ErrorBadParameter; } else { TIZ_TRACE (ap_hdl, "stream_title_len [%d] Stream title [%s]...", stream_title_len, p_metadata->cStreamTitle); tiz_mem_free (p_obj->p_stream_title_); p_obj->p_stream_title_ = tiz_mem_calloc (1, stream_title_len + 1); if (NULL != p_obj->p_stream_title_) { strncpy (p_obj->p_stream_title_, (char *)p_metadata->cStreamTitle, stream_title_len); p_obj->p_stream_title_[stream_title_len] = '\000'; } TIZ_TRACE (ap_hdl, "stream_title_len [%d] Stream title [%s]...", stream_title_len, p_obj->p_stream_title_); } } else { /* Delegate to the base port */ rc = super_SetConfig (typeOf (ap_obj, "httprmp3port"), ap_obj, ap_hdl, a_index, ap_struct); } return rc; }
static OMX_ERRORTYPE sdlivr_proc_prepare_to_transfer (void *ap_obj, OMX_U32 a_pid) { sdlivr_prc_t *p_prc = ap_obj; OMX_ERRORTYPE rc = OMX_ErrorNone; OMX_PARAM_PORTDEFINITIONTYPE portdef; TIZ_INIT_OMX_PORT_STRUCT (portdef, ARATELIA_YUV_RENDERER_PORT_INDEX); TIZ_TRACE (handleOf (p_prc), "pid [%d]", a_pid); assert (NULL != p_prc); /* Retrieve port def from port */ if (OMX_ErrorNone != (rc = tiz_api_GetParameter (tiz_get_krn (handleOf (p_prc)), handleOf (p_prc), OMX_IndexParamPortDefinition, &portdef))) { TIZ_ERROR (handleOf (p_prc), "[%s] : retrieving the port definition", tiz_err_to_str (rc)); return rc; } p_prc->vportdef_ = portdef.format.video; TIZ_TRACE (handleOf (p_prc), "nFrameWidth = [%d] nFrameHeight = [%d] ", /* "nStride = [%d] nSliceHeight = [%d] nBitrate = [%d] " */ /* "xFramerate = [%s] eCompressionFormat = [%d] eColorFormat = [%d]", */ p_prc->vportdef_.nFrameWidth, p_prc->vportdef_.nFrameHeight); /* p_prc->vportdef_.nStride, */ /* p_prc->vportdef_.nSliceHeight, */ /* p_prc->vportdef_.nBitrate, */ /* p_prc->vportdef_.xFramerate, */ /* p_prc->vportdef_.eCompressionFormat, */ /* p_prc->vportdef_.eColorFormat); */ SDL_WM_SetCaption ("Tizonia OpenMAX IL YUV renderer", "YUV"); p_prc->p_surface = SDL_SetVideoMode (p_prc->vportdef_.nFrameWidth, p_prc->vportdef_.nFrameHeight, 0, SDL_HWSURFACE | SDL_ASYNCBLIT | SDL_HWACCEL | SDL_RESIZABLE); p_prc->p_overlay = SDL_CreateYUVOverlay (p_prc->vportdef_.nFrameWidth, p_prc->vportdef_.nFrameHeight, SDL_YV12_OVERLAY, p_prc->p_surface); return OMX_ErrorNone; }
static int store_data (oggdmux_prc_t * ap_prc, const OMX_U32 a_pid, const OMX_U8 * ap_data, OMX_U32 a_nbytes) { OMX_U8 ** pp_store = NULL; OMX_U32 * p_offset = NULL; OMX_U32 * p_size = NULL; OMX_U32 nbytes_to_copy = 0; OMX_U32 nbytes_avail = 0; assert (ap_prc); assert (a_pid <= ARATELIA_OGG_DEMUXER_VIDEO_PORT_BASE_INDEX); assert (ap_data); pp_store = get_store_ptr (ap_prc, a_pid); p_size = get_store_size_ptr (ap_prc, a_pid); p_offset = get_store_offset_ptr (ap_prc, a_pid); assert (pp_store && *pp_store); assert (p_size); assert (p_offset); nbytes_avail = *p_size - *p_offset; if (a_nbytes > nbytes_avail) { /* need to re-alloc */ OMX_U8 * p_new_store = NULL; p_new_store = tiz_mem_realloc (*pp_store, *p_offset + a_nbytes); if (p_new_store) { *pp_store = p_new_store; *p_size = *p_offset + a_nbytes; nbytes_avail = *p_size - *p_offset; TIZ_TRACE (handleOf (ap_prc), "pid [%d] : Realloc'd data store " "to new size [%d]", a_pid, *p_size); } } nbytes_to_copy = MIN (nbytes_avail, a_nbytes); memcpy (*pp_store + *p_offset, ap_data, nbytes_to_copy); *p_offset += nbytes_to_copy; TIZ_TRACE (handleOf (ap_prc), "pid [%d]: bytes currently stored [%d]", a_pid, *p_offset); return a_nbytes - nbytes_to_copy; }
static int flush_ogg_packet (oggdmux_prc_t * ap_prc, const OMX_U32 a_pid, const OMX_U8 * ap_ogg_data, const OMX_U32 nbytes) { OMX_BUFFERHEADERTYPE * p_hdr = NULL; OMX_U32 nbytes_remaining = nbytes; OMX_U32 nbytes_copied = 0; OMX_U32 op_offset = 0; while ((p_hdr = get_header (ap_prc, a_pid))) { nbytes_copied = dump_ogg_data (ap_prc, a_pid, ap_ogg_data + op_offset, nbytes_remaining, p_hdr); nbytes_remaining -= nbytes_copied; op_offset += nbytes_copied; #ifdef _DEBUG if (a_pid == ARATELIA_OGG_DEMUXER_AUDIO_PORT_BASE_INDEX) { g_total_released += p_hdr->nFilledLen; OMX_U32 * p_offset = get_store_offset_ptr (ap_prc, a_pid); TIZ_TRACE (handleOf (ap_prc), "total released [%d] " "total read [%d] store [%d] last read [%d] " "remaining [%d] diff [%d]", g_total_released, g_total_read, *p_offset, g_last_read, nbytes_remaining, g_total_read - (g_total_released + nbytes_remaining)); } #endif release_header (ap_prc, a_pid); p_hdr = 0; if (0 == nbytes_remaining) { break; } } if (nbytes_remaining > 0) { /* Need_more_buffers. Temporarily store the data until an omx buffer is * available */ TIZ_TRACE (handleOf (ap_prc), "Need to store [%d] bytes - pid [%d]", nbytes_remaining, a_pid); nbytes_remaining = store_data (ap_prc, a_pid, ap_ogg_data + op_offset, nbytes_remaining); } return nbytes_remaining; }
static bool ivrport_check_tunnel_compat (const void * ap_obj, OMX_PARAM_PORTDEFINITIONTYPE * ap_this_def, OMX_PARAM_PORTDEFINITIONTYPE * ap_other_def) { tiz_port_t * p_obj = (tiz_port_t *) ap_obj; assert (ap_this_def); assert (ap_other_def); if (ap_other_def->eDomain != ap_this_def->eDomain) { TIZ_ERROR ( handleOf (ap_obj), "PORT [%d] : Video domain not found, instead found domain [%d]", p_obj->pid_, ap_other_def->eDomain); return false; } /* TODO : Review these compatibility checks */ TIZ_TRACE (handleOf (ap_obj), "PORT [%d] check_tunnel_compat [OK]", p_obj->pid_); return true; }
static OMX_BUFFERHEADERTYPE * buffer_needed (void * ap_arg) { httpr_prc_t * p_prc = ap_arg; OMX_BUFFERHEADERTYPE * p_hdr = NULL; assert (p_prc); if (!p_prc->port_disabled_) { if (!p_prc->p_inhdr_) { (void) tiz_krn_claim_buffer (tiz_get_krn (handleOf (p_prc)), ARATELIA_HTTP_RENDERER_PORT_INDEX, 0, &p_prc->p_inhdr_); if (p_prc->p_inhdr_) { TIZ_TRACE (handleOf (p_prc), "Claimed HEADER [%p]...nFilledLen [%d]", p_prc->p_inhdr_, p_prc->p_inhdr_->nFilledLen); } } p_hdr = p_prc->p_inhdr_; } /* p_prc->awaiting_buffers_ = p_hdr ? false : true; */ return p_hdr; }
static OMX_ERRORTYPE oggdmux_prc_buffers_ready (const void * ap_obj) { oggdmux_prc_t * p_prc = (oggdmux_prc_t *) ap_obj; OMX_ERRORTYPE rc = OMX_ErrorNone; assert (p_prc); TIZ_TRACE (handleOf (p_prc), "awaiting_buffers [%s] aud eos [%s] " "vid eos [%s]", p_prc->awaiting_buffers_ ? "YES" : "NO", p_prc->aud_eos_ ? "YES" : "NO", p_prc->vid_eos_ ? "YES" : "NO"); if (p_prc->awaiting_buffers_ && (!p_prc->aud_eos_ || !p_prc->vid_eos_)) { /* Make sure we have flushed the temp buffers before reading any more * data from file */ if (flush_stores (p_prc) == 0) { p_prc->awaiting_buffers_ = true; rc = demux_file (p_prc); } } return rc; }
static OMX_ERRORTYPE oggdmux_prc_port_disable (const void * ap_obj, OMX_U32 a_pid) { oggdmux_prc_t * p_prc = (oggdmux_prc_t *) ap_obj; bool * p_port_disabled = NULL; assert (p_prc); assert (a_pid <= ARATELIA_OGG_DEMUXER_VIDEO_PORT_BASE_INDEX); if (OMX_ALL == a_pid) { p_port_disabled = get_port_disabled_ptr ( p_prc, ARATELIA_OGG_DEMUXER_AUDIO_PORT_BASE_INDEX); *p_port_disabled = true; p_port_disabled = get_port_disabled_ptr ( p_prc, ARATELIA_OGG_DEMUXER_VIDEO_PORT_BASE_INDEX); *p_port_disabled = true; } else { p_port_disabled = get_port_disabled_ptr (p_prc, a_pid); *p_port_disabled = true; } /* Release any buffers held */ TIZ_TRACE (handleOf (p_prc), "port_disable"); return release_all_buffers (p_prc, a_pid); }
static size_t read_from_omx_buffer (const mp3d_prc_t * ap_prc, void * ap_dst, size_t bytes, OMX_BUFFERHEADERTYPE * ap_hdr) { size_t to_read = bytes; assert (ap_dst); assert (ap_hdr); if (bytes > 0) { if (ap_hdr->nFilledLen < bytes) { to_read = ap_hdr->nFilledLen; } if (to_read > 0) { memcpy (ap_dst, ap_hdr->pBuffer + ap_hdr->nOffset, to_read); TIZ_TRACE (handleOf (ap_prc), "bytes [%d] to_read [%d] nOffset [%d] nFilledLen [%d] " "nAllocLen [%d]", bytes, to_read, ap_hdr->nOffset, ap_hdr->nFilledLen, ap_hdr->nAllocLen); } ap_hdr->nFilledLen -= to_read; ap_hdr->nOffset += to_read; } return to_read; }
static OMX_ERRORTYPE sdlivr_proc_buffers_ready (const void *ap_obj) { OMX_BUFFERHEADERTYPE *p_hdr = NULL; if (OMX_ErrorNone == tiz_krn_claim_buffer (tiz_get_krn (handleOf (ap_obj)), 0, 0, &p_hdr)) { if (NULL != p_hdr) { tiz_check_omx_err (sdlivr_proc_render_buffer (ap_obj, p_hdr)); if (p_hdr->nFlags & OMX_BUFFERFLAG_EOS) { TIZ_TRACE (handleOf (ap_obj), "OMX_BUFFERFLAG_EOS in HEADER [%p]", p_hdr); tiz_srv_issue_event ((OMX_PTR) ap_obj, OMX_EventBufferFlag, 0, p_hdr->nFlags, NULL); } tiz_check_omx_err (tiz_krn_release_buffer (tiz_get_krn (handleOf (ap_obj)), 0, p_hdr)); } } return OMX_ErrorNone; }
static int mp4_write_cback (void * handle, const void * buffer, int64_t size, int64_t * nout, int64_t maxChunkSize) { TIZ_TRACE(handleOf(gp_prc), ""); return 0; }
OMX_ERRORTYPE tiz_os_init (tiz_os_t ** app_os, const OMX_HANDLETYPE ap_hdl, tiz_soa_t * ap_soa) { tiz_os_t * p_os = NULL; assert (app_os); assert (ap_hdl); TIZ_TRACE (ap_hdl, "Init"); if (NULL == (p_os = (tiz_os_t *) os_calloc (ap_soa, sizeof (tiz_os_t)))) { return OMX_ErrorInsufficientResources; } assert (p_os); if (OMX_ErrorNone != tiz_map_init (&(p_os->p_map), os_map_compare_func, os_map_free_func, NULL)) { os_free (ap_soa, p_os); p_os = NULL; return OMX_ErrorInsufficientResources; } p_os->p_hdl = ap_hdl; p_os->p_soa = ap_soa; *app_os = p_os; return OMX_ErrorNone; }
static OMX_ERRORTYPE sdlivr_prc_buffers_ready (const void * ap_obj) { sdlivr_prc_t * p_prc = (sdlivr_prc_t *) ap_obj; OMX_BUFFERHEADERTYPE * p_hdr = NULL; void * p_krn = tiz_get_krn (handleOf (ap_obj)); assert (p_prc); if (!p_prc->port_disabled_) { tiz_check_omx (tiz_krn_claim_buffer ( p_krn, ARATELIA_YUV_RENDERER_PORT_INDEX, 0, &p_hdr)); while (!p_prc->port_disabled_ && p_hdr) { if (p_hdr) { tiz_check_omx (sdlivr_prc_render_buffer (ap_obj, p_hdr)); if (p_hdr->nFlags & OMX_BUFFERFLAG_EOS) { TIZ_TRACE (handleOf (ap_obj), "OMX_BUFFERFLAG_EOS in HEADER [%p]", p_hdr); tiz_srv_issue_event ((OMX_PTR) ap_obj, OMX_EventBufferFlag, 0, p_hdr->nFlags, NULL); } tiz_check_omx (tiz_krn_release_buffer ( p_krn, ARATELIA_YUV_RENDERER_PORT_INDEX, p_hdr)); tiz_check_omx (tiz_krn_claim_buffer ( p_krn, ARATELIA_YUV_RENDERER_PORT_INDEX, 0, &p_hdr)); } } } return OMX_ErrorNone; }
static OMX_U32 dump_ogg_data (oggdmux_prc_t * ap_prc, const OMX_U32 a_pid, const OMX_U8 * ap_ogg_data, const OMX_U32 a_nbytes, OMX_BUFFERHEADERTYPE * ap_hdr) { OMX_U32 nbytes_copied = 0; OMX_U32 nbytes_avail = 0; assert (ap_prc); assert (a_pid <= ARATELIA_OGG_DEMUXER_VIDEO_PORT_BASE_INDEX); assert (ap_ogg_data); assert (ap_hdr); assert (ap_hdr->nAllocLen >= ap_hdr->nFilledLen); nbytes_avail = ap_hdr->nAllocLen - ap_hdr->nFilledLen; nbytes_copied = MIN (a_nbytes, nbytes_avail); if (nbytes_copied > 0) { memcpy (ap_hdr->pBuffer + ap_hdr->nFilledLen, ap_ogg_data, nbytes_copied); ap_hdr->nFilledLen += nbytes_copied; } TIZ_TRACE (handleOf (ap_prc), "HEADER [%p] pid [%d] nbytes [%d] " "nbytes_copied [%d] nFilledLen [%d]", ap_hdr, a_pid, a_nbytes, nbytes_copied, ap_hdr->nFilledLen); return nbytes_copied; }
static OMX_BUFFERHEADERTYPE * get_header (oggdmux_prc_t * ap_prc, const OMX_U32 a_pid) { OMX_BUFFERHEADERTYPE * p_hdr = NULL; bool port_disabled = *(get_port_disabled_ptr (ap_prc, a_pid)); if (!port_disabled) { OMX_BUFFERHEADERTYPE ** pp_hdr = get_header_ptr (ap_prc, a_pid); p_hdr = *pp_hdr; if (!p_hdr) { if (OMX_ErrorNone == tiz_krn_claim_buffer (tiz_get_krn (handleOf (ap_prc)), a_pid, 0, pp_hdr)) { p_hdr = *pp_hdr; if (p_hdr) { TIZ_TRACE (handleOf (ap_prc), "Claimed HEADER [%p] pid [%d] nFilledLen [%d]", p_hdr, a_pid, p_hdr->nFilledLen); } } } if (!p_hdr) { ap_prc->awaiting_buffers_ = true; } } return p_hdr; }
static OMX_ERRORTYPE cc_youtube_cfgport_GetParameter (const void * ap_obj, OMX_HANDLETYPE ap_hdl, OMX_INDEXTYPE a_index, OMX_PTR ap_struct) { const cc_youtube_cfgport_t * p_obj = ap_obj; OMX_ERRORTYPE rc = OMX_ErrorNone; assert (p_obj); TIZ_TRACE (ap_hdl, "PORT [%d] GetParameter [%s]...", tiz_port_index (ap_obj), tiz_idx_to_str (a_index)); if (OMX_TizoniaIndexParamAudioYoutubeSession == a_index) { memcpy (ap_struct, &(p_obj->session_), sizeof (OMX_TIZONIA_AUDIO_PARAM_YOUTUBESESSIONTYPE)); } else if (OMX_TizoniaIndexParamAudioYoutubePlaylist == a_index) { memcpy (ap_struct, &(p_obj->playlist_), sizeof (OMX_TIZONIA_AUDIO_PARAM_YOUTUBEPLAYLISTTYPE)); } else { /* Delegate to the base port */ rc = super_GetParameter (typeOf (ap_obj, "cc_youtubecfgport"), ap_obj, ap_hdl, a_index, ap_struct); } return rc; }
static OMX_ERRORTYPE os_register_type (tiz_os_t * ap_os, const tiz_os_type_init_f a_type_init_f, const char * a_type_name, const OMX_S32 a_type_id) { OMX_ERRORTYPE rc = OMX_ErrorInsufficientResources; void * p_obj = NULL; assert (ap_os); assert (ap_os->p_map); assert (a_type_init_f); assert (a_type_name); assert (strnlen (a_type_name, OMX_MAX_STRINGNAME_SIZE) < OMX_MAX_STRINGNAME_SIZE); assert (a_type_id >= 0); /* Call the type init function */ p_obj = a_type_init_f (ap_os, ap_os->p_hdl); if (p_obj) { /* Register the class or object type */ TIZ_TRACE (ap_os->p_hdl, "Registering type #[%d] : [%s] -> [%p] " "nameOf [%s]", a_type_id, a_type_name, p_obj, nameOf (p_obj)); rc = tiz_map_insert (ap_os->p_map, os_strndup (ap_os->p_soa, a_type_name, OMX_MAX_STRINGNAME_SIZE), p_obj, (OMX_U32 *) (&a_type_id)); } /* print_types (ap_os); */ return rc; }
static OMX_ERRORTYPE pausetoidle_tunneled_ports_status_update (void *ap_obj) { tiz_state_t *p_base = (tiz_state_t *) ap_obj; assert (NULL != ap_obj); { OMX_HANDLETYPE p_hdl = handleOf(p_base->p_fsm_); void *p_krn = tiz_get_krn (p_hdl); if (TIZ_KRN_MAY_INIT_EXE_TO_IDLE (p_krn)) { /* OK, at this point all the tunneled non-supplier neighboring ports are ready to receive ETB/FTB calls. NOTE: This will call the * 'tiz_state_state_set' function of the tiz_state_t base class (note * we are passing 'tizidle' as 1st parameter */ TIZ_TRACE (p_hdl, "kernel may initiate pause to idle"); return tiz_state_super_state_set (typeOf (ap_obj, "tizidle"), ap_obj, p_hdl, OMX_CommandStateSet, OMX_StateIdle, NULL); } } return OMX_ErrorNone; }
static OMX_ERRORTYPE pausetoidle_trans_complete (const void *ap_obj, OMX_PTR ap_servant, OMX_STATETYPE a_new_state) { const tiz_state_t *p_base = (const tiz_state_t *) ap_obj; TIZ_TRACE (handleOf (ap_obj), "Trans complete to state [%s]...", tiz_fsm_state_to_str (a_new_state)); assert (OMX_StateIdle == a_new_state); assert (NULL != ap_obj); assert (NULL != ap_servant); assert (OMX_StateIdle == a_new_state); if (2 == p_base->servants_count_ + 1) { /* Reset the OMX_TIZONIA_PORTSTATUS_AWAITBUFFERSRETURN flag in all ports where this has been set */ tiz_krn_reset_tunneled_ports_status (tiz_get_krn (handleOf(ap_servant)), OMX_TIZONIA_PORTSTATUS_AWAITBUFFERSRETURN); } return tiz_state_super_trans_complete (typeOf (ap_obj, "tizpausetoidle"), ap_obj, ap_servant, a_new_state); }
static OMX_ERRORTYPE httpr_mp3port_GetParameter (const void *ap_obj, OMX_HANDLETYPE ap_hdl, OMX_INDEXTYPE a_index, OMX_PTR ap_struct) { const httpr_mp3port_t *p_obj = ap_obj; OMX_ERRORTYPE rc = OMX_ErrorNone; TIZ_TRACE (ap_hdl, "[%s]...", tiz_idx_to_str (a_index)); assert (NULL != p_obj); if (OMX_TizoniaIndexParamIcecastMountpoint == a_index) { memcpy (ap_struct, &(p_obj->mountpoint_), sizeof(OMX_TIZONIA_ICECASTMOUNTPOINTTYPE)); } else { /* Delegate to the base port */ rc = super_GetParameter (typeOf (ap_obj, "httprmp3port"), ap_obj, ap_hdl, a_index, ap_struct); } return rc; }
static int convert_str_to_int (scloud_prc_t * ap_prc, const char * ap_start, char ** ap_end) { long val = -1; assert (ap_prc); assert (ap_start); assert (ap_end); errno = 0; val = strtol (ap_start, ap_end, 0); if ((errno == ERANGE && (val == LONG_MAX || val == LONG_MIN)) || (errno != 0 && val == 0)) { TIZ_ERROR (handleOf (ap_prc), "Error retrieving the number of channels : [%s]", strerror (errno)); } else if (*ap_end == ap_start) { TIZ_ERROR (handleOf (ap_prc), "Error retrieving the number of channels : " "[No digits were found]"); } TIZ_TRACE (handleOf (ap_prc), "Value : [%d]", val); return val; }