예제 #1
0
파일: chain.c 프로젝트: Ferdiand/cmyth
cmyth_chain_t
cmyth_chain_create(cmyth_recorder_t rec, char *chain_id)
{
	cmyth_chain_t chain;
	struct event_loop_args *args;

	args = ref_alloc(sizeof(*args));

	chain = ref_alloc(sizeof(*chain));

	chain->chain_id = ref_strdup(chain_id);
	chain->chain_count = 0;
	chain->chain_current = -1;
	chain->chain_list = NULL;
	chain->chain_callback = NULL;
	chain->chain_event = NULL;
	chain->chain_thread = 0;
	chain->chain_conn = ref_hold(rec->rec_conn);

	pthread_mutex_init(&chain->chain_mutex, NULL);
	pthread_cond_init(&chain->chain_cond, NULL);

	ref_set_destroy(chain, (ref_destroy_t)cmyth_chain_destroy);

	args->rec = ref_hold(rec);
	args->chain = ref_hold(chain);

	chain->chain_thread_args = (void*)args;

	pthread_create(&chain->chain_thread, NULL,
		       cmyth_chain_event_loop, (void*)args);

	return chain;
}
예제 #2
0
파일: mysql_query.c 프로젝트: Bladed/xbmc
/**
 * Allocate a dynamic query string to have parameters added to it
 * \param db database connection object
 * \param query_string Query string with ? placemarks for all dynamic
 * 			parameters, this is NOT copied and must therefore
 * 			remain valid for the life of the query.
 */
cmyth_mysql_query_t * 
cmyth_mysql_query_create(cmyth_database_t db, const char * query_string)
{
    cmyth_mysql_query_t * out;
    out = ref_alloc(sizeof(*out));
    if(out != NULL)
    {
	ref_set_destroy(out,query_destroy);
	out->source = out->source_pos = query_string;
	out->source_len = strlen(out->source);
	out->buf_size = out->source_len *2;
	out->buf_used = 0;
	out->db = ref_hold(db);
	out->buf = ref_alloc(out->buf_size);
	if(out->buf == NULL)
	{
	    ref_release(out);
	    out = NULL;
	}
	else
	{
	    out->buf[0] = '\0';
	}

    }
    return out;
}
예제 #3
0
파일: thread.c 프로젝트: def44/mate
void thread_destroy(struct thread *t) {
	if (t != NULL) {
		thread_clear(t);
		vm_stack_destroy(t->vm_stack);
		free(t->ref_buckets);
		ref_set_destroy(t->excluded_set);
#ifdef DMP	
		if (t->dmp != NULL)
			thread_dmp_destroy(t->dmp);
#endif
		heap_free(heap, t);
		free(t->free_buckets);
	}
}
예제 #4
0
cmyth_storagegroup_file_t
cmyth_storagegroup_file_create(void)
{
	cmyth_storagegroup_file_t ret = ref_alloc(sizeof(*ret));
	memset(ret, 0, sizeof(*ret));

	cmyth_dbg(CMYTH_DBG_DEBUG, "%s {\n", __FUNCTION__);
	if (!ret) {
		cmyth_dbg(CMYTH_DBG_DEBUG, "%s }!\n", __FUNCTION__);
		return NULL;
	}
	ref_set_destroy(ret, (ref_destroy_t)cmyth_storagegroup_file_destroy);

	return ret;
}
예제 #5
0
/*
 * cmyth_recordingrule_create()
 *
 * Scope: PRIVATE
 *
 * Description
 *
 * Create a recording schedule structure to be used to hold channel and return
 * a pointer to the structure.
 * Before forgetting the reference to this recording schedule structure the
 * caller must call ref_release().
 *
 * Return Value:
 *
 * Success: A non-NULL cmyth_channel_t (this type is a pointer)
 *
 * Failure: NULL
 */
