Val _lib7_P_Process_exece (Task* task, Val arg) {
//=====================
//
// _lib7_P_Process_exece : String * String list * String list -> 'a
//
// Overlay a new process image, using specified environment.
//
// This fn gets bound as exece in:
//
// src/lib/std/src/posix-1003.1b/posix-process.pkg
Val path = GET_TUPLE_SLOT_AS_VAL( arg, 0 );
Val arglst = GET_TUPLE_SLOT_AS_VAL( arg, 1 );
Val envlst = GET_TUPLE_SLOT_AS_VAL( arg, 2 );
// Use the heap for temp space for
// the argv[] and envp[] vectors:
//
char** cp = (char**)(task->heap_allocation_pointer);
#ifdef SIZES_C_64_MYTHRYL_32
//
// 8-byte align it:
//
cp = (char**) ROUND_UP_TO_POWER_OF_TWO((Unt2)cp, POINTER_BYTESIZE);
#endif
char** argv = cp;
//
for (Val p = arglst; p != LIST_NIL; p = LIST_TAIL(p)) {
*cp++ = HEAP_STRING_AS_C_STRING(LIST_HEAD(p));
}
*cp++ = 0; // Terminate the argv[].
char** envp = cp;
//
for (Val p = envlst; p != LIST_NIL; p = LIST_TAIL(p)) {
*cp++ = HEAP_STRING_AS_C_STRING(LIST_HEAD(p));
}
*cp++ = 0; // Terminate the envp[].
int status = execve( HEAP_STRING_AS_C_STRING(path), argv, envp );
CHECK_RETURN (task, status)
}
static Hugechunk* allocate_a_hugechunk (
// ====================
//
Hugechunk* free,
Hugechunk_Header* header,
Hugechunk_Quire_Relocation_Info* old_region
) {
Hugechunk* new_chunk;
Hugechunk_Relocation_Info* reloc_info;
int first_ram_quantum;
int total_bytesize
=
ROUND_UP_TO_POWER_OF_TWO(
//
header->bytesize,
HUGECHUNK_RAM_QUANTUM_IN_BYTES
);
int npages = total_bytesize >> LOG2_HUGECHUNK_RAM_QUANTUM_IN_BYTES;
Hugechunk_Quire* hq = free->hugechunk_quire;
if (free->bytesize == total_bytesize) {
// Allocate the whole
// free area to the chunk:
//
new_chunk = free;
} else {
// Split the free chunk:
//
new_chunk = MALLOC_CHUNK( Hugechunk );
new_chunk->chunk = free->chunk;
new_chunk->hugechunk_quire = hq;
//
free->chunk = (Punt)(free->chunk) + total_bytesize;
free->bytesize -= total_bytesize;
//
first_ram_quantum = GET_HUGECHUNK_FOR_POINTER_PAGE( hq, new_chunk->chunk );
for (int i = 0; i < npages; i++) {
//
hq->hugechunk_page_to_hugechunk[ first_ram_quantum + i ]
=
new_chunk;
}
}
new_chunk->bytesize = header->bytesize;
new_chunk->hugechunk_state = JUNIOR_HUGECHUNK;
new_chunk->age = header->age;
new_chunk->huge_ilk = header->huge_ilk;
hq->free_pages -= npages;
// Set up the relocation info:
//
reloc_info = MALLOC_CHUNK( Hugechunk_Relocation_Info );
reloc_info->old_address = header->base_address;
reloc_info->new_chunk = new_chunk;
//
first_ram_quantum = GET_HUGECHUNK_FOR_POINTER_PAGE(old_region, header->base_address);
//
for (int i = 0; i < npages; i++) {
//
old_region->hugechunk_page_to_hugechunk[ first_ram_quantum + i ]
=
reloc_info;
}
return new_chunk;
} // fun allocate_a_hugechunk
VIDEO_ENCODER_CODEC_ERROR_T MPEG4HWEncEncodeOneUnit(VIDEO_BUFFERHEADER_TYPE_T *prBufferHeader)
{
VIDEO_ENCODER_CODEC_ERROR_T eRet = VIDEO_ENCODER_CODEC_ERROR_NONE;
// kal_uint8* pu1Buffer;
kal_uint8* pu1StartAddr;
kal_uint8* pu1EndAddr;
kal_uint8* pu1WritePtr;
kal_uint8* pu1ReadAddr;
kal_uint8* pu1NextWritePtr;
kal_uint32 u4AvailLen, u4BuffLen;
kal_uint32 u4NextAvailLen;
kal_uint8* pu1Addr;
ASSERT(rpMPEG4HWEncDriver);
if(prBufferHeader)
video_dbg_trace(VIDEO_DBG_OWNER_ENCODER, VIDEO_DBG_HWENCV2_ENCODEONEUNIT, (kal_uint32) prBufferHeader->pu1Buffer);
if(!prBufferHeader && !rMPEG4HWEncCtrl.pu1YUV)
return VIDEO_ENCODER_CODEC_ERROR_NONE;
if(!mpeg4_encore_check_encoder_status() ||
!mepg4_encore_check_bits_buffer_status())
{
//return VIDEO_ENCODER_CODEC_PAUSE_ENCODE; //hw in use
ASSERT(0);
}
VideoEncoderAllocateBitstreamBuffer(&pu1StartAddr, &pu1EndAddr, &pu1WritePtr, &pu1ReadAddr, &u4BuffLen);
ASSERT(KAL_FALSE == VideoCommIsExtBufferCacheable((kal_uint32)pu1StartAddr, ROUND_UP_TO_POWER_OF_TWO(u4BuffLen,CPU_CACHE_LINE_SIZE)));
if ((kal_uint32)pu1ReadAddr <= (kal_uint32)pu1WritePtr)
{
u4AvailLen = (kal_uint32)pu1EndAddr - (kal_uint32)pu1WritePtr;
pu1Addr = pu1EndAddr;
#if 0
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
#endif
}
else // (u4WP < u4RP)
{
u4AvailLen = (kal_uint32)pu1ReadAddr - (kal_uint32)pu1WritePtr;
pu1Addr = pu1ReadAddr;
}
VideoEncoderQueryBitstreamNewWP((pu1WritePtr+u4AvailLen), &pu1NextWritePtr, &u4NextAvailLen);
if( (rMPEG4HWEncCtrl.eScenario == VIDEO_ENCODER_SCENARIO_VT && u4AvailLen <ENC_MIN_BUF_SIZE_VT) ||
(rMPEG4HWEncCtrl.eScenario == VIDEO_ENCODER_SCENARIO_ENCODER && u4AvailLen < ENC_MAX_VOP_SIZE) )
{
// next free buffer is not continuous
if (pu1NextWritePtr != pu1WritePtr+1)
{
VideoEncoderUpdateBitstreamWP((pu1WritePtr+u4AvailLen), 0);
}
VideoEncoderAllocateBitstreamBuffer(&pu1StartAddr, &pu1EndAddr, &pu1WritePtr, &pu1ReadAddr, &u4BuffLen);
if ((kal_uint32)pu1ReadAddr <= (kal_uint32)pu1WritePtr)
{
u4AvailLen = (kal_uint32)pu1EndAddr - (kal_uint32)pu1WritePtr;
pu1Addr = pu1EndAddr;
}
else // (u4WP < u4RP)
{
u4AvailLen = (kal_uint32)pu1ReadAddr - (kal_uint32)pu1WritePtr;
pu1Addr = pu1ReadAddr;
}
if( (rMPEG4HWEncCtrl.eScenario == VIDEO_ENCODER_SCENARIO_VT && u4AvailLen <ENC_MIN_BUF_SIZE_VT) ||
(rMPEG4HWEncCtrl.eScenario == VIDEO_ENCODER_SCENARIO_ENCODER && u4AvailLen < ENC_MAX_VOP_SIZE) )
{
MPEG4EncCallbackEncPause(pu1StartAddr);
drv_trace1(TRACE_GROUP_10, MPEG4HWENC_ENCODE_BUF_NOT_ENOUGH, u4AvailLen);
return VIDEO_ENCODER_CODEC_BS_BUFFER_NOT_ENOUGH;
}
}
rMPEG4HWEncCtrl.pu1Buffer = prBufferHeader->pu1Buffer;
rMPEG4HWEncCtrl.u8TimeStamp = prBufferHeader->u8TimeStamp;
rMPEG4HWEncCtrl.pu1YUV = 0;
drv_trace2(TRACE_GROUP_10, MPEG4HWENC_ENCODE, (kal_uint32)(rMPEG4HWEncCtrl.pu1Buffer), rMPEG4HWEncCtrl.u8TimeStamp);
rpMPEG4HWEncDriver->encode( rMPEG4HWEncCtrl.pu1Buffer, rMPEG4HWEncCtrl.u8TimeStamp, pu1WritePtr, pu1Addr);
return eRet;
}
