void audio_encoding_unit_create (void *arg) {
//krad_system_set_thread_name ("kr_audio_enc");
krad_link_t *krad_link = (krad_link_t *)arg;
int c;
printk ("Audio unit create");
if (krad_link->codec != VORBIS) {
krad_link->au_buffer = malloc (300000);
}
krad_link->au_interleaved_samples = malloc (8192 * 4 * KR_MXR_MAX_CHANNELS);
for (c = 0; c < krad_link->channels; c++) {
krad_link->au_samples[c] = malloc (8192 * 4);
krad_link->samples[c] = malloc (8192 * 4);
krad_link->audio_input_ringbuffer[c] = krad_ringbuffer_create (2000000);
}
if (socketpair(AF_UNIX, SOCK_STREAM, 0, krad_link->socketpair)) {
printk ("Krad Compositor: subunit could not create socketpair errno: %d", errno);
return;
}
// krad_link->mixer_portgroup = kr_mixer_path_create(krad_link->krad_radio->mixer,
// krad_link->sysname, KR_AOUT, 0, krad_link->channels, 0.0f,
// krad_link->krad_radio->mixer->master, 0, krad_link, 0);
switch (krad_link->codec) {
case VORBIS:
krad_link->krad_vorbis = krad_vorbis_encoder_create (krad_link->channels,
krad_link->krad_radio->mixer->sample_rate,
krad_link->vorbis_quality);
//krad_link->au_framecnt = KRAD_DEFAULT_VORBIS_FRAME_SIZE;
break;
case FLAC:
krad_link->krad_flac = krad_flac_encoder_create (krad_link->channels,
krad_link->krad_radio->mixer->sample_rate,
krad_link->flac_bit_depth);
krad_link->au_framecnt = KRAD_DEFAULT_FLAC_FRAME_SIZE;
break;
case OPUS:
krad_link->krad_opus = krad_opus_encoder_create (krad_link->channels,
krad_link->krad_radio->mixer->sample_rate,
krad_link->opus_bitrate,
OPUS_APPLICATION_AUDIO);
krad_link->au_framecnt = KRAD_MIN_OPUS_FRAME_SIZE;
break;
default:
failfast ("Krad Link Audio Encoder: Unknown Audio Codec");
}
krad_link->audio_encoder_ready = 1;
}
krad_ebml_creator_t *krad_ebml_creator_create(char *appname, krad_audio_api_t api) {
krad_ebml_creator_t *krad_ebml_creator = calloc(1, sizeof(krad_ebml_creator_t));
krad_ebml_creator->samples[0] = malloc(4 * 8192);
krad_ebml_creator->samples[1] = malloc(4 * 8192);
krad_ebml_creator->callback_samples[0] = malloc(4 * 8192);
krad_ebml_creator->callback_samples[1] = malloc(4 * 8192);
krad_ebml_creator->audio = kradaudio_create(appname, KINPUT, api);
krad_ebml_creator->ebml = kradebml_create();
//krad_ebml_creator->opus = kradopus_encoder_create(44100.0f, 2, 192000, OPUS_APPLICATION_AUDIO);
krad_ebml_creator->vorbis = krad_vorbis_encoder_create(2, 44100, 0.7);
strncpy(krad_ebml_creator->appname, appname, 512);
return krad_ebml_creator;
}
int main (int argc, char *argv[]) {
krad_v4l2_vpx_display_test_t *display_test;
krad_flac_t *krad_flac;
krad_dirac_t *krad_dirac;
krad_vpx_encoder_t *krad_vpx_encoder;
//krad_vpx_decoder_t *krad_vpx_decoder;
kradgui_t *kradgui;
kradebml_t *ebml;
cairo_surface_t *cst;
cairo_t *cr;
char *filename = "/home/oneman/kode/testmedia/capture/new_testfile4.webm";
int hud_width, hud_height;
int hud_stride;
int hud_byte_size;
unsigned char *hud_data;
struct SwsContext *sws_context;
int fps;
int videotrack;
int audiotrack;
char *device;
krad_v4l2_t *kradv4l2;
krad_sdl_opengl_display_t *krad_opengl_display;
int width;
int height;
int count;
//int first_frame;
int read_composited;
unsigned char *read_screen_buffer;
unsigned char *dbuffer;
unsigned char *dfbuffer;
krad_audio_t *audio;
krad_audio_api_t audio_api;
krad_vorbis_t *krad_vorbis;
hud_width = 320;
hud_height = 240;
read_composited = 1;
//first_frame = 1;
width = 640;
height = 480;
fps = 30;
count = 0;
int keyframe;
int bitrate;
void *frame = NULL;
void *vpx_packet;
int packet_size;
int took;
int video_codec;
int audio_codec;
int framenum;
int bytes;
bitrate = 1000;
video_codec = 1;
audio_codec = 1;
if (argc < 2) {
device = DEFAULT_DEVICE;
printf("no device provided, using %s , to provide a device, example: krad_v4l2_test /dev/video0\n", device);
} else {
device = argv[1];
printf("Using %s\n", device);
}
display_test = calloc(1, sizeof(krad_v4l2_vpx_display_test_t));
pthread_rwlock_init(&display_test->ebml_write_lock, NULL);
pthread_rwlock_rdlock(&display_test->ebml_write_lock);
//display_test->kradtimer = kradtimer_create();
display_test->input_ringbuffer[0] = krad_ringbuffer_create (RINGBUFFER_SIZE);
display_test->input_ringbuffer[1] = krad_ringbuffer_create (RINGBUFFER_SIZE);
display_test->samples[0] = malloc(4 * 8192);
display_test->samples[1] = malloc(4 * 8192);
display_test->first_block = 1;
display_test->audio_codec = audio_codec;
dbuffer = calloc(1, 2000000);
dfbuffer = calloc(1, 2000000);
audio_api = JACK;
//audio = kradaudio_create("krad v4l2 vpx display test", audio_api);
krad_vorbis = krad_vorbis_encoder_create(2, 44100, 0.7);
krad_flac = krad_flac_encoder_create(1, 44100, 16);
read_screen_buffer = calloc(1, width * height * 4 * 4 * 4 * 4);
sws_context = sws_getContext ( width, height, PIX_FMT_RGB32, width, height, PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);
ebml = kradebml_create();
//kradebml_open_output_stream(ebml, "192.168.1.2", 9080, "/teststream.webm", "secretkode");
kradebml_open_output_file(ebml, filename);
if (video_codec == 1) {
kradebml_header(ebml, "webm", APPVERSION);
} else {
kradebml_header(ebml, "matroska", APPVERSION);
}
if (video_codec == 1) {
videotrack = kradebml_add_video_track(ebml, "V_VP8", 30, width, height);
}
if (video_codec == 2) {
videotrack = kradebml_add_video_track(ebml, "V_DIRAC", 10, width, height);
}
if (audio_codec == 1) {
audiotrack = kradebml_add_audio_track(ebml, "A_VORBIS", 44100, 2, krad_vorbis->header, krad_vorbis->headerpos);
}
if (audio_codec == 2) {
bytes = krad_flac_encoder_read_min_header(krad_flac, dfbuffer);
audiotrack = kradebml_add_audio_track(ebml, "A_FLAC", 44100, 1, dfbuffer, bytes);
display_test->krad_flac = krad_flac;
}
kradebml_write(ebml);
krad_opengl_display = krad_sdl_opengl_display_create(APPVERSION, width, height, width, height);
//krad_opengl_display = krad_sdl_opengl_display_create(APPVERSION, 1920, 1080, width, height);
krad_vpx_encoder = krad_vpx_encoder_create(width, height, bitrate);
krad_dirac = krad_dirac_encoder_create(width, height);
kradgui = kradgui_create(width, height);
kradgui_add_item(kradgui, REEL_TO_REEL);
hud_stride = cairo_format_stride_for_width (CAIRO_FORMAT_ARGB32, hud_width);
hud_byte_size = hud_stride * hud_height;
hud_data = calloc (1, hud_byte_size);
cst = cairo_image_surface_create_for_data (hud_data, CAIRO_FORMAT_ARGB32, hud_width, hud_height, hud_stride);
krad_opengl_display->hud_width = hud_width;
krad_opengl_display->hud_height = hud_height;
krad_opengl_display->hud_data = hud_data;
display_test->audiotrack = audiotrack;
display_test->ebml = ebml;
//display_test->audio = audio;
display_test->krad_vorbis = krad_vorbis;
display_test->kradgui = kradgui;
kradv4l2 = kradv4l2_create();
kradv4l2_open(kradv4l2, device, width, height, fps);
kradv4l2_start_capturing (kradv4l2);
kradgui_reset_elapsed_time(kradgui);
kradgui->render_timecode = 1;
audio = kradaudio_create("krad v4l2 vpx display test", KINPUT, audio_api);
display_test->audio = audio;
pthread_create(&display_test->audio_encoding_thread, NULL, audio_encoding_thread, (void *)display_test);
kradaudio_set_process_callback(audio, krad_v4l2_vpx_display_test_audio_callback, display_test);
if (audio_api == JACK) {
krad_jack_t *jack = (krad_jack_t *)audio->api;
kradjack_connect_port(jack->jack_client, "firewire_pcm:001486af2e61ac6b_Unknown0_in", "krad v4l2 vpx display test:InputLeft");
kradjack_connect_port(jack->jack_client, "firewire_pcm:001486af2e61ac6b_Unknown0_in", "krad v4l2 vpx display test:InputRight");
}
while (count < TEST_COUNT) {
//kradtimer_start(display_test->kradtimer, "cycle");
cr = cairo_create(cst);
kradgui->cr = cr;
kradgui_render(kradgui);
cairo_destroy(cr);
frame = kradv4l2_read_frame_wait (kradv4l2);
if (display_test->start_audio == 0) {
display_test->start_audio = 1;
usleep(200000);
}
if (video_codec == 2) {
// memcpy(dfbuffer, frame, width * height + (((width * height) / 2) * 2));
}
krad_vpx_convert_uyvy2yv12(krad_vpx_encoder->image, frame, width, height);
///krad_vpx_convert_frame_for_local_gl_display(krad_vpx_encoder);
kradv4l2_frame_done (kradv4l2);
krad_sdl_opengl_display_render(krad_opengl_display, krad_vpx_encoder->image->planes[0], krad_vpx_encoder->image->stride[0], krad_vpx_encoder->image->planes[1], krad_vpx_encoder->image->stride[1], krad_vpx_encoder->image->planes[2], krad_vpx_encoder->image->stride[2]);
krad_sdl_opengl_draw_screen( krad_opengl_display );
if (read_composited) {
krad_sdl_opengl_read_screen( krad_opengl_display, read_screen_buffer);
rgb_to_yv12(sws_context, read_screen_buffer, width, height, krad_vpx_encoder->image->planes, krad_vpx_encoder->image->stride);
vpx_img_flip(krad_vpx_encoder->image);
}
if (video_codec == 1) {
count++;
packet_size = krad_vpx_encoder_write(krad_vpx_encoder, (unsigned char **)&vpx_packet, &keyframe);
//printf("packet size was %d\n", packet_size);
if (read_composited) {
vpx_img_flip(krad_vpx_encoder->image);
}
if (packet_size) {
pthread_rwlock_wrlock(&display_test->ebml_write_lock);
kradebml_add_video(ebml, videotrack, vpx_packet, packet_size, keyframe);
//kradebml_write(ebml);
pthread_rwlock_unlock (&display_test->ebml_write_lock);
}
}
if (video_codec == 2) {
// packet_size = krad_dirac_encode (krad_dirac, dfbuffer, dbuffer, &framenum, &took);
packet_size = krad_dirac_encode (krad_dirac, krad_vpx_encoder->image->img_data, dbuffer, &framenum, &took);
if (took == 1) {
took = 0;
count++;
}
if (packet_size > 0) {
krad_dirac_packet_type(dbuffer[4]);
//write(fd, buffer, len);
printf("Encoded size is %d for frame %d\n", packet_size, framenum);
}
//printf("packet size was %d\n", packet_size);
if (read_composited) {
vpx_img_flip(krad_vpx_encoder->image);
}
keyframe = 0;
if (packet_size) {
pthread_rwlock_wrlock(&display_test->ebml_write_lock);
kradebml_add_video(ebml, videotrack, dbuffer, packet_size, keyframe);
//kradebml_write(ebml);
pthread_rwlock_unlock (&display_test->ebml_write_lock);
}
}
//kradtimer_finish_show(display_test->kradtimer);
}
display_test->start_audio = 0;
if (video_codec == 2) {
schro_encoder_end_of_stream (krad_dirac->encoder);
// packet_size = krad_dirac_encode (krad_dirac, dfbuffer, dbuffer, &framenum, &took);
while ((framenum != count - 1) && (framenum != 0)) {
packet_size = krad_dirac_encode (krad_dirac, krad_vpx_encoder->image->img_data, dbuffer, &framenum, &took);
if (packet_size > 0) {
krad_dirac_packet_type(dbuffer[4]);
//write(fd, buffer, len);
printf("Encoded size is %d for frame %d\n", packet_size, framenum);
} else {
usleep(50000);
}
//printf("packet size was %d\n", packet_size);
if (read_composited) {
//vpx_img_flip(krad_vpx_encoder->image);
}
keyframe = 0;
if (packet_size) {
pthread_rwlock_wrlock(&display_test->ebml_write_lock);
kradebml_add_video(ebml, videotrack, dbuffer, packet_size, keyframe);
//kradebml_write(ebml);
pthread_rwlock_unlock (&display_test->ebml_write_lock);
}
}
}
//display_test->start_audio = 0;
printf("finish audio encoding\n");
usleep(2000000);
display_test->stop_audio_encoding = 1;
pthread_join(display_test->audio_encoding_thread, NULL);
kradebml_destroy(ebml);
kradv4l2_stop_capturing (kradv4l2);
kradv4l2_close(kradv4l2);
kradv4l2_destroy(kradv4l2);
krad_dirac_encoder_destroy(krad_dirac);
krad_vpx_encoder_destroy(krad_vpx_encoder);
// must be before vorbis
kradaudio_destroy(audio);
krad_vorbis_encoder_destroy(krad_vorbis);
krad_flac_encoder_destroy(krad_flac);
free(display_test->samples[0]);
free(display_test->samples[1]);
krad_sdl_opengl_display_destroy(krad_opengl_display);
kradgui_destroy(kradgui);
free(read_screen_buffer);
sws_freeContext (sws_context);
krad_ringbuffer_free ( display_test->input_ringbuffer[0] );
krad_ringbuffer_free ( display_test->input_ringbuffer[1] );
pthread_rwlock_destroy(&display_test->ebml_write_lock);
//kradtimer_destroy(display_test->kradtimer);
free(display_test);
free(dbuffer);
free(dfbuffer);
return 0;
}
kr_streamer_t *kr_streamer_create (kr_streamer_params_t *params) {
kr_streamer_t *streamer;
uint32_t c;
streamer = calloc (1, sizeof(kr_streamer_t));
streamer->params = params;
streamer->params->channels = 2;
streamer->params->sample_rate = 48000;
streamer->client = kr_client_create ("krad streamer client");
if (streamer->client == NULL) {
fprintf (stderr, "Could not create KR client.\n");
exit (1);
}
kr_connect (streamer->client, streamer->params->station);
if (!kr_connected (streamer->client)) {
fprintf (stderr, "Could not connect to %s krad radio daemon.\n",
streamer->params->station);
kr_client_destroy (&streamer->client);
exit (1);
}
if (kr_compositor_get_info_wait (streamer->client,
&streamer->width, &streamer->height,
&streamer->fps_numerator, &streamer->fps_denominator) != 1) {
fprintf (stderr, "Could not get compositor info!\n");
kr_client_destroy (&streamer->client);
exit (1);
}
streamer->frame_size = streamer->width * streamer->height * 4;
//FIXME
streamer->videoport = kr_videoport_create (streamer->client, 0);
if (streamer->videoport == NULL) {
fprintf (stderr, "Could not make videoport.\n");
kr_client_destroy (&streamer->client);
exit (1);
} else {
printf ("Working!\n");
}
kr_videoport_set_callback (streamer->videoport, new_frame, streamer);
for (c = 0; c < streamer->params->channels; c++) {
streamer->audio_ring[c] = krad_ringbuffer_create (2200000);
}
if (params->file != NULL) {
streamer->mkv = kr_mkv_create_file (params->file);
} else {
streamer->mkv = kr_mkv_create_stream (streamer->params->host,
streamer->params->port,
streamer->params->mount,
streamer->params->password);
}
if (streamer->mkv == NULL) {
fprintf (stderr, "failed to stream :/ \n");
exit (1);
}
streamer->vpx_enc = krad_vpx_encoder_create (streamer->params->width,
streamer->params->height,
streamer->fps_numerator,
streamer->fps_denominator,
streamer->params->video_bitrate);
if (params->file != NULL) {
krad_vpx_encoder_set_kf_max_dist (streamer->vpx_enc, 600);
}
kr_mkv_add_video_track (streamer->mkv, VP8,
streamer->fps_numerator,
streamer->fps_denominator,
streamer->params->width,
streamer->params->height);
if (kr_mixer_get_info_wait (streamer->client, &streamer->params->sample_rate, NULL) != 1) {
fprintf (stderr, "Could not get mixer info!\n");
kr_client_destroy (&streamer->client);
exit (1);
}
streamer->vorbis_enc = krad_vorbis_encoder_create (streamer->params->channels,
streamer->params->sample_rate,
streamer->params->audio_quality);
kr_mkv_add_audio_track (streamer->mkv, VORBIS, streamer->params->sample_rate,
streamer->params->channels,
streamer->vorbis_enc->hdrdata,
3 +
streamer->vorbis_enc->header.sz[0] +
streamer->vorbis_enc->header.sz[1] +
streamer->vorbis_enc->header.sz[2]);
//FIXME
streamer->audioport = kr_audioport_create (streamer->client, "streamer2",
0);
kr_audioport_set_callback (streamer->audioport, audioport_process, streamer);
streamer->frame_ring = krad_ringbuffer_create (90 * sizeof(krad_frame_t *));
streamer->framepool = krad_framepool_create (streamer->width,
streamer->height,
8);
return streamer;
}
static void remuxcode (kr_mkv_t *mkv, char *file, char *file2) {
int32_t ret;
int32_t bytes_read;
uint32_t track;
uint64_t timecode;
uint8_t *buffer;
uint8_t *vbuffer;
uint8_t *vbuffer2;
uint32_t out_track;
kr_mkv_t *new_mkv;
int32_t keyframe;
uint8_t flags;
int32_t packets;
krad_vpx_decoder_t *vpx_dec;
krad_vpx_encoder_t *vpx_enc;
kr_codec_hdr_t header;
kr_medium_t *medium;
kr_codeme_t *codeme;
krad_vorbis_t *vorbis_dec;
krad_vorbis_t *vorbis_enc;
packets = 0;
//vpxtest ();
buffer = malloc (20000000);
vbuffer = malloc (20000000);
vbuffer2 = malloc (20000000);
new_mkv = kr_mkv_create_file (file);
if (new_mkv == NULL) {
fprintf (stderr, "Could not open %s\n", file);
exit (1);
}
printf ("Created file: %s\n", file);
vpx_dec = krad_vpx_decoder_create ();
vpx_enc = krad_vpx_encoder_create (1280, 720,
30000,
1000,
2200);
out_track = kr_mkv_add_video_track (new_mkv, VP8,
30000,
1000,
mkv->tracks[VIDEO_TRACK].width,
mkv->tracks[VIDEO_TRACK].height);
header.count = mkv->tracks[AUDIO_TRACK].headers;
header.data[0] = mkv->tracks[AUDIO_TRACK].header[0];
header.sz[0] = mkv->tracks[AUDIO_TRACK].header_len[0];
header.data[1] = mkv->tracks[AUDIO_TRACK].header[1];
header.sz[1] = mkv->tracks[AUDIO_TRACK].header_len[1];
header.data[2] = mkv->tracks[AUDIO_TRACK].header[2];
header.sz[2] = mkv->tracks[AUDIO_TRACK].header_len[2];
vorbis_dec = krad_vorbis_decoder_create (&header);
vorbis_enc = krad_vorbis_encoder_create (2, 48000, 0.4);
kr_mkv_add_audio_track (new_mkv, VORBIS, 48000, 2,
vorbis_enc->hdrdata,
3 +
vorbis_enc->header.sz[0] +
vorbis_enc->header.sz[1] +
vorbis_enc->header.sz[2]);
printf ("\n");
while ((bytes_read = kr_mkv_read_packet (mkv, &track, &timecode, &flags, buffer)) > 0) {
printk ("Read packet %d track %d %d bytes", packets++, track, bytes_read);
//fflush (stdout);
if (flags == 0x80) {
keyframe = 1;
} else {
keyframe = 0;
}
if (track == 1) {
/*
medium = kr_medium_kludge_create ();
codeme = kr_codeme_kludge_create ();
codeme->sz = bytes_read;
memcpy (codeme->data, buffer, codeme->sz);
ret = kr_vpx_decode (vpx_dec, medium, codeme);
//printf ("Vpx dec ret was %d", ret);
kr_codeme_kludge_destroy (&codeme);
codeme = kr_codeme_kludge_create ();
ret = kr_vpx_encode (vpx_enc, codeme, medium);
//printf ("Vpx enc ret was %d", ret);
kr_medium_kludge_destroy (&medium);
bytes_read = codeme->sz;
memcpy (buffer, codeme->data, codeme->sz);
kr_codeme_kludge_destroy (&codeme);
*/
kr_mkv_add_video (new_mkv, out_track, buffer, bytes_read, keyframe);
}
if (track == 2) {
medium = kr_medium_kludge_create ();
codeme = kr_codeme_kludge_create ();
codeme->sz = bytes_read;
memcpy (codeme->data, buffer, codeme->sz);
kr_vorbis_decode (vorbis_dec, medium, codeme);
kr_codeme_kludge_destroy (&codeme);
if (medium->a.count > 0) {
do {
codeme = kr_codeme_kludge_create ();
ret = kr_vorbis_encode (vorbis_enc, codeme, medium);
if (ret == 1) {
kr_mkv_add_audio (new_mkv, 2, codeme->data, codeme->sz, codeme->count);
}
kr_medium_kludge_destroy (&medium);
kr_codeme_kludge_destroy (&codeme);
} while (ret == 1);
}
//}
}
}
//-----------------------------
krad_vorbis_decoder_destroy (&vorbis_dec);
//new_mkv->tracks[VIDEO_TRACK].fps_numerator = 30000;
kr_mkv_destroy (&mkv);
mkv = kr_mkv_open_file (file2);
printf ("FPS %d/%d RES: %dx%d\n",
mkv->tracks[VIDEO_TRACK].fps_numerator,
mkv->tracks[VIDEO_TRACK].fps_denominator,
mkv->tracks[VIDEO_TRACK].width,
mkv->tracks[VIDEO_TRACK].height);
if (mkv == NULL) {
fprintf (stderr, "Could not open %s\n", file2);
exit (1);
}
header.count = mkv->tracks[AUDIO_TRACK].headers;
header.data[0] = mkv->tracks[AUDIO_TRACK].header[0];
header.sz[0] = mkv->tracks[AUDIO_TRACK].header_len[0];
header.data[1] = mkv->tracks[AUDIO_TRACK].header[1];
header.sz[1] = mkv->tracks[AUDIO_TRACK].header_len[1];
header.data[2] = mkv->tracks[AUDIO_TRACK].header[2];
header.sz[2] = mkv->tracks[AUDIO_TRACK].header_len[2];
vorbis_dec = krad_vorbis_decoder_create (&header);
while ((bytes_read = kr_mkv_read_packet (mkv, &track, &timecode, &flags, buffer)) > 0) {
printk ("Read packet %d track %d %d bytes", packets++, track, bytes_read);
//fflush (stdout);
if (flags == 0x80) {
keyframe = 1;
} else {
keyframe = 0;
}
if (track == 1) {
/*
medium = kr_medium_kludge_create ();
codeme = kr_codeme_kludge_create ();
codeme->sz = bytes_read;
memcpy (codeme->data, buffer, codeme->sz);
ret = kr_vpx_decode (vpx_dec, medium, codeme);
//printf ("Vpx dec ret was %d", ret);
kr_codeme_kludge_destroy (&codeme);
codeme = kr_codeme_kludge_create ();
ret = kr_vpx_encode (vpx_enc, codeme, medium);
//printf ("Vpx enc ret was %d", ret);
kr_medium_kludge_destroy (&medium);
bytes_read = codeme->sz;
memcpy (buffer, codeme->data, codeme->sz);
kr_codeme_kludge_destroy (&codeme);
*/
kr_mkv_add_video (new_mkv, out_track, buffer, bytes_read, keyframe);
}
if (track == 2) {
medium = kr_medium_kludge_create ();
codeme = kr_codeme_kludge_create ();
codeme->sz = bytes_read;
memcpy (codeme->data, buffer, codeme->sz);
kr_vorbis_decode (vorbis_dec, medium, codeme);
kr_codeme_kludge_destroy (&codeme);
if (medium->a.count > 0) {
do {
codeme = kr_codeme_kludge_create ();
ret = kr_vorbis_encode (vorbis_enc, codeme, medium);
if (ret == 1) {
kr_mkv_add_audio (new_mkv, 2, codeme->data, codeme->sz, codeme->count);
}
kr_medium_kludge_destroy (&medium);
kr_codeme_kludge_destroy (&codeme);
} while (ret == 1);
}
//}
}
}
medium = kr_medium_kludge_create ();
codeme = kr_codeme_kludge_create ();
ret = kr_vorbis_encode (vorbis_enc, codeme, medium);
if (codeme->sz > 0) {
printk ("Got 1 another sized %zu with %d samples",
codeme->sz, codeme->count);
kr_mkv_add_audio (new_mkv, 2, codeme->data, codeme->sz, codeme->count);
}
kr_codeme_kludge_destroy (&codeme);
kr_medium_kludge_destroy (&medium);
do {
codeme = kr_codeme_kludge_create ();
ret = kr_vorbis_encode (vorbis_enc, codeme, medium);
if (ret == 1) {
kr_mkv_add_audio (new_mkv, 2, codeme->data, codeme->sz, codeme->count);
}
kr_codeme_kludge_destroy (&codeme);
} while (ret == 1);
//----------------------------
printf ("\nDone.\n");
krad_vpx_encoder_destroy (&vpx_enc);
krad_vpx_decoder_destroy (&vpx_dec);
krad_vorbis_decoder_destroy (&vorbis_dec);
krad_vorbis_encoder_destroy (&vorbis_enc);
kr_mkv_destroy (&new_mkv);
kr_mkv_destroy (&mkv);
free (buffer);
free (vbuffer);
free (vbuffer2);
}