cmyth_recordingrule_t
cmyth_recordingrule_create(void)
{
	cmyth_recordingrule_t ret = ref_alloc(sizeof(*ret));
	memset(ret, 0, sizeof(*ret));

	cmyth_dbg(CMYTH_DBG_DEBUG, "%s\n", __FUNCTION__);
	if (!ret) {
		cmyth_dbg(CMYTH_DBG_DEBUG, "%s: ref_alloc() failed\n", __FUNCTION__);
		return NULL;
	}
	ref_set_destroy(ret, (ref_destroy_t)cmyth_recordingrule_destroy);

	return ret;
}
예제 #6
0
파일: posmap.c 프로젝트: cgbarnwell/mvpmc
/*
 * cmyth_posmap_create(void)
 * 
 * Scope: PUBLIC
 *
 * Description
 *
 * Allocate and initialize a position map structure.
 *
 * Return Value:
 *
 * Success: A non-NULL cmyth_posmap_t (this type is a pointer)
 *
 * Failure: A NULL cmyth_posmap_t
 */
cmyth_posmap_t
cmyth_posmap_create(void)
{
	cmyth_posmap_t ret = ref_alloc(sizeof(*ret));

	cmyth_dbg(CMYTH_DBG_DEBUG, "%s\n", __FUNCTION__);
	if (!ret) {
		return NULL;
	}
	ref_set_destroy(ret, (ref_destroy_t)cmyth_posmap_destroy);

	ret->posmap_count = 0;
	ret->posmap_list = NULL;
	return ret;
}
예제 #7
0
파일: rec_num.c 프로젝트: cgbarnwell/mvpmc
/*
 * cmyth_rec_num_create(void)
 * 
 * Scope: PUBLIC
 *
 * Description
 *
 * Create a recorder number structure.
 *
 * Return Value:
 *
 * Success: A non-NULL cmyth_rec_num_t (this type is a pointer)
 *
 * Failure: A NULL cmyth_rec_num_t
 */
cmyth_rec_num_t
cmyth_rec_num_create(void)
{
	cmyth_rec_num_t ret = ref_alloc(sizeof(*ret));

	cmyth_dbg(CMYTH_DBG_DEBUG, "%s\n", __FUNCTION__);
	if (!ret) {
		return NULL;
	}
	ref_set_destroy(ret, (ref_destroy_t)cmyth_rec_num_destroy);

	ret->recnum_host = NULL;
	ret->recnum_port = 0;
	ret->recnum_id = 0;
	return ret;
}
예제 #8
0
cmyth_commbreaklist_t
cmyth_commbreaklist_create(void)
{
	cmyth_commbreaklist_t ret;

	cmyth_dbg(CMYTH_DBG_DEBUG, "%s\n", __FUNCTION__);
	ret = ref_alloc(sizeof(*ret));
	if (!ret) {
		return(NULL);
	}
	ref_set_destroy(ret, (ref_destroy_t)cmyth_commbreaklist_destroy);

	ret->commbreak_list = NULL;
	ret->commbreak_count = 0;
	return ret;
}
예제 #9
0
/*
 * cmyth_proglist_create()
 *
 * Scope: PUBLIC
 *
 * Description
 *
 * Create a timestamp structure and return a pointer to the structure.
 *
 * Return Value:
 *
 * Success: A non-NULL cmyth_proglist_t (this type is a pointer)
 *
 * Failure: A NULL cmyth_proglist_t
 */
