rtmp_app_t* rtmp_create_app(mem_pool_t *pool,rtmp_host_t *host)
{
mem_pool_t *chunk_pool;
rtmp_app_t *app;
rtmp_app_conf_t *conf;
rtmp_host_conf_t *hconf;
hconf = host->hconf;
app = mem_pcalloc(pool,sizeof(rtmp_app_t) + sizeof(rtmp_app_conf_t));
if (app == NULL) {
return NULL;
}
chunk_pool = mem_create_pool(MEM_DEFAULT_POOL_SIZE);
if (chunk_pool == NULL) {
return NULL;
}
conf = (rtmp_app_conf_t*)(app + 1);
app->conf = conf;
app->chunk_pool = chunk_pool;
conf->ack_size = hconf->ack_size;
conf->ping_timeout = hconf->ping;
conf->chunk_size = hconf->chunk_size;
conf->stream_buckets = 1024;
list_init(&app->free_lives);
app->host = host;
return app;
}
rtmp_cycle_t* rtmp_init_cycle(void)
{
rtmp_cycle_t *cycle;
mem_pool_t *pool,*temp_pool;
size_t slen;
int m;
rtmp_module_t *module;
mem_pagesize = 4096;
mem_pagesize_shift = 12;
mem_cacheline_size = 4096;
pool = mem_create_pool(MEM_DEFAULT_POOL_SIZE);
if (pool == NULL) {
rtmp_log(RTMP_LOG_ERR,"alloc pool failed!");
return NULL;
}
temp_pool = mem_create_pool(MEM_DEFAULT_POOL_SIZE);
if (temp_pool == NULL) {
rtmp_log(RTMP_LOG_ERR,"alloc temp_pool failed!");
return NULL;
}
slen = strlen(rtmp_conf_file);
cycle = mem_palloc(pool,sizeof(rtmp_cycle_t));
if (cycle == NULL) {
return NULL;
}
cycle->pool = pool;
cycle->temp_pool = temp_pool;
cycle->conf_file = mem_pcalloc(pool,slen + 1);
if (cycle->conf_file == NULL) {
return NULL;
}
memcpy(cycle->conf_file,rtmp_conf_file,slen);
rtmp_max_modules = 0;
for (m = 0;rtmp_modules[m];m++) {
rtmp_modules[m]->index = m;
rtmp_max_modules++;
}
cycle->conf = mem_pcalloc(pool,sizeof(void*));
/*create modules*/
for (m = 0;rtmp_modules[m];m++) {
module = rtmp_modules[m];
if (module->create_module != NULL) {
module->ctx = module->create_module(cycle);
if (module->ctx == NULL) {
rtmp_log(RTMP_LOG_WARNING,"create module failed[%d]",m);
return NULL;
}
}
}
if (rtmp_conf_parse(cycle) != RTMP_OK) {
return NULL;
}
for (m = 0;rtmp_modules[m];m++) {
module = rtmp_modules[m];
if (module->init_cycle != NULL) {
if (module->init_cycle(cycle,module) != RTMP_OK) {
rtmp_log(RTMP_LOG_WARNING,"configure module failed[%d]",m);
return 0;
}
}
}
/*init core process*/
module = rtmp_modules[0];
if (module->init_forking) {
if (rtmp_modules[0]->init_forking(cycle,module) == RTMP_FAILED) {
return 0;
}
}
return cycle;
}
bool_t model_md2_load(void *filedata, size_t filesize, model_t *out_model, char **out_error)
{
typedef struct md2_meshvert_s
{
unsigned short vertex;
unsigned short texcoord;
} md2_meshvert_t;
unsigned char * const f = (unsigned char*)filedata;
mem_pool_t *pool;
md2_header_t *header;
int i, j;
model_t model;
mesh_t *mesh;
skininfo_t *skininfo;
frameinfo_t *frameinfo;
md2_meshvert_t *meshverts;
float iwidth, iheight;
float *v, *n;
header = (md2_header_t*)f;
/* validate format */
if (memcmp(header->ident, "IDP2", 4))
return (void)(out_error && (*out_error = msprintf("wrong format (not IDP2)"))), false;
if (LittleLong(header->version) != 8)
return (void)(out_error && (*out_error = msprintf("wrong format (version not 8)"))), false;
pool = mem_create_pool();
/* byteswap file */
header->version = LittleLong(header->version);
header->skinwidth = LittleLong(header->skinwidth);
header->skinheight = LittleLong(header->skinheight);
header->framesize = LittleLong(header->framesize);
header->num_skins = LittleLong(header->num_skins);
header->num_vertices = LittleLong(header->num_vertices);
header->num_st = LittleLong(header->num_st);
header->num_tris = LittleLong(header->num_tris);
header->num_glcmds = LittleLong(header->num_glcmds);
header->num_frames = LittleLong(header->num_frames);
header->offset_skins = LittleLong(header->offset_skins);
header->offset_st = LittleLong(header->offset_st);
header->offset_tris = LittleLong(header->offset_tris);
header->offset_frames = LittleLong(header->offset_frames);
header->offset_glcmds = LittleLong(header->offset_glcmds);
header->offset_end = LittleLong(header->offset_end);
/* stuff */
model.total_skins = header->num_skins;
model.num_skins = header->num_skins;
model.skininfo = (skininfo_t*)mem_alloc(pool, sizeof(skininfo_t) * model.num_skins);
for (i = 0, skininfo = model.skininfo; i < model.num_skins; i++, skininfo++)
{
const md2_skin_t *md2skin = (const md2_skin_t*)(f + header->offset_skins) + i;
skininfo->frametime = 0.1f;
skininfo->num_skins = 1;
skininfo->skins = (singleskin_t*)mem_alloc(pool, sizeof(skininfo_t));
skininfo->skins[0].name = mem_copystring(pool, md2skin->name);
skininfo->skins[0].offset = i;
}
model.total_frames = header->num_frames;
model.num_frames = header->num_frames;
model.frameinfo = (frameinfo_t*)mem_alloc(pool, sizeof(frameinfo_t) * model.num_frames);
for (i = 0, frameinfo = model.frameinfo; i < model.num_frames; i++, frameinfo++)
{
const daliasframe_t *md2frame = (const daliasframe_t*)(f + header->offset_frames + i * header->framesize);
frameinfo->frametime = 0.1f;
frameinfo->num_frames = 1;
frameinfo->frames = (singleframe_t*)mem_alloc(pool, sizeof(singleframe_t));
frameinfo->frames[0].name = mem_copystring(pool, md2frame->name);
frameinfo->frames[0].offset = i;
}
model.num_meshes = 1;
model.meshes = (mesh_t*)mem_alloc(pool, sizeof(mesh_t));
model.num_tags = 0;
model.tags = NULL;
model.flags = 0;
model.synctype = 0;
model.offsets[0] = 0.0f;
model.offsets[1] = 0.0f;
model.offsets[2] = 0.0f;
mesh = &model.meshes[0];
mesh_initialize(&model, mesh);
mesh->name = mem_copystring(pool, "md2mesh");
/* read skins */
mesh->skins = (meshskin_t*)mem_alloc(pool, sizeof(meshskin_t) * model.num_skins);
for (i = 0; i < model.num_skins; i++)
{
const md2_skin_t *md2skin = (const md2_skin_t*)(f + header->offset_skins) + i;
char *error;
image_rgba_t *image;
for (j = 0; j < SKIN_NUMTYPES; j++)
mesh->skins[i].components[j] = NULL;
/* try to load the image file mentioned in the md2 */
/* if any of the skins fail to load, they will be left as null */
image = image_load_from_file(pool, md2skin->name, &error);
if (!image)
{
/* this is a warning. FIXME - return warnings too, don't print them here */
printf("md2: failed to load image \"%s\": %s\n", md2skin->name, error);
qfree(error);
continue;
}
mesh->skins[i].components[SKIN_DIFFUSE] = image;
}
/* read triangles */
mesh->num_triangles = header->num_tris;
mesh->triangle3i = (int*)mem_alloc(pool, sizeof(int) * mesh->num_triangles * 3);
mesh->num_vertices = 0;
meshverts = (md2_meshvert_t*)mem_alloc(pool, sizeof(md2_meshvert_t) * mesh->num_triangles * 3);
for (i = 0; i < mesh->num_triangles; i++)
{
const dtriangle_t *dtriangle = (const dtriangle_t*)(f + header->offset_tris) + i;
for (j = 0; j < 3; j++)
{
int vertnum;
unsigned short xyz = LittleShort(dtriangle->index_xyz[j]);
unsigned short st = LittleShort(dtriangle->index_st[j]);
for (vertnum = 0; vertnum < mesh->num_vertices; vertnum++)
{
/* see if this xyz+st combination exists in the buffer yet */
md2_meshvert_t *mv = &meshverts[vertnum];
if (mv->vertex == xyz && mv->texcoord == st)
break;
}
if (vertnum == mesh->num_vertices)
{
/* it isn't in the list yet, add it */
meshverts[vertnum].vertex = xyz;
meshverts[vertnum].texcoord = st;
mesh->num_vertices++;
}
mesh->triangle3i[i * 3 + j] = vertnum; /* (clockwise winding) */
}
}
/* read texcoords */
mesh->texcoord2f = (float*)mem_alloc(pool, sizeof(float) * mesh->num_vertices * 2);
iwidth = 1.0f / header->skinwidth;
iheight = 1.0f / header->skinheight;
for (i = 0; i < mesh->num_vertices; i++)
{
const dstvert_t *dstvert = (const dstvert_t*)(f + header->offset_st) + meshverts[i].texcoord;
mesh->texcoord2f[i*2+0] = (LittleFloat(dstvert->s) + 0.5f) * iwidth;
mesh->texcoord2f[i*2+1] = (LittleFloat(dstvert->t) + 0.5f) * iheight;
}
/* read frames */
v = mesh->vertex3f = (float*)mem_alloc(pool, model.num_frames * sizeof(float) * mesh->num_vertices * 3);
n = mesh->normal3f = (float*)mem_alloc(pool, model.num_frames * sizeof(float) * mesh->num_vertices * 3);
for (i = 0; i < model.num_frames; i++)
{
const daliasframe_t *frame = (const daliasframe_t*)(f + header->offset_frames + i * header->framesize);
const dtrivertx_t *vtxbase = (const dtrivertx_t*)(frame + 1);
float scale[3], translate[3];
for (j = 0; j < 3; j++)
{
scale[j] = LittleFloat(frame->scale[j]);
translate[j] = LittleFloat(frame->translate[j]);
}
for (j = 0; j < mesh->num_vertices; j++, v += 3, n += 3)
{
const dtrivertx_t *vtx = vtxbase + meshverts[j].vertex;
v[0] = translate[0] + scale[0] * vtx->v[0];
v[1] = translate[1] + scale[1] * vtx->v[1];
v[2] = translate[2] + scale[2] * vtx->v[2];
n[0] = anorms[vtx->lightnormalindex][0];
n[1] = anorms[vtx->lightnormalindex][1];
n[2] = anorms[vtx->lightnormalindex][2];
}
}
mem_free(meshverts);
mem_merge_pool(pool);
*out_model = model;
return true;
}
