void
bp_scene_init (scene_t *scene)
{
int i;
int parcel_size, parcel_start;
const unsigned int vertical_resolution = bp_scene_get_vertical_resolution (scene);
const unsigned int horizontal_resolution = bp_scene_get_horizontal_resolution (scene);
/* Initialize and set thread detached attribute */
pthread_attr_init(&thread_attr);
pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_JOINABLE);
threads = (pthread_t *)calloc (sizeof (pthread_t), scene->settings.num_threads);
thread_args = (thread_args_t *)calloc (sizeof (thread_args_t), scene->settings.num_threads);
pthread_mutex_init (&line_id_mutex, NULL);
gamma_inv = 1 / scene->settings.gamma;
/* FIXME: this can be improved a lot */
parcel_size = vertical_resolution / scene->settings.num_threads +
((vertical_resolution % scene->settings.num_threads) ? 1 : 0);
for (parcel_start = 0, i = 0; parcel_start < vertical_resolution; i++) {
thread_args [i].scene = scene;
thread_args [i].start = parcel_start;
parcel_start += parcel_size;
thread_args [i].end = MIN (parcel_start, horizontal_resolution);
}
framebuffer_init (bp_scene_get_framebuffer (scene));
simd4i_minus_ones = _mm_set1_epi32 (-1);
}
int renderer_init(struct renderer *r, int w, int h)
{
if (framebuffer_init(&r->fb) < 0)
return -1;
if (renderer_init_shaders(r) < 0)
return -1;
if (create_cube_mesh(&r->cube_attr, &r->cube_idx) < 0) {
fprintf(stderr, "Error creating cube mesh\n");
return -1;
}
if (create_quad_mesh(&r->quad_attr) < 0) {
fprintf(stderr, "Error creating fullscreen quad\n");
return -1;
}
vec3_set(&r->pos, 2, 4, 2);
vec3_set(&r->tar, 0, 0, 0);
vec3_set(&r->up, 0, 1, 0);
r->width = w;
r->height = h;
renderer_default_display_state(r);
renderer_default_quadrants(r);
renderer_default_postprocess_effects(r);
return 0;
}
window *window_create(size_t width, size_t height)
{
window *wnd = malloc(sizeof(*wnd));
XSizeHints hints;
if (!wnd)
return NULL;
if (!framebuffer_init(&wnd->fb, width, height))
goto fail;
wnd->dpy = XOpenDisplay(0);
if (!wnd->dpy)
goto fail_fb;
wnd->wnd = XCreateSimpleWindow(wnd->dpy, DefaultRootWindow(wnd->dpy),
0, 0, width, height, 0, 0, 0);
if (!wnd->wnd)
goto fail_dpy;
memset(&hints, 0, sizeof(hints));
hints.flags = PSize | PMinSize | PMaxSize;
hints.min_width = hints.max_width = hints.base_width = width;
hints.min_height = hints.max_height = hints.base_height = height;
XSetWMNormalHints(wnd->dpy, wnd->wnd, &hints);
wnd->atom_wm_delete = XInternAtom(wnd->dpy, "WM_DELETE_WINDOW", True);
XSelectInput(wnd->dpy, wnd->wnd, StructureNotifyMask | KeyReleaseMask);
XSetWMProtocols(wnd->dpy, wnd->wnd, &(wnd->atom_wm_delete), 1);
XFlush(wnd->dpy);
XStoreName(wnd->dpy, wnd->wnd, "SW Rasterizer");
XMapWindow(wnd->dpy, wnd->wnd);
wnd->gc = XCreateGC(wnd->dpy, wnd->wnd, 0, NULL);
if (!wnd->gc)
goto fail_wnd;
wnd->img = XCreateImage(wnd->dpy, NULL, 24, ZPixmap, 0, 0,
width, height, 32, 0);
if (!wnd->img)
goto fail_gc;
return wnd;
fail_gc:
XFreeGC(wnd->dpy, wnd->gc);
fail_wnd:
XDestroyWindow(wnd->dpy, wnd->wnd);
fail_dpy:
XCloseDisplay(wnd->dpy);
fail_fb:
framebuffer_cleanup(&wnd->fb);
fail:
free(wnd);
return NULL;
}
void kernel_main(uint32_t r0, uint32_t r1, uint32_t *atags,
uint32_t memory_kernel) {
unsigned int memory_total;
int init_process,idle_process;
struct atag_info_t atag_info;
uint32_t framebuffer_width=800,framebuffer_height=600;
(void) r0; /* Ignore boot method */
/* Initialize Software Structures */
processes_init();
/* Detect Hardware */
atags_detect(atags,&atag_info);
hardware_type=atag_info.hardware_type;
/* Initialize Hardware */
/* Serial console is most important so do that first */
uart_init();
/* Enable Interrupts */
enable_interrupts();
/************************/
/* Boot message! */
/************************/
printk("\r\nBooting VMWos...\r\n");
/**************************/
/* Device Drivers */
/**************************/
/* Set up ACT LED */
led_init();
/* Set up timer */
timer_init();
/* Set up keyboard */
ps2_keyboard_init();
/* Enable the Framebuffer */
if (atag_info.framebuffer_x!=0) {
framebuffer_width=atag_info.framebuffer_x;
}
if (atag_info.framebuffer_y!=0) {
framebuffer_height=atag_info.framebuffer_y;
}
framebuffer_init(framebuffer_width,framebuffer_height,24);
framebuffer_console_init();
/* Delay to allow time for serial port to settle */
/* So we can actually see the output on the terminal */
delay(0x3f0000);
printk("\r\nWaiting for serial port to be ready (press any key)\r\n");
uart_getc();
uart_enable_interrupts();
/* Clear screen */
printk("\n\r\033[2J\n\r\n\r");
/* Print boot message */
printk("\033[0;41m \033[42m \033[44m \033[42m \033[44m \033[0m VMW OS\r\n");
printk(" \033[0;41m \033[42m \033[44m \033[42m \033[44m \033[0m Version 0.%d\r\n\r\n",VERSION);
/* Print hardware version */
printk("Hardware version: %x ",r1);
if (r1==0xc42) printk("(Raspberry Pi)");
else printk("(Unknown Hardware)");
printk("\r\n");
printk("Detected Model ");
switch(hardware_type) {
case RPI_MODEL_A: printk("A"); break;
case RPI_MODEL_APLUS: printk("A+"); break;
case RPI_MODEL_B: printk("B"); break;
case RPI_MODEL_BPLUS: printk("B+"); break;
case RPI_MODEL_B2: printk("B2"); break;
case RPI_COMPUTE_NODE: printk("Compute Node"); break;
default: printk("Unknown %x",hardware_type); break;
}
printk("\r\n");
/* Print ATAGS */
atags_dump(atags);
printk("\r\n");
/* Get amount of RAM from ATAGs */
memory_total=atag_info.ramsize;
/* Init memory subsystem */
memory_init(memory_total,memory_kernel);
/* Init the MMU */
printk("Initializing MMU and caches\r\n");
//enable_mmu(0, memory_total);
//l1_data_cache_clear();
//l1_data_cache_enable();
l1_instruction_cache_enable();
/* Memory Benchmark */
#if 1
{
int i;
uint32_t before,after;
before=ticks_since_boot();
for(i=0;i<16;i++) {
memset(benchmark,0,BENCH_SIZE);
}
after=ticks_since_boot();
printk("MEMSPEED: %d MB took %d ticks %dkB/s\r\n",
16, (after-before),
div32(16*1024,(((after-before)*1000)/64)));
}
#endif
/* Load the idle thread */
idle_process=load_process("idle",PROCESS_FROM_RAM,
(char *)&idle_task,8,4096);
init_process=load_process("shell",PROCESS_FROM_DISK,
NULL,0,8192);
load_process("printa",PROCESS_FROM_DISK,
NULL,0,8192);
load_process("printb",PROCESS_FROM_DISK,
NULL,0,8192);
/* Enter our "init" process*/
printk("\r\nEntering userspace by starting process %d!\r\n",
init_process);
process[idle_process].ready=1;
process[init_process].ready=1;
userspace_started=1;
/* run init and restore stack as we won't return */
run_process(init_process,0x8000);
/* we should never get here */
while(1) {
/* Loop Forever */
/* Should probably execute a wfi instruction */
}
}
int main(int argc,char* argv[]) {
SubtitleOutputDef_t out;
int showInfos = 0, noinput = 0;
char file[255] = {""};
int speed = 0, speedmap = 0;
printf("%s >\n", __FILE__);
if (argc < 2)
{
printf("give me a filename please\n");
exit(1);
}
if (strstr(argv[1], "://") == NULL)
{
strcpy(file, "file://");
}
strcat(file, argv[1]);
/* debug helper */
if(argc == 3 && !strcmp(argv[2], "-d"))
{
showInfos = 1;
}
if(argc == 3 && !strcmp(argv[2], "-n"))
noinput = 1;
player = malloc(sizeof(Context_t));
player->playback = &PlaybackHandler;
player->output = &OutputHandler;
player->container = &ContainerHandler;
player->manager = &ManagerHandler;
printf("%s\n", player->output->Name);
//Registrating output devices
player->output->Command(player,OUTPUT_ADD, "audio");
player->output->Command(player,OUTPUT_ADD, "video");
player->output->Command(player,OUTPUT_ADD, "subtitle");
framebuffer_init();
/* for testing ass subtitles */
out.screen_width = xRes;
out.screen_height = yRes;
out.framebufferFD = fd;
out.destination = lfb;
out.destStride = stride;
out.shareFramebuffer = 1;
player->output->subtitle->Command(player, (OutputCmd_t)OUTPUT_SET_SUBTITLE_OUTPUT, (void*) &out);
if(player->playback->Command(player, PLAYBACK_OPEN, file) < 0)
return 10;
{
char ** TrackList = NULL;
player->manager->audio->Command(player, MANAGER_LIST, &TrackList);
if (TrackList != NULL) {
printf("AudioTrack List\n");
int i = 0;
for (i = 0; TrackList[i] != NULL; i+=2) {
printf("\t%s - %s\n", TrackList[i], TrackList[i+1]);
free(TrackList[i]);
free(TrackList[i+1]);
}
free(TrackList);
}
player->manager->video->Command(player, MANAGER_LIST, &TrackList);
if (TrackList != NULL) {
printf("VideoTrack List\n");
int i = 0;
for (i = 0; TrackList[i] != NULL; i+=2) {
printf("\t%s - %s\n", TrackList[i], TrackList[i+1]);
free(TrackList[i]);
free(TrackList[i+1]);
}
free(TrackList);
}
player->manager->subtitle->Command(player, MANAGER_LIST, &TrackList);
if (TrackList != NULL) {
printf("SubtitleTrack List\n");
int i = 0;
for (i = 0; TrackList[i] != NULL; i+=2) {
printf("\t%s - %s\n", TrackList[i], TrackList[i+1]);
free(TrackList[i]);
free(TrackList[i+1]);
}
free(TrackList);
}
}
{
int AudioTrackId = -1;
char * AudioTrackEncoding = NULL;
char * AudioTrackName = NULL;
player->manager->audio->Command(player, MANAGER_GET, &AudioTrackId);
player->manager->audio->Command(player, MANAGER_GETENCODING, &AudioTrackEncoding);
player->manager->audio->Command(player, MANAGER_GETNAME, &AudioTrackName);
printf("Current Audio Track : %d %s %s\n", AudioTrackId, AudioTrackEncoding, AudioTrackName);
free(AudioTrackEncoding);
free(AudioTrackName);
AudioTrackEncoding = NULL;
AudioTrackName = NULL;
player->manager->video->Command(player, MANAGER_GET, &AudioTrackId);
player->manager->video->Command(player, MANAGER_GETENCODING, &AudioTrackEncoding);
player->manager->video->Command(player, MANAGER_GETNAME, &AudioTrackName);
printf("Current Video Track : %d %s %s\n", AudioTrackId, AudioTrackEncoding, AudioTrackName);
free(AudioTrackEncoding);
free(AudioTrackName);
AudioTrackEncoding = NULL;
AudioTrackName = NULL;
player->manager->subtitle->Command(player, MANAGER_GET, &AudioTrackId);
player->manager->subtitle->Command(player, MANAGER_GETENCODING, &AudioTrackEncoding);
player->manager->subtitle->Command(player, MANAGER_GETNAME, &AudioTrackName);
printf("Current Subtitle Track : %d %s %s\n", AudioTrackId, AudioTrackEncoding, AudioTrackName);
free(AudioTrackEncoding);
free(AudioTrackName);
AudioTrackEncoding = NULL;
AudioTrackName = NULL;
/* player->manager->audio->Command(player, MANAGER_SET, 2);
player->manager->audio->Command(player, MANAGER_GET, &AudioTrackId);
player->manager->audio->Command(player, MANAGER_GETNAME, &AudioTrackName);
free(AudioTrackName);
AudioTrackName = NULL;*/
}
{
player->output->Command(player, OUTPUT_OPEN, NULL);
if (showInfos == 1)
{
char *tags[] =
{
"Title",
"Artist",
"Album",
"Year",
"Genre",
"Comment",
"Track",
"Copyright",
"TestLibEplayer",
NULL
};
int i = 0;
while (tags[i] != NULL)
{
char* tag = tags[i];
player->playback->Command(player, PLAYBACK_INFO, &tag);
#if !defined(VDR1722)
if (tag != NULL)
printf("\t%s:\t%s\n",tags[i], tag);
else
printf("\t%s:\tNULL\n",tags[i]);
#endif
i++;
}
player->output->Command(player, OUTPUT_CLOSE, NULL);
exit(1);
} else
player->playback->Command(player, PLAYBACK_PLAY, NULL);
/*{
int pid = 0;
player->playback->Command(player, PLAYBACK_SWITCH_SUBTITLE, (void*)&pid);
}*/
while(player->playback->isPlaying) {
int Key = 0;
if(kbhit())
if(noinput == 0)
Key = getchar();
if(!player->playback->isPlaying) {
break;
}
if(Key == 0)
continue;
switch (Key) {
case 'a': {
int Key2 = getchar();
switch (Key2) {
case 'l': {
char ** TrackList = NULL;
player->manager->audio->Command(player, MANAGER_LIST, &TrackList);
if (TrackList != NULL) {
printf("AudioTrack List\n");
int i = 0;
for (i = 0; TrackList[i] != NULL; i+=2) {
printf("\t%s - %s\n", TrackList[i], TrackList[i+1]);
free(TrackList[i]);
free(TrackList[i+1]);
}
free(TrackList);
}
break;
}
case 'c': {
int AudioTrackId = -1;
char * AudioTrackEncoding = NULL;
char * AudioTrackName = NULL;
player->manager->audio->Command(player, MANAGER_GET, &AudioTrackId);
player->manager->audio->Command(player, MANAGER_GETENCODING, &AudioTrackEncoding);
player->manager->audio->Command(player, MANAGER_GETNAME, &AudioTrackName);
printf("Current Audio Track : %d %s %s\n", AudioTrackId, AudioTrackEncoding, AudioTrackName);
free(AudioTrackEncoding);
free(AudioTrackName);
AudioTrackEncoding = NULL;
AudioTrackName = NULL;
break;
}
default: {
Key2 -= 0x30;
if(Key2 >= 0 && Key2 <= 9) {
player->playback->Command(player, PLAYBACK_SWITCH_AUDIO, (void*)&Key2);
}
}
}
break;
}
case 's': {
int Key2 = getchar();
switch (Key2) {
case 'l': {
char ** TrackList = NULL;
player->manager->subtitle->Command(player, MANAGER_LIST, &TrackList);
if (TrackList != NULL) {
printf("SubtitleTrack List\n");
int i = 0;
for (i = 0; TrackList[i] != NULL; i+=2) {
printf("\t%s - %s\n", TrackList[i], TrackList[i+1]);
free(TrackList[i]);
free(TrackList[i+1]);
}
free(TrackList);
}
break;
}
case 'c': {
int SubtitleTrackId = -1;
char * SubtitleTrackEncoding = NULL;
char * SubtitleTrackName = NULL;
player->manager->subtitle->Command(player, MANAGER_GET, &SubtitleTrackId);
player->manager->subtitle->Command(player, MANAGER_GETENCODING, &SubtitleTrackEncoding);
player->manager->subtitle->Command(player, MANAGER_GETNAME, &SubtitleTrackName);
printf("Current Subtitle Track : %d %s %s\n", SubtitleTrackId, SubtitleTrackEncoding, SubtitleTrackName);
free(SubtitleTrackEncoding);
free(SubtitleTrackName);
SubtitleTrackEncoding = NULL;
SubtitleTrackName = NULL;
break;
}
default: {
Key2 -= 0x30;
if(Key2 >= 0 && Key2 <= 9) {
player->playback->Command(player, PLAYBACK_SWITCH_SUBTITLE, (void*)&Key2);
}
}
}
break;
}
case 'q':
player->playback->Command(player, PLAYBACK_STOP, NULL);
break;
case 'c':
player->playback->Command(player, PLAYBACK_CONTINUE, NULL);
break;
case 'p':
player->playback->Command(player, PLAYBACK_PAUSE, NULL);
break;
case 'f': {
if (speed < 0)
speed = 0;
speed++;
if (speed > 7)
speed = 1;
switch(speed)
{
case 1:
speedmap = 1;
break;
case 2:
speedmap = 3;
break;
case 3:
speedmap = 7;
break;
case 4:
speedmap = 15;
break;
case 5:
speedmap = 31;
break;
case 6:
speedmap = 63;
break;
case 7:
speedmap = 127;
break;
}
player->playback->Command(player, PLAYBACK_FASTFORWARD, &speedmap);
break;
}
case 'b': {
if (speed > 0)
speed = 0;
speed--;
if (speed < -7)
speed = -1;
switch(speed)
{
case -1:
speedmap = -5;
break;
case -2:
speedmap = -10;
break;
case -3:
speedmap = -20;
break;
case -4:
speedmap = -40;
break;
case -5:
speedmap = -80;
break;
case -6:
speedmap = -160;
break;
case -7:
speedmap = -320;
break;
}
player->playback->Command(player, PLAYBACK_FASTBACKWARD, &speedmap);
break;
}
#if defined(VDR1722)
case 'g': {
char gotoString [256];
gets (gotoString);
int gotoPos = atoi(gotoString);
double length = 0;
float sec;
printf("gotoPos %i\n", gotoPos);
if (player->container && player->container->selectedContainer)
player->container->selectedContainer->Command(player, CONTAINER_LENGTH, &length);
if(gotoPos <= 0) {
printf("kleiner als erlaubt\n");
sec = 0.0;
} else if(gotoPos >= ((int)length - 10)) {
printf("laenger als erlaubt\n");
sec = (int)length - 10;
} else {
printf("normal action\n");
sec = gotoPos;
}
player->playback->Command(player, PLAYBACK_SEEK, (void*)&sec);
printf("goto postion (%i sec)\n", sec);
break;
}
#endif
case 'k': {
#if !defined(VDR1722)
int Key2 = getchar() - 48;
float sec=0.0;
printf("seconds %d \n", Key2);
switch (Key2) {
case 1:
sec=-15.0;
break;
case 4:
sec=-60.0;
break;
case 7:
sec=-300.0;
break;
case 3:
sec= 15.0;
break;
case 6:
sec= 60.0;
break;
case 9:
sec= 300.0;
break;
}
#else
char seek [256];
gets (seek);
unsigned int seekTo = atoi(seek);
double length = 0;
float sec;
unsigned long long int CurrentPTS = 0;
player->playback->Command(player, PLAYBACK_PTS, &CurrentPTS);
if (player->container && player->container->selectedContainer)
player->container->selectedContainer->Command(player, CONTAINER_LENGTH, &length);
int CurrentSec = CurrentPTS / 90000;
printf("CurrentSec = %i, seekTo = %i, abs(seekTo) = %i seekTo + CurrentSec %i\n", CurrentSec, seekTo, abs(seekTo), (seekTo + CurrentSec));
int ergSec = CurrentSec + seekTo;
if(ergSec < 0) {
printf("kleiner als erlaubt\n");
sec = 0.0;
} else if((CurrentSec + seekTo) >= ((int)length - 10)) {
printf("laenger als erlaubt\n");
sec = (int)length - 10;
} else {
printf("normal action\n");
sec = seekTo + CurrentSec;
}
printf("springe %i \n", (int)sec);
#endif
player->playback->Command(player, PLAYBACK_SEEK, (void*)&sec);
break;
}
case 'l': {
double length = 0;
if (player->container && player->container->selectedContainer)
player->container->selectedContainer->Command(player, CONTAINER_LENGTH, &length);
printf("Length = %02d:%02d:%02d (%.4f sec)\n", (int)((length/60)/60)%60, (int)(length/60)%60, (int)length%60, length);
break;
}
case 'j': {
unsigned long long int pts = 0;
player->playback->Command(player, PLAYBACK_PTS, &pts);
unsigned long long int sec = pts / 90000;
printf("Pts = %02d:%02d:%02d (%llu.0000 sec)\n", (int)((sec/60)/60)%60, (int)(sec/60)%60, (int)sec%60, sec);
break;
}
case 'i':
{
char *tags[] =
{
"Title",
"Artist",
"Album",
"Year",
"Genre",
"Comment",
"Track",
"Copyright",
"TestLibEplayer",
NULL
};
int i = 0;
while (tags[i] != NULL)
{
char* tag = tags[i];
player->playback->Command(player, PLAYBACK_INFO, &tag);
if (tag != NULL)
printf("\t%s:\t%s\n",tags[i], tag);
else
printf("\t%s:\tNULL\n",tags[i]);
i++;
}
break;
}
default: {
printf("Control:\n");
printf("al: List audio tracks\n");
printf("ac: List current audio track\n");
printf("a[id] Select audio track\n");
printf("sl: List subtitles\n");
printf("sc: List current subtitle\n");
printf("s[id] Select subtitles\n");
printf("q: Stop\n");
printf("c: Continue\n");
printf("p: Pause\n");
printf("f: Increase speed (Fast forward) (stepwise)\n");
printf("b: Decrease speed (Fast reverse) (stepwise)\n");
printf("l: Print duration\n");
printf("j: Print current PTS\n");
printf("k[1,4,7]: Jump back [15,60,300] seconds\n");
printf("k[3,6,9]: Jump forward [15,60,300] seconds\n");
printf("i: Print Info\n");
break;
}
}
}
player->output->Command(player, OUTPUT_CLOSE, NULL);
}
//printOutputCapabilities();
exit(0);
}
void kernel_main(uint32_t r0, uint32_t r1, uint32_t *atags,
uint32_t memory_kernel) {
unsigned int memory_total;
int init_process,idle_process;
struct atag_info_t atag_info;
uint32_t framebuffer_width=800,framebuffer_height=600;
uint32_t temperature;
(void) r0; /* Ignore boot method */
/* Initialize Software Structures */
processes_init();
/* Detect Hardware */
atags_detect(atags,&atag_info);
hardware_type=atag_info.hardware_type;
/* Initialize Hardware */
/* Serial console is most important so do that first */
uart_init();
/* Enable HW random number generator */
bcm2835_rng_init();
/* Enable Interrupts */
enable_interrupts();
/************************/
/* Boot message! */
/************************/
printk("\nBooting VMWos...\n");
/**************************/
/* Device Drivers */
/**************************/
/* Set up ACT LED */
led_init();
/* Set up timer */
timer_init();
/* Set up keyboard */
ps2_keyboard_init();
/* Enable the Framebuffer */
if (atag_info.framebuffer_x!=0) {
framebuffer_width=atag_info.framebuffer_x;
}
if (atag_info.framebuffer_y!=0) {
framebuffer_height=atag_info.framebuffer_y;
}
framebuffer_init(framebuffer_width,framebuffer_height,24);
framebuffer_console_init();
/* Delay to allow time for serial port to settle */
/* So we can actually see the output on the terminal */
delay(0x3f0000);
printk("\nWaiting for serial port to be ready (press any key)\n");
uart_getc();
uart_enable_interrupts();
/* Clear screen */
printk("\n\033[2J\n\n");
/* Print boot message */
printk("\033[0;41m \033[42m \033[44m \033[42m \033[44m \033[0m VMW OS\n");
printk(" \033[0;41m \033[42m \033[44m \033[42m \033[44m \033[0m Version 0.%d\n\n",VERSION);
/* Print hardware version */
printk("Hardware version: %x ",r1);
if (r1==0xc42) printk("(Raspberry Pi)");
else printk("(Unknown Hardware)");
printk("\n");
printk("Detected Model ");
switch(hardware_type) {
case RPI_MODEL_A: printk("A"); break;
case RPI_MODEL_APLUS: printk("A+"); break;
case RPI_MODEL_B: printk("B"); break;
case RPI_MODEL_BPLUS: printk("B+"); break;
case RPI_MODEL_B2: printk("B2"); break;
case RPI_COMPUTE_NODE: printk("Compute Node"); break;
default: printk("Unknown %x",hardware_type); break;
}
printk("\n");
/* Check temperature */
temperature=thermal_read();
printk("CPU Temperature: %dC, %dF\n",
temperature/1000,
((temperature*9)/5000)+32);
/* Print ATAGS */
atags_dump(atags);
printk("\n");
/* Get amount of RAM from ATAGs */
memory_total=atag_info.ramsize;
/* Init memory subsystem */
memory_init(memory_total,memory_kernel);
/* Start HW Perf Counters */
arm1176_init_pmu();
#if 0
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
// printk("Heisenbug!\n");
#endif
/* Setup Memory Hierarchy */
#if 1
memset_benchmark(memory_total);
#else
/* Enable L1 i-cache */
printk("Enabling L1 icache\n");
enable_l1_dcache();
/* Enable branch predictor */
printk("Enabling branch predictor\n");
/* Enable L1 d-cache */
printk("Enabling MMU with 1:1 Virt/Phys page mapping\n");
enable_mmu(0,memory_total);
printk("Enabling L1 dcache\n");
enable_l1_dcache();
#endif
/* Init the file descriptor table */
fd_table_init();
/* Initialize the ramdisk */
ramdisk_init(initrd_image,sizeof(initrd_image));
/* Mount the ramdisk */
mount("/dev/ramdisk","/","romfs",0,NULL);
/* Load the idle thread */
idle_process=load_process("idle",PROCESS_FROM_RAM,
(char *)&idle_task,8,4096);
init_process=load_process("shell",PROCESS_FROM_DISK,
NULL,0,8192);
load_process("printa",PROCESS_FROM_DISK,
NULL,0,8192);
load_process("printb",PROCESS_FROM_DISK,
NULL,0,8192);
/* Enter our "init" process*/
printk("\nEntering userspace by starting process %d!\n",
init_process);
process[idle_process].ready=1;
process[init_process].ready=1;
userspace_started=1;
/* run init and restore stack as we won't return */
run_process(init_process,0x8000);
/* we should never get here */
while(1) {
/* Loop Forever */
/* Should probably execute a wfi instruction */
}
}
//extern void drawModelSetMax(void);
int glInit(void){
cvar_register(&cvar_gl_MSAA_Samples);
cvar_pset(&cvar_gl_MSAA_Samples, "0");
// console_printf("cvar id is %i\n", cvar_gl_MSAA_Samples.myid);
// console_printf("cvar name is %s\n", cvar_gl_MSAA_Samples.name);
// console_printf("cvar value is %s\n", cvar_gl_MSAA_Samples.valuestring);
glewExperimental = TRUE;
GLenum glewError = glewInit();
CHECKGLERROR
if(glewError != GLEW_OK){
console_printf("ERROR with the glew: %s\n", glewGetErrorString(glewError));
return FALSE;
}
shader_init();
CHECKGLERROR
if(!shader_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
texture_init();
CHECKGLERROR
if(!texture_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
framebuffer_init();
CHECKGLERROR
if(!framebuffer_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
vbo_init();
CHECKGLERROR
if(!vbo_ok){
return FALSE;
//todo call some sort of shutdown of everything
}
ubo_init();
CHECKGLERROR
if(!ubo_ok){
return FALSE;
//todo call some sort of shutdown of everything
}
anim_init();
CHECKGLERROR
if(!anim_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
model_init();
CHECKGLERROR
if(!model_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
/*
initParticleSystem(128);
if(!particlesOK){
//todo call some sort of shutdown of everything
return FALSE;
}
*/
light_init();
CHECKGLERROR
if(!light_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
lighttile_init();
CHECKGLERROR
if(!lighttile_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
viewport_init();
CHECKGLERROR
if(!viewport_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
text_init();
CHECKGLERROR
if(!text_ok){
//todo call some sort of shutdown of everything
return FALSE;
}
rendermodel_init();
CHECKGLERROR
//todo errorcheck
drawbb_init();
CHECKGLERROR
//todo errorcheck
states_enableForce(GL_MULTISAMPLE);
glClearDepth(1.0);
glClearColor(0.0, 0.0, 0.0, 0.0);
CHECKGLERROR
// states_disableForce(GL_FOG);
states_enableForce(GL_DEPTH_TEST);
CHECKGLERROR
// glDepthFunc(GL_LESS);
states_depthFunc(GL_LESS);
states_enableForce(GL_CULL_FACE);
states_cullFace(GL_BACK);
// states_depthMask(GL_TRUE);
int maxSamples = 0, maxIntSamples = 0, maxColorTextureSamples = 0, maxDepthTextureSamples = 0;
glGetIntegerv(GL_MAX_SAMPLES, &maxSamples);
glGetIntegerv(GL_MAX_INTEGER_SAMPLES, &maxIntSamples);
glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &maxColorTextureSamples);
glGetIntegerv(GL_MAX_DEPTH_TEXTURE_SAMPLES, &maxDepthTextureSamples);
maxMSAASamples = maxSamples;
if(maxIntSamples < maxMSAASamples) maxMSAASamples = maxIntSamples;
if(maxColorTextureSamples < maxMSAASamples) maxMSAASamples = maxColorTextureSamples;
if(maxDepthTextureSamples < maxMSAASamples) maxMSAASamples = maxDepthTextureSamples;
console_printf("Max multisample samples: %i\n", maxMSAASamples);
cam = createAndAddViewportRPOINT("cam", 1);
camid = cam->myid;
cam->outfbid = findFramebufferByNameRINT("screen");
unsigned char dflags[] = {3, 7, 3};
// unsigned char drb = FRAMEBUFFERRBFLAGSDEPTH| 2;
unsigned char drb = FRAMEBUFFERRBFLAGSDEPTH;
unsigned char dcount = 3;
cam->dfbid = createAndAddFramebufferRINT("screend", dcount, drb, dflags);
resizeViewport(cam, 800, 600);
screenWidth = 800;
screenHeight = 600;
glGenBuffers(1, &instancevbo);
glGenBuffers(1, &instancevbo2);
//temporary
CHECKGLERROR
vbo_t * tvbo = createAndAddVBORPOINT("text", 2);
textvbo = tvbo->myid;
textshaderid = shader_createAndAddRINT("text");
fsblendshaderid = shader_createAndAddRINT("fsblend");
depthonlyid = shader_createAndAddRINT("depthmodel");
forwardmodelid = shader_createAndAddRINT("forwardmodel");
fsquadmodel = model_findByNameRINT("fsquad");
readyRenderQueueBuffers();
return TRUE; // so far so good
}
void gl_init(int win_w, int win_h)
{
WINDOW_WIDTH = win_w;
WINDOW_HEIGHT = win_h;
glfwInit();
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 0);
glfwOpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE);
//glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwOpenWindow(win_w, win_h, 8, 8, 8, 8, 32, 0, GLFW_WINDOW);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glEnable(GL_BLEND);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
glDepthFunc(GL_LEQUAL);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
static GLuint bufs[16] =
{GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2,
GL_COLOR_ATTACHMENT3, GL_COLOR_ATTACHMENT4, GL_COLOR_ATTACHMENT5,
GL_COLOR_ATTACHMENT6, GL_COLOR_ATTACHMENT7, GL_COLOR_ATTACHMENT8,
GL_COLOR_ATTACHMENT9, GL_COLOR_ATTACHMENT10, GL_COLOR_ATTACHMENT11,
GL_COLOR_ATTACHMENT12, GL_COLOR_ATTACHMENT13, GL_COLOR_ATTACHMENT14,
GL_COLOR_ATTACHMENT15};
glDrawBuffers(16, bufs);
// create unit square buffer
glGenBuffers(1, &UNIT_SQUARE);
glGenVertexArrays(1, &UNIT_SQUARE_VAO);
glBindVertexArray(UNIT_SQUARE_VAO);
glBindBuffer(GL_ARRAY_BUFFER, UNIT_SQUARE);
glBufferData(GL_ARRAY_BUFFER, sizeof(UNIT_SQUARE_VERTS), UNIT_SQUARE_VERTS, GL_STATIC_DRAW);
glEnableVertexAttribArray(CW_POSITION);
glEnableVertexAttribArray(CW_NORMAL);
glEnableVertexAttribArray(CW_UV);
glVertexAttribPointer(CW_POSITION, 3, GL_FLOAT, false, 32, (void *) 0);
glVertexAttribPointer(CW_NORMAL, 3, GL_SHORT, true, 32, (void *) 12);
glVertexAttribPointer(CW_UV, 2, GL_UNSIGNED_SHORT, true, 32, (void *) 18);
glVertexAttribPointer(CW_MATERIAL, 1, GL_UNSIGNED_SHORT, true, 32, (void *) 22);
glVertexAttribPointer(CW_BONEIDS, 2, GL_UNSIGNED_BYTE, false, 32, (void *) 24);
glVertexAttribPointer(CW_BONEWEIGHTS, 2, GL_UNSIGNED_BYTE, true, 32, (void *) 26);
glBindVertexArray(0);
//glBindBuffer(GL_ARRAY_BUFFER, 0);
drawmodel = malloc(sizeof(Shader));
shader_init(drawmodel, "clockwork/glsl/drawmodel");
shader_add_fragment_output(drawmodel, "outColor");
shader_add_fragment_output(drawmodel, "outNormal");
shader_add_texture_target(drawmodel, "inColor", 0);
/*{{{ XXX debug*/
printf("current\n");
int max_attribs;
glGetProgramiv(drawmodel->program, GL_ACTIVE_ATTRIBUTES, &max_attribs);
int i;
for(i = 0; i < max_attribs; i++)
{
GLchar buf[64];
GLint size;
GLenum type;
glGetActiveAttrib(drawmodel->program, i, 64, NULL, &size, &type, buf);
printf("attrib: %d, %s, %s\n", i, glbTypeString(type), buf);
}
printf("...\n");
/*}}}*/
glbdrawmodel = glbCreateProgram(NULL);
int err =
glbProgramAttachNewShaderSourceFile(glbdrawmodel,
"clockwork/glsl/drawmodel.vs",
GL_VERTEX_SHADER);
glbProgramAttachNewShaderSourceFile(glbdrawmodel,
"clockwork/glsl/drawmodel.fs",
GL_FRAGMENT_SHADER);
struct GLBVertexLayout vlayout[] =
{
{3, GL_FLOAT, false, 32, 0},
{3, GL_SHORT, true, 32, 12},
{2, GL_UNSIGNED_SHORT, true, 32, 18},
{1, GL_UNSIGNED_SHORT, false, 32, 22},
{2, GL_UNSIGNED_BYTE, false, 32, 24},
{2, GL_UNSIGNED_BYTE, true, 32, 26},
};
glbQUAD = glbCreateVertexBuffer(6, sizeof(gl_vertex_t),
UNIT_SQUARE_VERTS, 6, vlayout, GLB_STATIC_DRAW, NULL);
glbframebuffer = glbCreateFramebuffer(NULL);
GLBTexture *fb_color[4] = {
glbCreateTexture(0, GLB_RGBA, win_w, win_h, 1, NULL, NULL), // color
glbCreateTexture(0, GLB_RGBA, win_w, win_h, 1, NULL, NULL), // normal
glbCreateTexture(0, GLB_RGBA, win_w, win_h, 1, NULL, NULL), // light front
glbCreateTexture(0, GLB_RGBA, win_w, win_h, 1, NULL, NULL), // light back
};
GLBTexture *fb_depth = glbCreateTexture(0, GLB_DEPTH, win_w, win_h, 1, NULL, NULL);
GLBTexture *fb_stencil = glbCreateTexture(0, GLB_STENCIL, win_w, win_h, 1, NULL, NULL);
glbFramebufferTexture(glbframebuffer, fb_color[0]);
glbFramebufferTexture(glbframebuffer, fb_color[1]);
glbFramebufferTexture(glbframebuffer, fb_color[2]);
glbFramebufferTexture(glbframebuffer, fb_color[3]);
glbFramebufferTexture(glbframebuffer, fb_depth);
glbFramebufferTexture(glbframebuffer, fb_stencil);
// framebuffer is now owner of textures
glbReleaseTexture(fb_color[0]);
glbReleaseTexture(fb_color[1]);
glbReleaseTexture(fb_color[2]);
glbReleaseTexture(fb_color[3]);
glbReleaseTexture(fb_depth);
glbReleaseTexture(fb_stencil);
//process framebuffer
glGenFramebuffers(1, &processFBO);
framebuffer_init(&framebuffers[0], win_w, win_h);
framebuffer_init(&framebuffers[1], win_w, win_h);
framebuffer_addtextures(&framebuffers[0], 4,
TEXTURE_DEPTH, TEXTURE_RGBA, TEXTURE_RGBA, TEXTURE_RGBA);
framebuffer_addtextures(&framebuffers[1], 4,
TEXTURE_DEPTH, TEXTURE_RGBA, TEXTURE_RGBA, TEXTURE_RGBA);
gl_bindframebuffer(&framebuffers[0], FRAMEBUFFER_OUTPUT);
gl_bindframebuffer(&framebuffers[1], FRAMEBUFFER_INPUT);
}