cmyth_proglist_t
cmyth_proglist_create(void)
{
    cmyth_proglist_t ret;

    cmyth_dbg(CMYTH_DBG_DEBUG, "%s\n", __FUNCTION__);
    ret = ref_alloc(sizeof(*ret));
    if (!ret) {
        return(NULL);
    }
    ref_set_destroy(ret, (ref_destroy_t)cmyth_proglist_destroy);

    ret->proglist_list = NULL;
    ret->proglist_count = 0;
    pthread_mutex_init(&ret->proglist_mutex, NULL);
    return ret;
}
예제 #10
0
cmyth_commbreak_t
cmyth_commbreak_create(void)
{
	cmyth_commbreak_t ret = ref_alloc(sizeof(*ret));

	cmyth_dbg(CMYTH_DBG_DEBUG, "%s {\n", __FUNCTION__);
	if (!ret) {
		cmyth_dbg(CMYTH_DBG_DEBUG, "%s }!\n", __FUNCTION__);
		return NULL;
	}
	ref_set_destroy(ret, (ref_destroy_t)cmyth_commbreak_destroy);

	ret->start_mark = 0;
	ret->start_offset = 0;
	ret->end_mark = 0;
	ret->end_offset = 0;

	cmyth_dbg(CMYTH_DBG_DEBUG, "%s }\n", __FUNCTION__);
	return ret;
}
예제 #11
0
파일: livetv.c 프로젝트: Castlecard/plex
/*
 * cmyth_livetv_chain_create(void)
 * 
 * Scope: PUBLIC
 *
 * Description
 *
 * Allocate and initialize a ring buffer structure.
 *
 * Return Value:
 *
 * Success: A non-NULL cmyth_livetv_chain_t (this type is a pointer)
 *
 * Failure: A NULL cmyth_livetv_chain_t
 */
cmyth_livetv_chain_t
cmyth_livetv_chain_create(char * chainid)
{
	cmyth_livetv_chain_t ret = ref_alloc(sizeof(*ret));

	cmyth_dbg(CMYTH_DBG_DEBUG, "%s\n", __FUNCTION__);
	if (!ret) {
		return NULL;
	}

	ret->chainid = ref_strdup(chainid);
	ret->chain_ct = 0;
	ret->chain_switch_on_create = 0;
	ret->chain_current = -1;
	ret->chain_urls = NULL;
	ret->chain_files = NULL;
	ret->progs = NULL;
	ref_set_destroy(ret, (ref_destroy_t)cmyth_livetv_chain_destroy);
	return ret;
}
예제 #12
0
/*
 * cmyth_conn_create(void)
 * 
 * Scope: PRIVATE (static)
 *
 * Description
 *
 * Allocate and initialize a cmyth_conn_t structure.  This should only
 * be called by cmyth_connect(), which establishes a connection.
 *
 * Return Value:
 *
 * Success: A non-NULL cmyth_conn_t (this type is a pointer)
 *
 * Failure: A NULL cmyth_conn_t
 */
static cmyth_conn_t
cmyth_conn_create(void)
{
	cmyth_conn_t ret = ref_alloc(sizeof(*ret));

	cmyth_dbg(CMYTH_DBG_DEBUG, "%s {\n", __FUNCTION__);
	if (!ret) {
			cmyth_dbg(CMYTH_DBG_DEBUG, "%s }!\n", __FUNCTION__);
		return NULL;
	}
	ref_set_destroy(ret, (ref_destroy_t)cmyth_conn_destroy);

	ret->conn_fd = -1;
	ret->conn_buf = NULL;
	ret->conn_len = 0;
	ret->conn_buflen = 0;
	ret->conn_pos = 0;
	ret->conn_hang = 0;
	cmyth_dbg(CMYTH_DBG_DEBUG, "%s }\n", __FUNCTION__);
	return ret;
}
예제 #13
0
cmyth_input_t
cmyth_input_create(void)
{
	cmyth_input_t ret = ref_alloc(sizeof(*ret));

	cmyth_dbg(CMYTH_DBG_DEBUG, "%s {\n", __FUNCTION__);
	if (!ret) {
		cmyth_dbg(CMYTH_DBG_DEBUG, "%s }!\n", __FUNCTION__);
		return NULL;
	}
	ref_set_destroy(ret, (ref_destroy_t)cmyth_input_destroy);

	ret->inputname = NULL;
	ret->sourceid = 0;
	ret->inputid = 0;
	ret->cardid = 0;
	ret->multiplexid = 0;

	cmyth_dbg(CMYTH_DBG_DEBUG, "%s }\n", __FUNCTION__);
	return ret;
}
예제 #14
0
파일: ringbuf.c 프로젝트: AWilco/xbmc
/*
 * cmyth_ringbuf_create(void)
 * 
 * Scope: PUBLIC
 *
 * Description
 *
 * Allocate and initialize a ring buffer structure.
 *
 * Return Value:
 *
 * Success: A non-NULL cmyth_ringbuf_t (this type is a pointer)
 *
 * Failure: A NULL cmyth_ringbuf_t
 */
