int
main (int argc, char *argv[])
{
int filter;
int j;
int n;
int i;
SchroEncoder *encoder;
double min;
double x;
schro_init();
encoder = schro_encoder_new ();
for(filter=0;filter<8;filter++){
for(j=0;j<4;j++){
printf("filter %d n_levels %d\n", filter, j+1);
n = 3*(j+1)+1;
min = encoder->subband_weights[filter][j][0];
for(i=0;i<n;i++){
if (encoder->subband_weights[filter][j][i] < min) {
min = encoder->subband_weights[filter][j][i];
}
}
for(i=0;i<n;i++){
x = encoder->subband_weights[filter][j][i]/min;
printf("%2d %6.3f %6.3f %d\n", i, encoder->subband_weights[filter][j][i],
x, gain_to_quant_index(x));
}
}
}
return 0;
}
static int libschroedinger_encode_init(AVCodecContext *avccontext)
{
SchroEncoderParams *p_schro_params = avccontext->priv_data;
SchroVideoFormatEnum preset;
/* Initialize the libraries that libschroedinger depends on. */
schro_init();
/* Create an encoder object. */
p_schro_params->encoder = schro_encoder_new();
if (!p_schro_params->encoder) {
av_log(avccontext, AV_LOG_ERROR,
"Unrecoverable Error: schro_encoder_new failed. ");
return -1;
}
/* Initialize the format. */
preset = ff_get_schro_video_format_preset(avccontext);
p_schro_params->format =
schro_encoder_get_video_format(p_schro_params->encoder);
schro_video_format_set_std_video_format(p_schro_params->format, preset);
p_schro_params->format->width = avccontext->width;
p_schro_params->format->height = avccontext->height;
if (set_chroma_format(avccontext) == -1)
return -1;
if (avccontext->color_primaries == AVCOL_PRI_BT709) {
p_schro_params->format->colour_primaries = SCHRO_COLOUR_PRIMARY_HDTV;
} else if (avccontext->color_primaries == AVCOL_PRI_BT470BG) {
p_schro_params->format->colour_primaries = SCHRO_COLOUR_PRIMARY_SDTV_625;
} else if (avccontext->color_primaries == AVCOL_PRI_SMPTE170M) {
p_schro_params->format->colour_primaries = SCHRO_COLOUR_PRIMARY_SDTV_525;
}
if (avccontext->colorspace == AVCOL_SPC_BT709) {
p_schro_params->format->colour_matrix = SCHRO_COLOUR_MATRIX_HDTV;
} else if (avccontext->colorspace == AVCOL_SPC_BT470BG) {
p_schro_params->format->colour_matrix = SCHRO_COLOUR_MATRIX_SDTV;
}
if (avccontext->color_trc == AVCOL_TRC_BT709) {
p_schro_params->format->transfer_function = SCHRO_TRANSFER_CHAR_TV_GAMMA;
}
if (ff_get_schro_frame_format(p_schro_params->format->chroma_format,
&p_schro_params->frame_format) == -1) {
av_log(avccontext, AV_LOG_ERROR,
"This codec currently supports only planar YUV 4:2:0, 4:2:2"
" and 4:4:4 formats.\n");
return -1;
}
p_schro_params->format->frame_rate_numerator = avccontext->time_base.den;
p_schro_params->format->frame_rate_denominator = avccontext->time_base.num;
p_schro_params->frame_size = avpicture_get_size(avccontext->pix_fmt,
avccontext->width,
avccontext->height);
avccontext->coded_frame = &p_schro_params->picture;
if (!avccontext->gop_size) {
schro_encoder_setting_set_double(p_schro_params->encoder,
"gop_structure",
SCHRO_ENCODER_GOP_INTRA_ONLY);
if (avccontext->coder_type == FF_CODER_TYPE_VLC)
schro_encoder_setting_set_double(p_schro_params->encoder,
"enable_noarith", 1);
} else {
schro_encoder_setting_set_double(p_schro_params->encoder,
"au_distance", avccontext->gop_size);
avccontext->has_b_frames = 1;
p_schro_params->dts = -1;
}
/* FIXME - Need to handle SCHRO_ENCODER_RATE_CONTROL_LOW_DELAY. */
if (avccontext->flags & CODEC_FLAG_QSCALE) {
if (!avccontext->global_quality) {
/* lossless coding */
schro_encoder_setting_set_double(p_schro_params->encoder,
"rate_control",
SCHRO_ENCODER_RATE_CONTROL_LOSSLESS);
} else {
int quality;
schro_encoder_setting_set_double(p_schro_params->encoder,
"rate_control",
SCHRO_ENCODER_RATE_CONTROL_CONSTANT_QUALITY);
quality = avccontext->global_quality / FF_QP2LAMBDA;
if (quality > 10)
quality = 10;
schro_encoder_setting_set_double(p_schro_params->encoder,
"quality", quality);
}
} else {
schro_encoder_setting_set_double(p_schro_params->encoder,
"rate_control",
SCHRO_ENCODER_RATE_CONTROL_CONSTANT_BITRATE);
schro_encoder_setting_set_double(p_schro_params->encoder,
"bitrate",
avccontext->bit_rate);
}
if (avccontext->flags & CODEC_FLAG_INTERLACED_ME)
/* All material can be coded as interlaced or progressive
irrespective of the type of source material. */
schro_encoder_setting_set_double(p_schro_params->encoder,
"interlaced_coding", 1);
schro_encoder_setting_set_double(p_schro_params->encoder, "open_gop",
!(avccontext->flags & CODEC_FLAG_CLOSED_GOP));
/* FIXME: Signal range hardcoded to 8-bit data until both libschroedinger
* and libdirac support other bit-depth data. */
schro_video_format_set_std_signal_range(p_schro_params->format,
SCHRO_SIGNAL_RANGE_8BIT_VIDEO);
/* Set the encoder format. */
schro_encoder_set_video_format(p_schro_params->encoder,
p_schro_params->format);
/* Set the debug level. */
schro_debug_set_level(avccontext->debug);
schro_encoder_start(p_schro_params->encoder);
/* Initialize the encoded frame queue. */
ff_schro_queue_init(&p_schro_params->enc_frame_queue);
return 0;
}
int
main (int argc, char *argv[])
{
SchroEncoder *encoder;
SchroParams params;
SchroVideoFormat video_format;
int filter;
SchroFrame *frame;
int transform_depth;
int i,j;
int k;
schro_init();
encoder = schro_encoder_new ();
frame = schro_frame_new_and_alloc (NULL, SCHRO_FRAME_FORMAT_S16_444, SIZE, SIZE);
schro_fft_generate_tables_f32 (costable, sintable, 2*SHIFT);
filter = 6;
transform_depth = 4;
schro_video_format_set_std_video_format (&video_format, 0);
video_format.width = SIZE;
video_format.height = SIZE;
memset (¶ms, 0, sizeof(params));
params.video_format = &video_format;
schro_params_init (¶ms, 0);
params.wavelet_filter_index = filter;
params.transform_depth = transform_depth;
schro_params_calculate_iwt_sizes (¶ms);
for(i=0;i<SIZE*SIZE;i++) power[i] = 0;
for(k=0;k<N_TRIALS;k++){
generate_noise (frame, transform_depth,
encoder->subband_weights[filter][transform_depth-1]);
schro_frame_inverse_iwt_transform (frame, ¶ms, tmp);
for(j=0;j<SIZE;j++){
int16_t *line;
line = OFFSET(frame->components[0].data,
frame->components[0].stride * j);
for(i=0;i<SIZE;i++){
sr[j*SIZE+i] = line[i];
si[j*SIZE+i] = 0;
}
}
schro_fft_fwd_f32 (dr, di, sr, si, costable, sintable, 2*SHIFT);
for(i=0;i<SIZE*SIZE;i++) {
power[i] += (dr[i]*dr[i]+di[i]*di[i])*(1.0/(SIZE*SIZE));
}
}
//power[0] *= 4.0/SIZE;
//power[0] = 0;
for(j=0;j<SIZE/2;j+=CHUNK_SIZE){
for(i=0;i<SIZE/2;i+=CHUNK_SIZE){
int ii,jj;
double sum = 0;
for(jj=0;jj<CHUNK_SIZE;jj++){
for(ii=0;ii<CHUNK_SIZE;ii++){
sum += power[(j+jj)*SIZE+(i+ii)];
}
}
sum /= N_TRIALS*CHUNK_SIZE*CHUNK_SIZE;
printf("%d %d %g\n", j, i, sqrt(sum)/AMPLITUDE);
}
printf("\n");
}
return fail;
}
static int libschroedinger_encode_init(AVCodecContext *avccontext)
{
FfmpegSchroEncoderParams* p_schro_params = avccontext->priv_data;
SchroVideoFormatEnum preset;
/* Initialize the libraries that libschroedinger depends on. */
schro_init();
/* Create an encoder object. */
p_schro_params->encoder = schro_encoder_new();
if (!p_schro_params->encoder) {
av_log(avccontext, AV_LOG_ERROR,
"Unrecoverable Error: schro_encoder_new failed. ");
return -1;
}
/* Initialize the format. */
preset = ff_get_schro_video_format_preset(avccontext);
p_schro_params->format =
schro_encoder_get_video_format(p_schro_params->encoder);
schro_video_format_set_std_video_format(p_schro_params->format, preset);
p_schro_params->format->width = avccontext->width;
p_schro_params->format->height = avccontext->height;
if (SetSchroChromaFormat(avccontext) == -1)
return -1;
if (ff_get_schro_frame_format(p_schro_params->format->chroma_format,
&p_schro_params->frame_format) == -1) {
av_log(avccontext, AV_LOG_ERROR,
"This codec currently supports only planar YUV 4:2:0, 4:2:2"
" and 4:4:4 formats.\n");
return -1;
}
p_schro_params->format->frame_rate_numerator = avccontext->time_base.den;
p_schro_params->format->frame_rate_denominator = avccontext->time_base.num;
p_schro_params->frame_size = avpicture_get_size(avccontext->pix_fmt,
avccontext->width,
avccontext->height);
avccontext->coded_frame = &p_schro_params->picture;
if (!avccontext->gop_size) {
schro_encoder_setting_set_double(p_schro_params->encoder,
"gop_structure",
SCHRO_ENCODER_GOP_INTRA_ONLY);
if (avccontext->coder_type == FF_CODER_TYPE_VLC)
schro_encoder_setting_set_double(p_schro_params->encoder,
"enable_noarith", 1);
} else {
schro_encoder_setting_set_double(p_schro_params->encoder,
"gop_structure",
SCHRO_ENCODER_GOP_BIREF);
avccontext->has_b_frames = 1;
}
/* FIXME - Need to handle SCHRO_ENCODER_RATE_CONTROL_LOW_DELAY. */
if (avccontext->flags & CODEC_FLAG_QSCALE) {
if (!avccontext->global_quality) {
/* lossless coding */
schro_encoder_setting_set_double(p_schro_params->encoder,
"rate_control",
SCHRO_ENCODER_RATE_CONTROL_LOSSLESS);
} else {
int noise_threshold;
schro_encoder_setting_set_double(p_schro_params->encoder,
"rate_control",
SCHRO_ENCODER_RATE_CONTROL_CONSTANT_NOISE_THRESHOLD);
noise_threshold = avccontext->global_quality / FF_QP2LAMBDA;
if (noise_threshold > 100)
noise_threshold = 100;
schro_encoder_setting_set_double(p_schro_params->encoder,
"noise_threshold",
noise_threshold);
}
} else {
schro_encoder_setting_set_double(p_schro_params->encoder,
"rate_control",
SCHRO_ENCODER_RATE_CONTROL_CONSTANT_BITRATE);
schro_encoder_setting_set_double(p_schro_params->encoder,
"bitrate",
avccontext->bit_rate);
}
if (avccontext->flags & CODEC_FLAG_INTERLACED_ME)
/* All material can be coded as interlaced or progressive
irrespective of the type of source material. */
schro_encoder_setting_set_double(p_schro_params->encoder,
"interlaced_coding", 1);
/* FIXME: Signal range hardcoded to 8-bit data until both libschroedinger
* and libdirac support other bit-depth data. */
schro_video_format_set_std_signal_range(p_schro_params->format,
SCHRO_SIGNAL_RANGE_8BIT_VIDEO);
/* Set the encoder format. */
schro_encoder_set_video_format(p_schro_params->encoder,
p_schro_params->format);
/* Set the debug level. */
schro_debug_set_level(avccontext->debug);
schro_encoder_start(p_schro_params->encoder);
/* Initialize the encoded frame queue. */
ff_dirac_schro_queue_init(&p_schro_params->enc_frame_queue);
return 0;
}
static bool
RunTest(int bit_depth)
{
bool result = true;
const int seq_len = 5;
const int width = 100;
const int height = 10;
int luma_min = 16;
int luma_max = 235;
int chroma_zero = 128;
schro_init();
// set up encoder
SchroEncoder *encoder = schro_encoder_new();
schro_encoder_setting_set_double(encoder, "gop_structure", SCHRO_ENCODER_GOP_INTRA_ONLY);
schro_encoder_setting_set_double(encoder, "rate_control", SCHRO_ENCODER_RATE_CONTROL_LOSSLESS);
//schro_encoder_setting_set_double(encoder, "force_profile", SCHRO_ENCODER_PROFILE_VC2_SIMPLE);
//schro_encoder_setting_set_double(encoder, "queue_depth", seq_len);
//assert(seq_len <= SCHRO_LIMIT_FRAME_QUEUE_LENGTH);
SchroVideoFormat *format = schro_encoder_get_video_format(encoder);
if(format)
{
format->width = width;
format->height = height;
format->clean_width = format->width;
format->clean_height = format->height;
format->left_offset = 0;
format->top_offset = 0;
format->chroma_format = SCHRO_CHROMA_444;
const SchroSignalRange range = (bit_depth == 12 ? SCHRO_SIGNAL_RANGE_12BIT_VIDEO :
bit_depth == 10 ? SCHRO_SIGNAL_RANGE_10BIT_VIDEO :
SCHRO_SIGNAL_RANGE_8BIT_VIDEO);
schro_video_format_set_std_signal_range(format, range);
luma_min = format->luma_offset;
luma_max = format->luma_offset + format->luma_excursion;
chroma_zero = format->chroma_offset;
format->colour_primaries = SCHRO_COLOUR_PRIMARY_HDTV;
format->colour_matrix = SCHRO_COLOUR_MATRIX_HDTV;
format->transfer_function = SCHRO_TRANSFER_CHAR_TV_GAMMA;
format->interlaced = false;
format->frame_rate_numerator = 24;
format->frame_rate_denominator = 1;
format->aspect_ratio_numerator = 1;
format->aspect_ratio_denominator = 1;
schro_encoder_set_video_format(encoder, format);
free(format);
}
else
return false;
schro_encoder_start(encoder);
// create frame
SchroFrame *start_frame = schro_frame_new_and_alloc(NULL, SCHRO_FRAME_FORMAT_U8_444, width, height);
FillFrame<unsigned char>(start_frame, 16, 235, 128);
const SchroFrameFormat schro_format = (bit_depth > 8 ? SCHRO_FRAME_FORMAT_S16_444 : SCHRO_FRAME_FORMAT_U8_444);
SchroFrame *original_frame = schro_frame_new_and_alloc(NULL, schro_format, width, height);
schro_frame_convert(original_frame, start_frame);
SchroDecoder *decoder = schro_decoder_new();
// push frames to encoder
for(int t = 0; t < seq_len; t++)
{
SchroFrame *new_frame = schro_frame_dup(original_frame);
schro_encoder_push_frame(encoder, new_frame);
}
// pull packets out of encoder, pass to decoder
int packets_out = 0;
while(packets_out < seq_len)
{
SchroStateEnum encoder_state = schro_encoder_wait(encoder);
if(encoder_state == SCHRO_STATE_HAVE_BUFFER || encoder_state == SCHRO_STATE_END_OF_STREAM)
{
int n_decodable_frames = -1;
SchroBuffer *buffer = schro_encoder_pull(encoder, &n_decodable_frames);
if(buffer)
{
const int parse_code = buffer->data[4];
if(SCHRO_PARSE_CODE_IS_SEQ_HEADER(parse_code) ||
SCHRO_PARSE_CODE_IS_AUXILIARY_DATA(parse_code) ||
SCHRO_PARSE_CODE_IS_PICTURE(parse_code))
{
schro_decoder_push(decoder, buffer);
//schro_buffer_unref(buffer);
if(SCHRO_PARSE_CODE_IS_PICTURE(parse_code))
{
packets_out++;
}
}
}
}
else
{
assert(encoder_state == SCHRO_STATE_NEED_FRAME);
assert(encoder_state != SCHRO_STATE_AGAIN); // yeah, redundant
schro_encoder_end_of_stream(encoder);
}
}
// pull frames out of decoder
int frames_out = 0;
while(frames_out < seq_len)
{
int decoder_state = schro_decoder_wait(decoder);
if(decoder_state == SCHRO_DECODER_FIRST_ACCESS_UNIT)
{
SchroVideoFormat *format = schro_decoder_get_video_format(decoder);
if(format)
{
assert(format->width == width);
assert(format->height == height);
assert(format->chroma_format == SCHRO_CHROMA_444);
assert(format->luma_offset == luma_min);
assert(format->luma_offset + format->luma_excursion == luma_max);
assert(format->chroma_offset = chroma_zero);
free(format);
}
}
else if(decoder_state == SCHRO_DECODER_NEED_BITS)
{
schro_decoder_push_end_of_stream(decoder);
}
else if(decoder_state == SCHRO_DECODER_NEED_FRAME)
{
SchroFrame *decoder_frame = schro_frame_new_and_alloc(NULL, schro_format, width, height);
schro_decoder_add_output_picture(decoder, decoder_frame);
}
else if(decoder_state == SCHRO_DECODER_OK || decoder_state == SCHRO_DECODER_EOS)
{
SchroFrame *decoder_frame = schro_decoder_pull(decoder);
if(decoder_frame)
{
frames_out++;
bool match = CompareFrames(decoder_frame, original_frame);
//std::cout << (match ? "Match!" : "No Match!") << " " << std::endl;
if(!match)
{
// output doesn't match input, so print the values of the
// first line of the first component to see what went in and out
PrintFirstLine(original_frame);
std::cout << "==========" << std::endl;
PrintFirstLine(decoder_frame);
std::cout << "==========" << std::endl;
result = false;
}
schro_frame_unref(decoder_frame);
}
}
}
schro_frame_unref(original_frame);
schro_frame_unref(start_frame);
schro_decoder_free(decoder);
schro_encoder_free(encoder);
return result;
}
