StreamSource::StreamSource(int nThread, int nFrames, int w, int h, uint32_t fmt, int fps) {
nWorkThread = nThread;
pic.width = w;
pic.height = h;
pic.fmt = fmt;
video.fps = fps;
video.tpf = 1000000 / fps;
streamInit(nFrames);
handlerList = HandlerList::createNew();
threadPollInit();
}
void fillStreamWithFile(Stream *stream, char *filename) {
FILE *file = fopen(filename, "rb");
if (file == NULL) {
DEBUG(("UNABLE TO OPEN FILE\n"));
return;
}
fseek(file, 0L, SEEK_END);
u32 length = ftell(file);
rewind(file);
streamInit(stream, length);
length = fread(stream->buffer, sizeof(u8), stream->length, file);
fclose(file);
if (length != stream->length) {
DEBUG(("CANNOT READ FILE\n"));
}
DEBUG(("READ FILE %d BYTES\n", length));
}
STREAM *wavestreamInit(USHORT streamType, MCI_AUDIO_INIT __far *mciInitPtr, WAVESTREAM *wsPtr) {
USHORT rc = 0;
STREAM *tstreamPtr = malloc(sizeof(STREAM)); // this gets free'd in wavestreamDeinit()
if (tstreamPtr) {
MEMSET(tstreamPtr,0,sizeof(STREAM));
rc = streamInit(streamType, tstreamPtr);
if (rc == 0) {
tstreamPtr->wsParentPtr = wsPtr;
// update WAVESTREAM
wsPtr->streamPtr = tstreamPtr;
// WAVEAUDIO waPtr-> data already setup (incl. dma, audiobuffer)
// but still need to set WAVESTREAM.waPtr -> wap (or war) structure (6-Feb-99)
if (streamType == AUDIOHW_WAVE_PLAY) {
wsPtr->waPtr = &wap;
}
else {
wsPtr->waPtr = &war;
}
//WAVECONFIG. data already setup, some of it? like silence
abReset(streamType & STREAM_RW_MODE, &wsPtr->waPtr->ab);
wsPtr->waveConfig.sampleRate = (USHORT)mciInitPtr->lSRate;
wsPtr->waveConfig.bitsPerSample = (UCHAR)mciInitPtr->lBitsPerSRate;
wsPtr->waveConfig.channels = (UCHAR)mciInitPtr->sChannels;
wsPtr->waveConfig.dataType = mciInitPtr->sMode;
wsPtr->audioBufferSize = 0; // 0=use default logical DMA size
wsPtr->bytesProcessed = 0;
wsPtr->timeBase = 0;
mciInitPtr->sSlotNumber = -1;
mciInitPtr->lResolution = 10;
mciInitPtr->ulFlags = mciInitPtr->ulFlags | FIXED | LEFT_ALIGNED;
// original had this if flags == 8...snafu (pas16 has 8 also)
if (mciInitPtr->ulFlags == 16) {
mciInitPtr->ulFlags = mciInitPtr->ulFlags | TWOS_COMPLEMENT;
}
}
// since rc only possible if streamInit() failed, don't need to use streamDeinit()
// but...streamInit() currently never fails...
if (rc) {
free(tstreamPtr);
tstreamPtr = 0;
}
}
return tstreamPtr;
}
int main( void )
{
u32 i, ii, ulClock;
u8 floatString[20];
// First test the descriptor page ( last page in FLASH )
// if configuration exists, use programmed ID, else query
// Debug registers for ID. This is a workaround for silicon
// issues in the F103 STM32s
RCC->APB2ENR |= (RCC_IOPBEN|RCC_IOPCEN|RCC_IOPAEN);
PYGMY_RCC_USART3_ENABLE;
PYGMY_RCC_USART2_ENABLE;
PYGMY_RCC_USART1_ENABLE;
PYGMY_RCC_GPIOA_ENABLE;
PYGMY_RCC_GPIOB_ENABLE;
//globalID = fpecMCUID( );
globalID = 0;
globalPLL = BIT16|BIT1;
// First Init the Clocks
if( globalID == 0x0416 ){
// L152
globalStrID = (u8*)STRID_L15X;
globalXTAL = 16000000;
globalFreq = 32000000;
ulClock = globalFreq;
FPEC->ACR = FPEC_ACR_PRFTBE | FPEC_ACR_LATENCY1;
} else if( globalID == 0x0420 || globalID == 0x0428 ){
// F100
globalStrID = (u8*)STRID_F100;
globalXTAL = 12000000;
globalFreq = 24000000;
ulClock = globalFreq;
} else{
// F103
globalStrID = (u8*)STRID_F103;
globalXTAL = 8000000;
globalFreq = 72000000; //72022900;
ulClock = 36000000;
globalPLL = RCC_PLL_X9|BIT16|BIT15|BIT14|BIT1;//BIT10|BIT1;
FPEC->ACR = FPEC_ACR_PRFTBE | FPEC_ACR_LATENCY2;
} // else
PYGMY_RCC_HSI_ENABLE;
PYGMY_RCC_HSE_ENABLE;
while( !PYGMY_RCC_HSE_READY );
RCC->CFGR2 = 0;
RCC->CFGR = globalPLL;
PYGMY_RCC_PLL_ENABLE;
while( !PYGMY_RCC_PLL_READY );
taskInit();
streamInit();
streamSetPut( COM1, putsUSART1 );
streamSetPutc( COM1, putcUSART1 );
streamSetGet( COM1, bootGetUSART1 );
streamDisableDefaultGet( COM1 );
streamSetSTDIO( COM1 );
// Basic Port Init
GPIOB->CRH &= ~( PIN10_CLEAR | PIN11_CLEAR );
GPIOB->CRH |= ( PIN10_OUT50_ALTPUSHPULL | PIN11_IN_FLOAT );
USART3->BRR = ( ( (ulClock >> 3 ) / BOOT_BAUDRATE ) << 4 ) + ( ( ( ulClock / BOOT_BAUDRATE ) ) & 0x0007 );
USART3->CR3 = USART_ONEBITE;
USART3->CR1 = ( USART_OVER8 | USART_UE | USART_RXNEIE | USART_TE | USART_RE );
GPIOA->CRH &= ~( PIN9_CLEAR | PIN10_CLEAR );
GPIOA->CRH |= ( PIN9_OUT50_ALTPUSHPULL | PIN10_IN_FLOAT );
USART1->BRR = ( ( (ulClock >> 3 ) / BOOT_BAUDRATE ) << 4 ) + ( ( ( ulClock / BOOT_BAUDRATE ) ) & 0x0007 );
USART1->CR3 = USART_ONEBITE;
USART1->CR1 = ( USART_OVER8 | USART_UE | USART_RXNEIE | USART_TE | USART_RE );
// End Basic Port Init
// HSI Must be ON for Flash Program/Erase Operations
// End Clock Init
// Configure Interrupts
// Do not read from NVIC LOAD or VAL!!!
// Reading from Write only registers causes unpredictable behavior!!!
NVIC->ISER[ 1 ] = 0x00000001 << 7;
NVIC->ISER[ 1 ] = 0x00000001 << 6;
NVIC->ISER[ 1 ] = 0x00000001 << 5;
SYSTICK->VAL = globalFreq / 1000;
SYSTICK->LOAD = globalFreq / 1000; // Based on ( 2X the System Clock ) / 1000
SYSTICK->CTRL = 0x07; // Enable system timer
// End Configure Interrupts
PYGMY_WATCHDOG_UNLOCK;
PYGMY_WATCHDOG_PRESCALER( IWDT_PREDIV128 );
PYGMY_WATCHDOG_TIMER( 0x0FFF );
PYGMY_WATCHDOG_START;
PYGMY_WATCHDOG_REFRESH;
println( STDIO, "Pygmy Boot Lite V%s\rMCU ", version );
println( STDIO, "%s\rPage Size %d\rFLASH %dKB\rRAM %dKB", globalStrID, fpecFlashSectorSize(), fpecFlashSize(), fpecRAMSize() );
println( STDIO, "\rMCUID: 0x%08X", fpecMCUID() );
xmodemInit( &XModem );
while( 1 ){
// Wait for commands
}
}
static uint8_t getByte(bool rs);
static void init0(void);
static void init1(void);
static void init2(void);
static void init3(void);
static void init4(void);
static void init5(void);
static void init6(void);
static void init7(void);
static Task task = {
.setup = setup,
.loop = loop,
};
static Stream _lcdout = streamInit(LCD_STREAM_SIZE);
Stream* lcdout = &_lcdout;
static LCDConfig lcdConfig;
Task* lcdTask(LCDConfig config) {
lcdConfig = config;
return &task;
}
static void setup(void) {
pinDirection(lcdConfig.rw, Output);
pinDirection(lcdConfig.rs, Output);
pinDirection(lcdConfig.e, Output);
#include "task1.h"
static void setup(void);
static void loop(void);
Task task1 = {
.setup = setup,
.loop = loop,
};
static uint32_t mDelay;
static uint16_t count;
static Stream _task1Stream = streamInit(5);
Stream* task1Stream = &_task1Stream;
static void setup(void) {
mDelay = 0;
count = 0;
streamClear(task1Stream);
}
static void loop(void) {
uint32_t ticks = getTicks();
if(ticks >= mDelay) {
print(stdout, "Task1 running (", count, ")\n");
mDelay = ticks + MS_TO_TICKS(1000);
count++;
}
u8 *broadwayCreateStream(u32 length) {
streamInit(&broadwayStream, length);
return broadwayStream.buffer;
}