cmyth_ringbuf_t
cmyth_ringbuf_create(void)
{
	cmyth_ringbuf_t ret = ref_alloc(sizeof(*ret));

	cmyth_dbg(CMYTH_DBG_DEBUG, "%s\n", __FUNCTION__);
	if (!ret) {
		return NULL;
	}

	ret->conn_data = NULL;
	ret->ringbuf_url = NULL;
	ret->ringbuf_size = 0;
	ret->ringbuf_fill = 0;
	ret->file_pos = 0;
	ret->file_id = 0;
	ret->ringbuf_hostname = NULL;
	ret->ringbuf_port = 0;
	ref_set_destroy(ret, (ref_destroy_t)cmyth_ringbuf_destroy);
	return ret;
}
예제 #15
0
/*
 * cmyth_recorder_create()
 *
 * Scope: PUBLIC
 *
 * Description
 *
 * Allocate and initialize a cmyth recorder structure.
 *
 * Return Value:
 *
 * Success: A non-NULL cmyth_recorder_t (this type is a pointer)
 *
 * Failure: A NULL cmyth_recorder_t
 */
cmyth_recorder_t
cmyth_recorder_create(void)
{
	cmyth_recorder_t ret = ref_alloc(sizeof(*ret));

	cmyth_dbg(CMYTH_DBG_DEBUG, "%s\n", __FUNCTION__);
	if (!ret) {
		return NULL;
	}
	ref_set_destroy(ret, (ref_destroy_t)cmyth_recorder_destroy);

	ret->rec_server = NULL;
	ret->rec_port = 0;
	ret->rec_have_stream = 0;
	ret->rec_id = 0;
	ret->rec_ring = NULL;
	ret->rec_conn = NULL;
	ret->rec_framerate = 0.0;
	ret->rec_livetv_chain = NULL;
	ret->rec_livetv_file = NULL;
	return ret;
}
예제 #16
0
파일: file.c 프로젝트: tsp/cmyth
/*
 * cmyth_file_create(cmyth_conn_t control)
 * 
 * Scope: PRIVATE (mapped to __cmyth_file_create)
 *
 * Description
 *
 * Allocate and initialize a cmyth_file_t structure.  This should only
 * be called by cmyth_connect_file(), which establishes a file
 * transfer connection.
 *
 * Return Value:
 *
 * Success: A non-NULL cmyth_file_t (this type is a pointer)
 *
 * Failure: A NULL cmyth_file_t
 */
cmyth_file_t
cmyth_file_create(cmyth_conn_t control)
{
	cmyth_file_t ret = ref_alloc(sizeof(*ret));

	cmyth_dbg(CMYTH_DBG_DEBUG, "%s {\n", __FUNCTION__);
 	if (!ret) {
		cmyth_dbg(CMYTH_DBG_DEBUG, "%s }\n", __FUNCTION__);
 		return NULL;
	}
	ref_set_destroy(ret, (ref_destroy_t)cmyth_file_destroy);

	ret->file_control = ref_hold(control);
	ret->file_data = NULL;
	ret->file_id = -1;
	ret->file_start = 0;
	ret->file_length = 0;
	ret->file_pos = 0;
	ret->closed_callback = NULL;
	cmyth_dbg(CMYTH_DBG_DEBUG, "%s }\n", __FUNCTION__);
	return ret;
}
예제 #17
0
/*
 * cmyth_livetv_chain_create(void)
 *
 * Scope: PUBLIC
 *
 * Description
 *
 * Allocate and initialize a ring buffer structure.
 *
 * Return Value:
 *
 * Success: A non-NULL cmyth_livetv_chain_t (this type is a pointer)
 *
 * Failure: A NULL cmyth_livetv_chain_t
 */
