// load a texture from given text, font, and color
bool Texture::txLoadT(std::string text, TTF_Font* font, SDL_Color color)
{
txFree();
SDL_Surface* textSurface = TTF_RenderText_Blended_Wrapped(font, text.c_str(), color, 1024);
if (textSurface != NULL)
{
txTexture = SDL_CreateTextureFromSurface(Window::renderer, textSurface);
if (txTexture == NULL)
{
std::cout << "Unable to create texture from rendered text! SDL Error: " << SDL_GetError() << std::endl;
}
else
{
if (txRect.w == NULL || txRect.h == NULL)
{
txRect.w = textSurface->w;
txRect.h = textSurface->h;
}
}
SDL_FreeSurface(textSurface);
}
else
{
std::cout << "Unable to render text surface! SDL_TTF Error: " << TTF_GetError() << std::endl;
}
return txTexture != NULL;
}
FxBool txConvertFromFile( FILE *file, Gu3dfInfo *info,
FxU32 flags, const void *palNcc )
{
long file_start_position;
FxBool retval;
TxMip txMip;
/*
* Save the current position of the input file so that we can
* later recent it.
*/
file_start_position = ftell( file );
txMipReadFromFP( &txMip, "(FILE*)", file, GR_TEXFMT_ANY );
retval = txConvert( info, txMip.format, txMip.width, txMip.height,
txMip.data[0], flags, palNcc );
txFree( txMip.data[0] );
return retval;
}
// load a texture from the given file path
bool Texture::txLoadF(std::string path)
{
bool success = true;
txFree();
SDL_Texture* createdTexture = NULL;
SDL_Surface* imageSurface = IMG_Load(path.c_str());
if (imageSurface == NULL)
{
std::cout << "Error loading image at the specified path: " << path << std::endl;
std::cout << "IMG_GetError: " << IMG_GetError() << std::endl;
success = false;
}
else
{
// SDL_SetColorKey(imageSurface, SDL_TRUE, SDL_MapRGB(imageSurface->format, 0, 255, 255));
createdTexture = SDL_CreateTextureFromSurface(Window::renderer, imageSurface);
if (createdTexture == NULL)
{
std::cout << "Error creating texture from surface. SDL_GetError: " << SDL_GetError() << std::endl;
}
else
{
if (txRect.w == NULL || txRect.h == NULL)
{
txRect.w = imageSurface->w;
txRect.h = imageSurface->h;
}
}
}
SDL_FreeSurface(imageSurface);
txTexture = createdTexture;
return success;
}
// free everything
Texture::~Texture()
{
txFree();
}
FxBool txConvert( Gu3dfInfo *info, GrTextureFormat_t srcFormat,
int srcWidth, int srcHeight,
const void *srcImage, FxU32 flags,
const void *palNcc )
{
TxMip srcMip;
TxMip trueColorMip;
TxMip outputMip;
TxMip tmpMip;
/*
* Make a txMip out of the passed data.
*/
memset( &srcMip, 0, sizeof( srcMip ) );
srcMip.format = srcFormat;
srcMip.width = srcWidth;
srcMip.height = srcHeight;
srcMip.depth = 1;
if( palNcc )
{
switch( srcFormat )
{
case GR_TEXFMT_YIQ_422:
case GR_TEXFMT_AYIQ_8422:
txNccToPal( srcMip.pal, palNcc);
break;
case GR_TEXFMT_P_8:
memcpy( srcMip.pal, palNcc, sizeof( FxU32 ) * 256 );
break;
}
}
srcMip.data[0] = ( void * )srcImage;
/*
* Set up a txMip to put a true color version of the texture in.
*/
memset( &trueColorMip, 0, sizeof( trueColorMip ) );
trueColorMip.format = GR_TEXFMT_ARGB_8888;
trueColorMip.width = srcWidth;
trueColorMip.height = srcHeight;
/*
* Set the depth to the mipmapped depth to allocate the image.
*/
#ifdef GLIDE3
trueColorMip.depth = info->header.large_lod - info->header.small_lod + 1;
#else
trueColorMip.depth = info->header.small_lod - info->header.large_lod + 1;
#endif
if( !txMipAlloc( &trueColorMip ) )
return FXFALSE;
/*
* Set to one level only since we only want to dequant the first
* level.
*/
trueColorMip.depth = 1;
/*
* Convert from the input format to truecolor.
*/
txMipDequantize( &trueColorMip, &srcMip );
/*
* We realy have more than one level, so. . .
*/
#ifdef GLIDE3
trueColorMip.depth = info->header.large_lod - info->header.small_lod + 1;
#else
trueColorMip.depth = info->header.small_lod - info->header.large_lod + 1;
#endif
/*
* WARNING! I do not free srcMip.data[0] since it is passed in by the users.
*/
/*
* Resample the true color version of the input image to
* the passed in size. . . . this should be a valid
* size for the hardware to handle.
*/
tmpMip = trueColorMip;
tmpMip.width = info->header.width;
tmpMip.height = info->header.height;
txMipAlloc( &tmpMip );
if( ( flags & TX_CLAMP_MASK ) == TX_CLAMP_DISABLE )
{
txMipResample( &tmpMip, &trueColorMip );
}
else
{
txMipClamp( &tmpMip, &trueColorMip );
#if 0
txMipView( &tmpMip, "blah", FXTRUE, 0 );
#endif
}
#if 0
if( _heapchk() != _HEAPOK )
txPanic( "_heapchk failed" );
#endif
txFree( trueColorMip.data[0] );
trueColorMip = tmpMip;
/*
* Generate mipmap levels.
*/
#ifdef GLIDE3
trueColorMip.depth = info->header.large_lod - info->header.small_lod + 1;
#else
trueColorMip.depth = info->header.small_lod - info->header.large_lod + 1;
#endif
txMipMipmap( &trueColorMip );
#if 0
txMipView( &trueColorMip, "blah", FXTRUE, 0 );
#endif
/*
* Convert from true color to the output color format.
*/
memset( &outputMip, 0, sizeof( outputMip ) );
outputMip.format = info->header.format;
outputMip.width = info->header.width;
outputMip.height = info->header.height;
outputMip.depth = trueColorMip.depth;
outputMip.data[0] = info->data;
#if 0
txMipAlloc( &outputMip );
#else
txMipSetMipPointers( &outputMip );
#endif
if( ( flags & TX_TARGET_PALNCC_MASK ) == TX_TARGET_PALNCC_SOURCE )
{
txMipTrueToFixedPal( &outputMip, &trueColorMip, palNcc,
flags & TX_FIXED_PAL_QUANT_MASK );
}
else
{
txMipQuantize( &outputMip, &trueColorMip, outputMip.format,
flags & TX_DITHER_MASK, flags & TX_COMPRESSION_MASK );
}
info->data = outputMip.data[0];
if( ( info->header.format == GR_TEXFMT_YIQ_422 ) ||
( info->header.format == GR_TEXFMT_AYIQ_8422 ) )
{
txPalToNcc( &info->table.nccTable, outputMip.pal );
}
if( info->header.format == GR_TEXFMT_P_8 || info->header.format == GR_TEXFMT_AP_88 )
{
memcpy( info->table.palette.data, outputMip.pal, sizeof( FxU32 ) * 256 );
}
txFree( trueColorMip.data[0] );
return FXTRUE;
}
static void txDaemon(void *arg) {
struct bfin_ethernetSoftc *sc;
struct ifnet *ifp;
struct mbuf *m, *first;
rtems_event_set events;
void *ethBase;
void *txdmaBase;
txStatusT *status;
int head;
int prevHead;
int tail;
int length;
char *ptr;
sc = (struct bfin_ethernetSoftc *) arg;
ifp = &sc->arpcom.ac_if;
ethBase = sc->ethBase;
txdmaBase = sc->txdmaBase;
head = 0;
prevHead = sc->txDescCount - 1;
tail = 0;
while (1) {
/* wait for packet or isr */
rtems_bsdnet_event_receive(START_TRANSMIT_EVENT | INTERRUPT_EVENT,
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT, &events);
/* if no descriptors are available, try to free one. To reduce
transmit latency only do one here. */
if (sc->tx[head].inUse && txFree(sc, tail)) {
if (++tail == sc->txDescCount)
tail = 0;
}
/* send packets until the queue is empty or we run out of tx
descriptors */
while (!sc->tx[head].inUse && (ifp->if_flags & IFF_OACTIVE)) {
/* get the next mbuf chain to transmit */
IF_DEQUEUE(&ifp->if_snd, m);
if (m != NULL) {
/* copy packet into our buffer */
ptr = sc->tx[head].buffer.packet.data;
length = 0;
first = m;
while (m && length <= BFIN_ETHERNET_MAX_FRAME_LENGTH) {
length += m->m_len;
if (length <= BFIN_ETHERNET_MAX_FRAME_LENGTH)
memcpy(ptr, m->m_data, m->m_len);
ptr += m->m_len;
m = m->m_next;
}
m_freem(first); /* all done with mbuf */
if (length <= BFIN_ETHERNET_MAX_FRAME_LENGTH) {
sc->tx[head].buffer.packet.length = length;
/* setup tx dma */
status = (txStatusT *) sc->tx[head].status.addr;
status->status = 0;
sc->tx[head].inUse = true;
rtems_cache_flush_multiple_data_lines(status, sizeof(*status));
/* configure dma to stop after sending this packet */
sc->tx[head].status.dmaConfig = DMA_MODE_STATUS_LAST;
rtems_cache_flush_multiple_data_lines(
&sc->tx[head].status.dmaConfig,
sizeof(sc->tx[head].status.dmaConfig));
rtems_cache_flush_multiple_data_lines(
&sc->tx[head].buffer.packet,
length + sizeof(uint16_t));
/* modify previous descriptor to let it continue
automatically */
sc->tx[prevHead].status.dmaConfig = DMA_MODE_STATUS;
rtems_cache_flush_multiple_data_lines(
&sc->tx[prevHead].status.dmaConfig,
sizeof(sc->tx[prevHead].status.dmaConfig));
/* restart dma if it stopped before the packet we just
added. this is purely to reduce transmit latency,
as it would be restarted anyway after this loop (and
needs to be, as there's a very small chance that the
dma controller had started the last status transfer
before the new dmaConfig word was written above and
is still doing that status transfer when we check the
status below. this will be caught by the check
outside the loop as that is guaranteed to run at least
once after the last dma complete interrupt. */
if ((BFIN_REG16(txdmaBase, DMA_IRQ_STATUS_OFFSET) &
DMA_IRQ_STATUS_DMA_RUN) == 0 &&
BFIN_REG32(txdmaBase, DMA_NEXT_DESC_PTR_OFFSET) !=
(uint32_t) sc->tx[head].data.next) {
BFIN_REG16(txdmaBase, DMA_CONFIG_OFFSET) = DMA_MODE_TX;
BFIN_REG32(ethBase, EMAC_OPMODE_OFFSET) |= EMAC_OPMODE_TE;
}
if (++head == sc->txDescCount)
head = 0;
if (++prevHead == sc->txDescCount)
prevHead = 0;
/* if no descriptors are available, try to free one */
if (sc->tx[head].inUse && txFree(sc, tail)) {
if (++tail == sc->txDescCount)
tail = 0;
}
} else {
/* dropping packet: too large */
}
} else {
/* no packets queued */
ifp->if_flags &= ~IFF_OACTIVE;
}
}
/* if dma stopped and there's more to do, restart it */
if ((BFIN_REG16(txdmaBase, DMA_IRQ_STATUS_OFFSET) &
DMA_IRQ_STATUS_DMA_RUN) == 0 &&
BFIN_REG32(txdmaBase, DMA_NEXT_DESC_PTR_OFFSET) !=
(uint32_t) &sc->tx[head].data) {
BFIN_REG16(txdmaBase, DMA_CONFIG_OFFSET) = DMA_MODE_TX;
BFIN_REG32(ethBase, EMAC_OPMODE_OFFSET) |= EMAC_OPMODE_TE;
}
/* free up any additional tx descriptors */
while (txFree(sc, tail)) {
if (++tail == sc->txDescCount)
tail = 0;
}
}
}
