void funca(void)
{
foobar fb;
foobar *bf;
if (count < 10)
{
count++;
funcb(count);
}
fb.nothing = "Foo Bar";
fb.f = 42;
fb.s = 19;
bf = malloc (sizeof (foobar));
bf->nothing = malloc (128);
bf->nothing = "Bar Foo";
bf->f = 24;
bf->s = 91;
end_func(21, "Param", bf, fb);
free (bf->nothing);
free (bf);
return;
}
static int encode_ogg (cdrom_drive *drive, rip_opts_s *rip_opts,
text_tag_s *text_tag, int track,
int tracktot, char *filename, char **filenames)
{
ogg_stream_state os;
ogg_page og;
ogg_packet op;
vorbis_dsp_state vd;
vorbis_block vb;
vorbis_info vi;
long samplesdone = 0;
int sector = 0, last_sector = 0;
long bytes_written = 0, packetsdone = 0;
double time_elapsed = 0.0;
int ret = 0;
time_t *timer;
double time;
int serialno = rand ();
vorbis_comment vc;
long total_samples_per_channel = 0;
int channels = 2;
int eos = 0;
long rate = 44100;
FILE *out = fopen (filename, "w+");
timer = timer_start ();
if (!rip_opts->managed && (rip_opts->min_bitrate > 0 || rip_opts->max_bitrate > 0)) {
log_msg ("Min or max bitrate requires managed", FL, FN, LN);
return -1;
}
if (rip_opts->bitrate < 0 && rip_opts->min_bitrate < 0 && rip_opts->max_bitrate < 0) {
rip_opts->quality_set = 1;
}
start_func (filename, rip_opts->bitrate, rip_opts->quality, rip_opts->quality_set,
rip_opts->managed, rip_opts->min_bitrate, rip_opts->max_bitrate);
vorbis_info_init (&vi);
if (rip_opts->quality_set > 0) {
if (vorbis_encode_setup_vbr (&vi, channels, rate, rip_opts->quality)) {
log_msg ("Couldn't initialize vorbis_info", FL, FN, LN);
vorbis_info_clear (&vi);
return -1;
}
/* two options here, max or min bitrate */
if (rip_opts->max_bitrate > 0 || rip_opts->min_bitrate > 0) {
struct ovectl_ratemanage_arg ai;
vorbis_encode_ctl (&vi, OV_ECTL_RATEMANAGE_GET, &ai);
ai.bitrate_hard_min = rip_opts->min_bitrate;
ai.bitrate_hard_max = rip_opts->max_bitrate;
ai.management_active = 1;
vorbis_encode_ctl (&vi, OV_ECTL_RATEMANAGE_SET, &ai);
}
} else {
if (vorbis_encode_setup_managed (&vi, channels, rate,
rip_opts->max_bitrate > 0 ? rip_opts->max_bitrate * 1000 : -1,
rip_opts->bitrate * 1000,
rip_opts->min_bitrate > 0 ? rip_opts->min_bitrate * 1000 : -1)) {
log_msg ("Mode init failed, encode setup managed", FL, FN, LN);
vorbis_info_clear (&vi);
return -1;
}
}
if (rip_opts->managed && rip_opts->bitrate < 0) {
vorbis_encode_ctl (&vi, OV_ECTL_RATEMANAGE_AVG, NULL);
} else if (!rip_opts->managed) {
vorbis_encode_ctl (&vi, OV_ECTL_RATEMANAGE_SET, NULL);
}
/* set advanced encoder options */
vorbis_encode_setup_init (&vi);
vorbis_analysis_init (&vd, &vi);
vorbis_block_init (&vd, &vb);
ogg_stream_init (&os, serialno);
{
ogg_packet header_main;
ogg_packet header_comments;
ogg_packet header_codebooks;
int result;
char buf[32];
vorbis_comment_init (&vc);
vorbis_comment_add_tag (&vc, "title", text_tag->songname);
vorbis_comment_add_tag (&vc, "artist", text_tag->artistname);
vorbis_comment_add_tag (&vc, "album", text_tag->albumname);
vorbis_comment_add_tag (&vc, "genre", text_tag->genre);
snprintf (buf, 32, "%d", text_tag->year);
vorbis_comment_add_tag (&vc, "date", buf);
snprintf (buf, 32, "%02d", text_tag->track);
vorbis_comment_add_tag (&vc, "tracknumber", buf);
vorbis_analysis_headerout (&vd, &vc, &header_main, &header_comments, &header_codebooks);
ogg_stream_packetin (&os, &header_main);
ogg_stream_packetin (&os, &header_comments);
ogg_stream_packetin (&os, &header_codebooks);
while ((result = ogg_stream_flush (&os, &og))) {
if (result == 0)
break;
ret = write_page (&og, out);
if (ret != og.header_len + og.body_len) {
log_msg ("Failed writing data to output stream", FL, FN, LN);
ret = -1;
}
}
sector = cdda_track_firstsector (drive, track);
last_sector = cdda_track_lastsector (drive, track);
total_samples_per_channel = (last_sector - sector) * (CD_FRAMESAMPLES / 2);
int eos = 0;
while (!eos) {
signed char *buffer = (signed char *)malloc (CD_FRAMESIZE_RAW * READ_SECTORS);
//use this variable as a s**t
long sectors_read = last_sector - sector;
if (sectors_read > READ_SECTORS)
sectors_read = READ_SECTORS;
sectors_read = cdda_read (drive, (signed char *)buffer, sector, sectors_read);
int i;
if (sectors_read == 0) {
vorbis_analysis_wrote (&vd, 0);
} else {
float **vorbbuf = vorbis_analysis_buffer (&vd, CD_FRAMESIZE_RAW * sectors_read);
for (i = 0; i < (CD_FRAMESIZE_RAW * sectors_read) / 4; i++) {
vorbbuf[0][i] = ((buffer[i * 4 + 1] << 8) | (0x00ff&(int)buffer[i * 4])) / 32768.f;
vorbbuf[1][i] = ((buffer[i * 4 + 3] << 8) | (0x00ff&(int)buffer[i * 4 + 2])) / 32768.f;
}
int samples_read = sectors_read * (CD_FRAMESAMPLES / 2);
samplesdone += samples_read;
// progress every 60 pages
if (packetsdone >= 60) {
packetsdone = 0;
time = timer_time (timer);
update_statistics (total_samples_per_channel, samplesdone, time, track,
tracktot, 0, filenames);
}
vorbis_analysis_wrote (&vd, i);
}
free (buffer);
sector += sectors_read;
while (vorbis_analysis_blockout (&vd, &vb) == 1) {
vorbis_analysis (&vb, &op);
vorbis_bitrate_addblock (&vb);
while (vorbis_bitrate_flushpacket (&vd, &op)) {
ogg_stream_packetin (&os, &op);
packetsdone++;
while (!eos) {
int result = ogg_stream_pageout (&os, &og);
if (result == 0) {
break;
}
ret = write_page (&og, out);
if (ret != og.header_len + og.body_len) {
log_msg ("Failed writing data to output stream", FL, FN, LN);
ret = -1;
} else
bytes_written += ret;
if (ogg_page_eos (&og)) {
eos = 1;
}
}
}
}
}
}
ret = 0;
update_statistics (total_samples_per_channel, samplesdone, time, track,
tracktot, 0, filenames);
ogg_stream_clear (&os);
vorbis_block_clear (&vb);
vorbis_dsp_clear (&vd);
vorbis_comment_clear (&vc);
vorbis_info_clear (&vi);
vorbis_comment_clear (&vc);
time_elapsed = timer_time (timer);
end_func (time_elapsed, rate, samplesdone, bytes_written);
timer_clear (timer);
fclose (out);
return ret;
}