static void
destroy_frames(vda_decoder_t *vdad)
{
vda_frame_t *vf;
while((vf = LIST_FIRST(&vdad->vdad_frames)) != NULL)
destroy_frame(vf);
}
static void
destroy_frames(vtb_decoder_t *vtbd)
{
vtb_frame_t *vf;
while((vf = LIST_FIRST(&vtbd->vtbd_frames)) != NULL)
destroy_frame(vf);
}
static inline void _fl_cleanNodes(GSM0710_FrameList *list)
{
GSM0710_Frame *frame;
while (!_fl_isEmpty(list)) {
frame = _fl_popFrame(list);
destroy_frame(frame);
}
}
void destroy_thing(WThing *t)
{
if(WTHING_IS(t, WTHING_FRAME))
destroy_frame((WFrame*)t);
else if(WTHING_IS(t, WTHING_DOCK))
destroy_dock((WDock*)t);
else if(WTHING_IS(t, WTHING_MENU))
destroy_menu_tree((WMenu*)t);
else if(WTHING_IS(t, WTHING_CLIENTWIN))
unmanage_clientwin((WClientWin*)t);
}
void free_tac() {
free(f_list);
free(ta_table);
while (!stack_empty(frame_stack)) {
rm_frame();
}
stack_dispose(frame_stack);
destroy_frame(prep_frame);
}
// Baseline DCT
void parse_sof0(struct c63_common *cm)
{
uint16_t size;
size = (get_byte(cm->e_ctx.fp) << 8) | get_byte(cm->e_ctx.fp);
uint8_t precision = get_byte(cm->e_ctx.fp);
if (precision != 8)
{
printf("Only 8-bit precision supported\n");
exit(1);
}
uint16_t height = (get_byte(cm->e_ctx.fp) << 8) | get_byte(cm->e_ctx.fp);
uint16_t width = (get_byte(cm->e_ctx.fp) << 8) | get_byte(cm->e_ctx.fp);
// Discard subsampling info. We assume 4:2:0
uint8_t buf[10];
read_bytes(cm->e_ctx.fp, buf, 10);
/* First frame? */
if (cm->framenum == 0)
{
cm->width = width;
cm->height = height;
cm->padw[0] = cm->ypw = (uint32_t)(ceil(width/16.0f)*16);
cm->padh[0] = cm->yph = (uint32_t)(ceil(height/16.0f)*16);
cm->padw[1] = cm->upw = (uint32_t)(ceil(width*UX/(YX*8.0f))*8);
cm->padh[1] = cm->uph = (uint32_t)(ceil(height*UY/(YY*8.0f))*8);
cm->padw[2] = cm->vpw = (uint32_t)(ceil(width*VX/(YX*8.0f))*8);
cm->padh[2] = cm->vph = (uint32_t)(ceil(height*VY/(YY*8.0f))*8);
cm->mb_cols = cm->ypw / 8;
cm->mb_rows = cm->yph / 8;
cm->curframe = 0;
}
/* Advance to next frame */
destroy_frame(cm->refframe);
cm->refframe = cm->curframe;
cm->curframe = create_frame(cm, 0);
/* Is this a keyframe */
cm->curframe->keyframe = get_byte(cm->e_ctx.fp);
}
void _fc_cacheFrameData(
Channel * channel,
GSM0710_Frame * frame)
{
LOGMUX(LOG_DEBUG, "Enter");
/* All data sent from the modem before receiving the MSC with FC OFF Rsp will be inserted into the link list */
if ((channel->rx_fl_total + frame->length) > RX_FLOW_CTRL_HIGH_WATERMARK) {
LOGMUX(LOG_DEBUG, "Accumulated_pending_frame_bytes is larger than mark val=%d, drop it",
RX_FLOW_CTRL_HIGH_WATERMARK);
serial.in_buf->dropped_count++;
//mtk02863
//Gsm0710Muxd_Assert(19);
} else {
channel->rx_fl_total += frame->length;
channel->rx_fl = _fl_pushFrame(channel->rx_fl, frame);
}
LOGMUX(LOG_INFO, "Case2:Frame List=0x%08X, pending_frame_bytes=%d, frame_len=%d",
(unsigned int)channel->rx_fl, channel->rx_fl_total, frame->length);
destroy_frame(frame);
return;
}
/* The shell's main routine. Consists of several steps:
* 1> Reads JPEGs using first command-line parameter(s)
* 2> Records the process's elapsed time
* 3> Lets the user play with the images
* 4> Checks the elapsed time again, prints out the difference
* 5> Writes JPEGs out using last command-line parameter(s)
*/
int main(int argc, char *argv[]) {
int i;
int num_inputs; /* Number of JPEG input-output files */
int num_runs, run; /* Number of runs, for multi-run code */
double run_time, total_time; /* Amount of time we've run */
struct timeval start_time, end_time; /* Time before/after user code */
/* Step 0A: Check & process command line */
if (argc != 1 + NUM_INPUTS + NUM_OUTPUTS + RUNS_COMMAND + RUNS_PROCS) {
fprintf(stderr, "Usage: %s runs procs input1.jpg %soutput.jpg\n",
argv[0],
NUM_INPUTS > 1 ? "input2.jpg " : "");
exit(1);
}
num_inputs = argc - 1 - NUM_OUTPUTS - RUNS_COMMAND - RUNS_PROCS;
num_runs = atoi(argv[1]);
if (num_runs < 1) num_runs = 1;
if (num_runs > 10) num_runs = 10; /* Change if you like LOTS of runs */
fprintf(stderr, "Making %d runs . . .\n", num_runs);
num_procs = atoi(argv[1 + RUNS_COMMAND]);
if (num_procs < 1) num_procs = 1;
if (num_procs > 256) num_procs = 256;
fprintf(stderr, "Using %d processors . . .\n", num_procs);
/* Step 1: Get some JPEGs into memory, uncompressed */
for (i=0; i < num_inputs; i++)
input_frames[i] = read_JPEG_file(argv[i+1+RUNS_COMMAND+RUNS_PROCS]);
/* Step 2: Allocate output frames */
for (i=0; i < NUM_OUTPUTS; i++)
output_frames[i] = allocate_frame(input_frames[i]->image_height,
input_frames[i]->image_width,
input_frames[i]->num_components);
/* Loop over multiple runs, if desired */
total_time = 0.0;
run = 0;
while ((run < num_runs)) {
/* Step 3: Record elapsed time */
gettimeofday(&start_time, NULL);
/* Step 4: Call a user function! */
EEE4084F_parallel();
/* Step 5: Check & print elapsed time */
gettimeofday(&end_time, NULL);
run_time = ((double)(end_time.tv_sec) + (double)(end_time.tv_usec)/1000000.0)
- ((double)(start_time.tv_sec) + (double)(start_time.tv_usec)/1000000.0);
fprintf(stderr, "%d. ELAPSED TIME = %20.3f sec\n", run, run_time);
total_time += run_time;
#ifdef NO_FIRST
if (run == 0) {
fprintf(stderr, " . . . first run discarded\n");
total_time = 0.0;
}
#endif
run++;
}
/* Print out final, average time, if desired */
#ifdef NO_FIRST
fprintf(stderr, "AVERAGE ELAPSED TIME = %20.3f seconds\n",
total_time / ((double)(run - 1)));
#else
fprintf(stderr, "AVERAGE ELAPSED TIME = %20.3f seconds\n",
total_time / ((double)run));
#endif
/* Step 6: Write JPEGs out from memory buffers */
for (i=0; i < NUM_OUTPUTS; i++)
write_JPEG_file(argv[argc - NUM_OUTPUTS + i], output_frames[i], OUT_QUALITY);
destroy_frame(input_frames[0]);
printf("input_frame[0]!\n");
destroy_frame(output_frames[0]);
printf("output_frame[0]!\n");
}
void rm_frame() {
destroy_frame(stack_pop(frame_stack));
}
