C++ (Cpp) krad_flac_encode Examples

Example #1

File: krad_v4l2_vpx_display_test.c Project: rillian/krad_ebml

void *audio_encoding_thread(void *arg) {

	krad_v4l2_vpx_display_test_t *display_test = (krad_v4l2_vpx_display_test_t *)arg;
	
	int bytes;
	float *audio = calloc(1, 1000000);
	unsigned char *buffer = calloc(1, 1000000);
	ogg_packet *op;

	int framecnt;

	if (display_test->audio_codec == 1) {
		framecnt = 1470;
	}
	
	if (display_test->audio_codec == 2) {
		framecnt = 4096;
	}	
	
	while (!(display_test->stop_audio_encoding)) {

		while (krad_ringbuffer_read_space(display_test->input_ringbuffer[1]) > framecnt * 4) {	
	
	
			if (display_test->audio_codec == 1) {
				op = krad_vorbis_encode(display_test->krad_vorbis, framecnt, display_test->input_ringbuffer[0], display_test->input_ringbuffer[1]);
	
				if (op != NULL) {
	
					printf("bytes is %ld\n", op->bytes);
				
					if (display_test->first_block == 0) {
						pthread_rwlock_rdlock(&display_test->ebml_write_lock);
					} else {
						display_test->first_block = 0;
					}
				
					kradebml_add_audio(display_test->ebml, display_test->audiotrack, op->packet, op->bytes, framecnt);
					//kradebml_write(display_test->ebml);		
					pthread_rwlock_unlock (&display_test->ebml_write_lock);		
				}
			}
			
			if (display_test->audio_codec == 2) {
			
					krad_ringbuffer_read(display_test->input_ringbuffer[1], (char *)audio, 4096 * 4);
			
					bytes = krad_flac_encode(display_test->krad_flac, audio, 4096, buffer);

					printf("bytes is %d\n", bytes);
				
					if (display_test->first_block == 0) {
						pthread_rwlock_rdlock(&display_test->ebml_write_lock);
					} else {
						display_test->first_block = 0;
					}
					
					kradebml_add_audio(display_test->ebml, display_test->audiotrack, buffer, bytes, 4096);
					//kradebml_write(display_test->ebml);		
					pthread_rwlock_unlock (&display_test->ebml_write_lock);	
					
					
			}
			
		}
	
		while (krad_ringbuffer_read_space(display_test->input_ringbuffer[1]) < framecnt * 4) {
	
			usleep(10000);
	
			if (display_test->stop_audio_encoding) {
				break;
			}
	
		}
	}
	free(audio);
	free(buffer);
	return NULL;
	
}

Example #2

File: audio_encoder.c Project: kripton/krad_radio-1

int audio_encoding_unit_process (void *arg) {

  krad_link_t *krad_link = (krad_link_t *)arg;

  int c;
  int s;
  int bytes;
  int frames;
  int ret;
  char buffer[1];
  kr_slice_t *kr_slice;

  bytes = 0;
  kr_slice = NULL;

  ret = read (krad_link->socketpair[1], buffer, 1);
  if (ret != 1) {
    if (ret == 0) {
      printk ("Krad AU Transponder: port read got EOF");
      return -1;
    }
    printk ("Krad AU Transponder: port read unexpected read return value %d", ret);
  }

  if (krad_link->codec != VORBIS) {
    frames = krad_link->au_framecnt;
  }

  while (krad_ringbuffer_read_space(krad_link->audio_input_ringbuffer[krad_link->channels - 1]) >= krad_link->au_framecnt * 4) {

    if (krad_link->codec == OPUS) {
      for (c = 0; c < krad_link->channels; c++) {
        krad_ringbuffer_read (krad_link->audio_input_ringbuffer[c], (char *)krad_link->au_samples[c], (krad_link->au_framecnt * 4) );
        krad_opus_encoder_write (krad_link->krad_opus, c + 1, (char *)krad_link->au_samples[c], krad_link->au_framecnt * 4);
      }
      bytes = krad_opus_encoder_read (krad_link->krad_opus, krad_link->au_buffer, &krad_link->au_framecnt);
    }
    if (krad_link->codec == FLAC) {
      for (c = 0; c < krad_link->channels; c++) {
        krad_ringbuffer_read (krad_link->audio_input_ringbuffer[c], (char *)krad_link->au_samples[c], (krad_link->au_framecnt * 4) );
      }
      for (s = 0; s < krad_link->au_framecnt; s++) {
        for (c = 0; c < krad_link->channels; c++) {
          krad_link->au_interleaved_samples[s * krad_link->channels + c] = krad_link->au_samples[c][s];
        }
      }
      bytes = krad_flac_encode (krad_link->krad_flac, krad_link->au_interleaved_samples, krad_link->au_framecnt, krad_link->au_buffer);
    }
    if (krad_link->codec == VORBIS) {
    /*


      medium = kr_medium_kludge_create ();
      codeme = kr_codeme_kludge_create ();


      for (c = 0; c < krad_link->channels; c++) {
        krad_ringbuffer_read (krad_link->audio_input_ringbuffer[c], (char *)float_buffer[c], krad_link->au_framecnt * 4);
      }

                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);

      bytes =
    */
    }

    while (bytes > 0) {
      if (krad_link->subunit != NULL) {
        kr_slice = kr_slice_create_with_data (krad_link->au_buffer, bytes);
        kr_slice->frames = frames;
        kr_slice->codec = krad_link->codec;
        kr_xpdr_slice_broadcast (krad_link->subunit, &kr_slice);
        kr_slice_unref (kr_slice);
      }
      bytes = 0;
      if (krad_link->codec == VORBIS) {
      //  bytes = krad_vorbis_encoder_read (krad_link->krad_vorbis, &frames, &krad_link->au_buffer);
      }
      if (krad_link->codec == OPUS) {
        bytes = krad_opus_encoder_read (krad_link->krad_opus, krad_link->au_buffer, &krad_link->au_framecnt);
      }
    }
  }

  return 0;
}