cmyth_livetv_chain_t
cmyth_livetv_chain_create(char * chainid)
{
    cmyth_livetv_chain_t ret = ref_alloc(sizeof(*ret));

    cmyth_dbg(CMYTH_DBG_DEBUG, "%s\n", __FUNCTION__);
    if (!ret) {
        return NULL;
    }

    ret->chainid = ref_strdup(chainid);
    ret->chain_ct = 0;
    ret->chain_switch_on_create = 0;
    ret->chain_current = -1;
    ret->chain_urls = NULL;
    ret->chain_files = NULL;
    ret->progs = NULL;
    ret->livetv_watch = 0; /* JLB: Manage program breaks. Set to 1 on chain setup */
    ret->livetv_tcp_rcvbuf = 0;
    ref_set_destroy(ret, (ref_destroy_t)cmyth_livetv_chain_destroy);
    return ret;
}
예제 #18
0
파일: proginfo.c 프로젝트: Ferdiand/cmyth
/*
 * cmyth_proginfo_create(void)
 * 
 * Scope: PUBLIC
 *
 * Description
 *
 * Create a programinfo structure to be used to hold program
 * information and return a pointer to the structure.  The structure
 * is initialized to default values.
 *
 * Return Value:
 *
 * Success: A non-NULL cmyth_proginfo_t (this type is a pointer)
 *
 * Failure: A NULL cmyth_proginfo_t
 */
