real_t
predict_range (real_t max_costs, real_t price, range_t *range, wfa_t *wfa,
coding_t *c, unsigned band, int y_state, unsigned states,
const tree_t *tree_model, const tree_t *p_tree_model,
const void *domain_model, const void *d_domain_model,
const void *coeff_model, const void *d_coeff_model)
{
unsigned state; /* counter */
void *rec_domain_model; /* domain model after recursion */
void *rec_d_domain_model; /* p domain model after recursion */
void *rec_coeff_model; /* coeff model after recursion */
void *rec_d_coeff_model; /* d coeff model after recursion */
tree_t rec_tree_model; /* tree_model after '' */
tree_t rec_p_tree_model; /* p_tree_model after '' */
unsigned rec_states; /* wfa->states after '' */
real_t *rec_pixels; /* c->pixels after '' */
state_data_t *rec_state_data; /* state_data struct after '' */
real_t costs; /* current approximation costs */
unsigned level; /* counter */
state_data_t *sd; /* pointer to state_data field */
/*
* Store WFA data from state 'lc_states' to 'wfa->states' - 1 and
* current state of probability models.
*/
rec_domain_model = c->domain_pool->model;
rec_d_domain_model = c->d_domain_pool->model;
rec_coeff_model = c->coeff->model;
rec_d_coeff_model = c->d_coeff->model;
rec_tree_model = c->tree;
rec_p_tree_model = c->p_tree;
rec_states = wfa->states;
rec_pixels = c->pixels;
rec_state_data = store_state_data (states, rec_states - 1,
c->options.lc_max_level, wfa, c);
/*
* Restore probability models to the state before the recursive subdivision
* has been started.
*/
wfa->states = states;
c->tree = *tree_model;
c->p_tree = *p_tree_model;
c->domain_pool->model = c->domain_pool->model_duplicate (domain_model);
c->d_domain_pool->model = c->d_domain_pool->model_duplicate (d_domain_model);
c->coeff->model = c->coeff->model_duplicate (c->coeff, coeff_model);
c->d_coeff->model = c->d_coeff->model_duplicate (c->d_coeff,
d_coeff_model);
if (c->mt->frame_type == I_FRAME)
costs = nd_prediction (max_costs, price, band, y_state, range, wfa, c);
else
costs = mc_prediction (max_costs, price, band, y_state, range, wfa, c);
c->pixels = rec_pixels;
if (costs < MAXCOSTS)
{
/*
* Free the memory used by the state_data struct
*/
for (state = states; state < rec_states; state++)
{
sd = &rec_state_data [state - states];
for (level = c->options.images_level + 1;
level <= c->options.lc_max_level; level++)
if (sd->ip_states_state [level] != NULL)
Free (sd->ip_states_state [level]);
if (sd->images_of_state != NULL)
Free (sd->images_of_state);
if (sd->inner_products != NULL)
Free (sd->inner_products);
}
if (states < rec_states)
Free (rec_state_data);
c->domain_pool->model_free (rec_domain_model);
c->d_domain_pool->model_free (rec_d_domain_model);
c->coeff->model_free (rec_coeff_model);
c->d_coeff->model_free (rec_d_coeff_model);
costs = (range->tree_bits + range->matrix_bits + range->weights_bits
+ range->mv_tree_bits + range->mv_coord_bits
+ range->nd_tree_bits + range->nd_weights_bits) * price
+ range->err;
}
else
{
/*
* Restore WFA to state before function was called
*/
c->domain_pool->model_free (c->domain_pool->model);
c->d_domain_pool->model_free (c->d_domain_pool->model);
c->coeff->model_free (c->coeff->model);
c->d_coeff->model_free (c->d_coeff->model);
c->domain_pool->model = rec_domain_model;
c->d_domain_pool->model = rec_d_domain_model;
c->coeff->model = rec_coeff_model;
c->d_coeff->model = rec_d_coeff_model;
c->tree = rec_tree_model;
c->p_tree = rec_p_tree_model;
range->prediction = NO;
if (wfa->states != states)
remove_states (states, wfa);
restore_state_data (states, rec_states - 1, c->options.lc_max_level,
rec_state_data, wfa, c);
costs = MAXCOSTS;
}
return costs;
}
image_t *
get_next_frame (bool_t store_wfa, int enlarge_factor,
int smoothing, const char *reference_frame,
format_e format, video_t *video, dectimer_t *timer,
wfa_t *orig_wfa, bitfile_t *input)
/*
* Get next frame of the WFA 'video' from stream 'input'.
* 'orig_wfa' is the constant part of the WFA used by all frames.
* Depending on values of 'enlarge_factor' and 'smoothing' enlarge and
* smooth image, respectively.
* If 'store_wfa' is TRUE, then store WFA structure of reference frames
* (used by analysis tool xwfa).
* If 'reference_frame' is not NULL, then load image 'reference_frame'
* from disk.
* 'format' gives the color format to be used (either 4:2:0 or 4:4:4).
* If 'timer' is not NULL, then accumulate running time statistics.
*
* Return value:
* pointer to decoded frame
*
* Side effects:
* 'video' and 'timer' struct are modified.
*/
{
image_t *frame = NULL; /* current frame */
image_t *sframe = NULL; /* current smoothed frame */
bool_t current_frame_is_future_frame = NO;
if (video->future_display == video->display)
{
/*
* Future frame is already computed since it has been used
* as reference frame. So just return the stored frame.
*/
if (video->frame) /* discard current frame */
free_image (video->frame);
video->frame = video->future;
video->future = NULL;
if (video->sframe) /* discard current (smoothed) frame */
free_image (video->sframe);
video->sframe = video->sfuture;
video->sfuture = NULL;
if (store_wfa)
copy_wfa (video->wfa, video->wfa_future);
video->display++;
if (!store_wfa)
video->wfa = NULL;
}
else
{
do /* compute next frame(s) */
{
unsigned frame_number; /* current frame number */
clock_t ptimer;
unsigned int stop_timer [3];
wfa_t *tmp_wfa = NULL;
if (!store_wfa)
video->wfa = orig_wfa;
else
{
tmp_wfa = alloc_wfa (NO);
copy_wfa (tmp_wfa, video->wfa);
copy_wfa (video->wfa, orig_wfa);
}
/*
* First step: read WFA from disk
*/
prg_timer (&ptimer, START);
frame_number = read_next_wfa (video->wfa, input);
stop_timer [0] = prg_timer (&ptimer, STOP);
if (timer)
{
timer->input [video->wfa->frame_type] += stop_timer [0];
timer->frames [video->wfa->frame_type]++;
}
/*
* Read reference frame from disk if required
* (i.e., 1st frame is of type B or P)
*/
if (video->display == 0 && video->wfa->frame_type != I_FRAME)
{
if (!reference_frame)
error ("First frame is %c-frame but no "
"reference frame is given.",
video->wfa->frame_type == B_FRAME ? 'B' : 'P');
video->frame = read_image_file (reference_frame);
video->sframe = NULL;
}
/*
* Depending on current frame type update past and future frames
*/
if (video->wfa->frame_type == I_FRAME)
{
if (video->past) /* discard past frame */
free_image (video->past);
video->past = NULL;
if (video->future) /* discard future frame */
free_image (video->future);
video->future = NULL;
if (video->sfuture) /* discard (smoothed) future frame */
free_image (video->sfuture);
video->sfuture = NULL;
if (video->frame) /* discard current frame */
free_image (video->frame);
video->frame = NULL;
if (video->sframe) /* discard current (smoothed) frame */
free_image (video->sframe);
video->sframe = NULL;
}
else if (video->wfa->frame_type == P_FRAME)
{
if (video->past) /* discard past frame */
free_image (video->past);
video->past = video->frame; /* past <- current frame */
video->frame = NULL;
if (video->sframe) /* discard current (smoothed) frame */
free_image (video->sframe);
video->sframe = NULL;
if (store_wfa)
copy_wfa (video->wfa_past, tmp_wfa);
if (video->future) /* discard future frame */
free_image (video->future);
video->future = NULL;
if (video->sfuture) /* discard (smoothed) future frame */
free_image (video->sfuture);
video->sfuture = NULL;
}
else /* B_FRAME */
{
if (current_frame_is_future_frame)
{
if (video->future) /* discard future frame */
free_image (video->future);
video->future = frame; /* future <- current frame */
if (video->sfuture) /* discard (smoothed) future frame */
free_image (video->sfuture);
video->sfuture = sframe; /* future <- current (smoothed) */
if (store_wfa)
copy_wfa (video->wfa_future, tmp_wfa);
if (video->frame) /* discard current frame */
free_image (video->frame);
video->frame = NULL;
if (video->sframe) /* discard current (smoothed) frame */
free_image (video->sframe);
video->sframe = NULL;
frame = NULL;
sframe = NULL;
}
else
{
if (video->wfa->wfainfo->B_as_past_ref == YES)
{
if (video->past) /* discard past frame */
free_image (video->past);
video->past = video->frame; /* past <- current frame */
video->frame = NULL;
if (video->sframe) /* discard current (smoothed) frame */
free_image (video->sframe);
video->sframe = NULL;
if (store_wfa)
copy_wfa (video->wfa_past, tmp_wfa);
}
else
{
if (video->frame) /* discard current */
free_image (video->frame);
video->frame = NULL;
if (video->sframe) /* discard current (smoothed) frame */
free_image (video->sframe);
video->sframe = NULL;
}
}
}
if (tmp_wfa)
free_wfa (tmp_wfa);
current_frame_is_future_frame = NO;
/*
* Second step: decode image
* Optionally enlarge image if specified by option 'enlarge_factor'.
*/
{
unsigned orig_width, orig_height;
stop_timer [0] = stop_timer [1] = stop_timer [2] = 0;
enlarge_image (enlarge_factor, format,
(video->wfa->wfainfo->color
&& format == FORMAT_4_2_0)
? video->wfa->tree [video->wfa->tree [video->wfa->root_state][0]][0] : -1, video->wfa);
if (enlarge_factor > 0)
{
orig_width = video->wfa->wfainfo->width << enlarge_factor;
orig_height = video->wfa->wfainfo->height << enlarge_factor;
}
else
{
orig_width = video->wfa->wfainfo->width >> - enlarge_factor;
orig_height = video->wfa->wfainfo->height >> - enlarge_factor;
if (orig_width & 1)
orig_width++;
if (orig_height & 1)
orig_height++;
}
frame = decode_image (orig_width, orig_height, format,
timer != NULL ? stop_timer : NULL,
video->wfa);
if (timer)
{
timer->preprocessing [video->wfa->frame_type] += stop_timer [0];
timer->decoder [video->wfa->frame_type] += stop_timer [1];
timer->cleanup [video->wfa->frame_type] += stop_timer [2];
}
}
/*
* Third step: restore motion compensation
*/
if (video->wfa->frame_type != I_FRAME)
{
prg_timer (&ptimer, START);
restore_mc (enlarge_factor, frame, video->past, video->future,
video->wfa);
stop_timer [0] = prg_timer (&ptimer, STOP);
if (timer)
timer->motion [video->wfa->frame_type] += stop_timer [0];
}
/*
* Fourth step: smooth image along partitioning borders
*/
prg_timer (&ptimer, START);
if (smoothing < 0) /* smoothing not changed by user */
smoothing = video->wfa->wfainfo->smoothing;
if (smoothing > 0 && smoothing <= 100)
{
sframe = clone_image (frame);
smooth_image (smoothing, video->wfa, sframe);
}
else
sframe = NULL;
stop_timer [0] = prg_timer (&ptimer, STOP);
if (timer)
timer->smooth [video->wfa->frame_type] += stop_timer [0];
if (frame_number == video->display)
{
video->display++;
video->frame = frame;
video->sframe = sframe;
frame = NULL;
sframe = NULL;
}
else if (frame_number > video->display)
{
video->future_display = frame_number;
current_frame_is_future_frame = YES;
}
if (!store_wfa)
remove_states (video->wfa->basis_states, video->wfa);
} while (!video->frame);
if (!store_wfa)
video->wfa = NULL;
}
return video->sframe ? video->sframe : video->frame;
}