cmyth_proginfo_t
cmyth_proginfo_create(void)
{
	cmyth_proginfo_t ret = ref_alloc(sizeof(*ret));

	cmyth_dbg(CMYTH_DBG_DEBUG, "%s {\n", __FUNCTION__);
	if (!ret) {
		cmyth_dbg(CMYTH_DBG_DEBUG, "%s }!\n", __FUNCTION__);
		return NULL;
	}
	ref_set_destroy(ret, (ref_destroy_t)cmyth_proginfo_destroy);

	ret->proginfo_start_ts = cmyth_timestamp_create();
	if (!ret->proginfo_start_ts) {
		cmyth_dbg(CMYTH_DBG_DEBUG, "%s }!!\n", __FUNCTION__);
		goto err;
	}
	ret->proginfo_end_ts = cmyth_timestamp_create();
	if (!ret->proginfo_end_ts) {
		cmyth_dbg(CMYTH_DBG_DEBUG, "%s }!!!\n", __FUNCTION__);
		goto err;
	}
	ret->proginfo_rec_start_ts = cmyth_timestamp_create();
	if (!ret->proginfo_rec_start_ts) {
		cmyth_dbg(CMYTH_DBG_DEBUG, "%s }!!!!\n", __FUNCTION__);
		goto err;
	}
	ret->proginfo_rec_end_ts = cmyth_timestamp_create();
	if (!ret->proginfo_rec_end_ts) {
		cmyth_dbg(CMYTH_DBG_DEBUG, "%s } !!!!!\n", __FUNCTION__);
		goto err;
	}
	ret->proginfo_lastmodified = cmyth_timestamp_create();
	if (!ret->proginfo_lastmodified) {
		cmyth_dbg(CMYTH_DBG_DEBUG, "%s } !!!!!!\n", __FUNCTION__);
		goto err;
	}
	ret->proginfo_originalairdate = cmyth_timestamp_create();
	if (!ret->proginfo_originalairdate) {
		cmyth_dbg(CMYTH_DBG_DEBUG, "%s } !!!!!!!\n", __FUNCTION__);
		goto err;
	}
	ret->proginfo_title = NULL;
	ret->proginfo_subtitle = NULL;
	ret->proginfo_description = NULL;
	ret->proginfo_season = 0;
	ret->proginfo_episode = 0;
	ret->proginfo_category = NULL;
	ret->proginfo_chanId = 0;
	ret->proginfo_chanstr = NULL;
	ret->proginfo_chansign = NULL;
	ret->proginfo_channame = NULL;
	ret->proginfo_chanicon = NULL;
	ret->proginfo_url = NULL;
	ret->proginfo_pathname = NULL;
	ret->proginfo_host = NULL;
	ret->proginfo_port = -1;
	ret->proginfo_Length = 0;
	ret->proginfo_conflicting = 0;
	ret->proginfo_unknown_0 = NULL;
	ret->proginfo_recording = 0;
	ret->proginfo_override = 0;
	ret->proginfo_hostname = NULL;
	ret->proginfo_source_id = 0;
	ret->proginfo_card_id = 0;
	ret->proginfo_input_id = 0;
	ret->proginfo_rec_priority = 0;
	ret->proginfo_rec_status = 0;
	ret->proginfo_record_id = 0;
	ret->proginfo_rec_type = 0;
	ret->proginfo_rec_dups = 0;
	ret->proginfo_unknown_1 = 0;
	ret->proginfo_repeat = 0;
	ret->proginfo_program_flags = 0;
	ret->proginfo_rec_profile = NULL;
	ret->proginfo_recgroup = NULL;
	ret->proginfo_chancommfree = NULL;
	ret->proginfo_chan_output_filters = NULL;
	ret->proginfo_seriesid = NULL;
	ret->proginfo_programid = NULL;
	ret->proginfo_inetref = NULL;
	ret->proginfo_stars = NULL;
	ret->proginfo_version = 12;
	ret->proginfo_hasairdate = 0;
	ret->proginfo_playgroup = NULL;
	ret->proginfo_storagegroup = NULL;
	ret->proginfo_recpriority_2 = NULL;
	ret->proginfo_parentid = 0;
	ret->proginfo_audioproperties = 0;
	ret->proginfo_videoproperties = 0;
	ret->proginfo_subtitletype = 0;
	ret->proginfo_year = 0;
	cmyth_dbg(CMYTH_DBG_DEBUG, "%s }\n", __FUNCTION__);
	return ret;

    err:
	ref_release(ret);
	cmyth_dbg(CMYTH_DBG_DEBUG, "%s } !++\n", __FUNCTION__);
       	return NULL;
}
예제 #19
0
파일: proginfo.c 프로젝트: Ferdiand/cmyth
/*
 * cmyth_proginfo_create(void)
 * 
 * Scope: PRIVATE (static)
 *
 * Description
 *
 * Duplicate a program information structure into a new one.  The sub-fields
 * get held, not actually copied.
 *
 * Return Value:
 *
 * Success: A non-NULL cmyth_proginfo_t (this type is a pointer)
 *
 * Failure: A NULL cmyth_proginfo_t
 */
static cmyth_proginfo_t
cmyth_proginfo_dup(cmyth_proginfo_t p)
{
	cmyth_proginfo_t ret = cmyth_proginfo_create();

	cmyth_dbg(CMYTH_DBG_DEBUG, "%s {\n", __FUNCTION__);
	if (!ret) {
		cmyth_dbg(CMYTH_DBG_DEBUG, "%s }!\n", __FUNCTION__);
		return NULL;
	}
	ref_set_destroy(ret, (ref_destroy_t)cmyth_proginfo_destroy);

	ret->proginfo_start_ts = ref_hold(p->proginfo_start_ts);
	ret->proginfo_end_ts = ref_hold(p->proginfo_end_ts);
	ret->proginfo_rec_start_ts = ref_hold(p->proginfo_rec_start_ts);
	ret->proginfo_rec_end_ts = ref_hold(p->proginfo_rec_end_ts);
	ret->proginfo_lastmodified = ref_hold(p->proginfo_lastmodified);
	ret->proginfo_originalairdate = ref_hold(p->proginfo_originalairdate);
	ret->proginfo_title = ref_hold(p->proginfo_title);
	ret->proginfo_subtitle = ref_hold(p->proginfo_subtitle);
	ret->proginfo_description = ref_hold(p->proginfo_description);
	ret->proginfo_season = p->proginfo_season;
	ret->proginfo_episode = p->proginfo_episode;
	ret->proginfo_category = ref_hold(p->proginfo_category);
	ret->proginfo_chanId = p->proginfo_chanId;
	ret->proginfo_chanstr = ref_hold(p->proginfo_chanstr);
	ret->proginfo_chansign = ref_hold(p->proginfo_chansign);
	ret->proginfo_channame = ref_hold(p->proginfo_channame);
	ret->proginfo_chanicon = ref_hold(p->proginfo_chanicon);
	ret->proginfo_url = ref_hold(p->proginfo_url);
	ret->proginfo_pathname = ref_hold(p->proginfo_pathname);
	ret->proginfo_host = ref_hold(p->proginfo_host);
	ret->proginfo_port = p->proginfo_port;
	ret->proginfo_Length = p->proginfo_Length;
	ret->proginfo_conflicting = p->proginfo_conflicting;
	ret->proginfo_unknown_0 = ref_hold(p->proginfo_unknown_0);
	ret->proginfo_recording = p->proginfo_recording;
	ret->proginfo_override = p->proginfo_override;
	ret->proginfo_hostname = ref_hold(p->proginfo_hostname);
	ret->proginfo_source_id = p->proginfo_source_id;
	ret->proginfo_card_id = p->proginfo_card_id;
	ret->proginfo_input_id = p->proginfo_input_id;
	ret->proginfo_rec_priority = ref_hold(p->proginfo_rec_priority);
	ret->proginfo_rec_status = p->proginfo_rec_status;
	ret->proginfo_record_id = p->proginfo_record_id;
	ret->proginfo_rec_type = p->proginfo_rec_type;
	ret->proginfo_rec_dups = p->proginfo_rec_dups;
	ret->proginfo_unknown_1 = p->proginfo_unknown_1;
	ret->proginfo_repeat = p->proginfo_repeat;
	ret->proginfo_program_flags = p->proginfo_program_flags;
	ret->proginfo_rec_profile = ref_hold(p->proginfo_rec_profile);
	ret->proginfo_recgroup = ref_hold(p->proginfo_recgroup);
	ret->proginfo_chancommfree = ref_hold(p->proginfo_chancommfree);
	ret->proginfo_chan_output_filters = ref_hold(p->proginfo_chan_output_filters);
	ret->proginfo_seriesid = ref_hold(p->proginfo_seriesid);
	ret->proginfo_programid = ref_hold(p->proginfo_programid);
	ret->proginfo_inetref = ref_hold(p->proginfo_inetref);
	ret->proginfo_stars = ref_hold(p->proginfo_stars);
	ret->proginfo_version = p->proginfo_version;
	ret->proginfo_hasairdate = p->proginfo_hasairdate;
	ret->proginfo_playgroup = ref_hold(p->proginfo_playgroup);
	ret->proginfo_storagegroup = ref_hold(p->proginfo_storagegroup);
	ret->proginfo_recpriority_2 = ref_hold(p->proginfo_recpriority_2);
	ret->proginfo_parentid = p->proginfo_parentid;
	ret->proginfo_audioproperties = p->proginfo_audioproperties;
	ret->proginfo_videoproperties = p->proginfo_videoproperties;
	ret->proginfo_subtitletype = p->proginfo_subtitletype;
	ret->proginfo_year = p->proginfo_year;
	cmyth_dbg(CMYTH_DBG_DEBUG, "%s }\n", __FUNCTION__);
	return ret;
}