void
gread(struct termios *tp, char *s)
{
const struct cchar *cp;
char *ep, *p;
long tmp;
if ((s = strchr(s, ':')) == NULL)
gerr(NULL);
for (++s; s != NULL;) {
p = strsep(&s, ":\0");
if (!p || !*p)
break;
if (!(ep = strchr(p, '=')))
gerr(p);
*ep++ = '\0';
(void)sscanf(ep, "%lx", &tmp);
#define CHK(s) (*p == s[0] && !strcmp(p, s))
if (CHK("cflag")) {
tp->c_cflag = tmp;
continue;
}
if (CHK("iflag")) {
tp->c_iflag = tmp;
continue;
}
#ifdef BSD4_4
if (CHK("ispeed")) {
(void)sscanf(ep, "%ld", &tmp);
tp->c_ispeed = tmp;
continue;
}
#endif
if (CHK("lflag")) {
tp->c_lflag = tmp;
continue;
}
if (CHK("oflag")) {
tp->c_oflag = tmp;
continue;
}
#ifdef BSD4_4
if (CHK("ospeed")) {
(void)sscanf(ep, "%ld", &tmp);
tp->c_ospeed = tmp;
continue;
}
#endif
for (cp = cchars1; cp->name != NULL; ++cp)
if (CHK(cp->name)) {
if (cp->sub == VMIN || cp->sub == VTIME)
(void)sscanf(ep, "%ld", &tmp);
tp->c_cc[cp->sub] = tmp;
break;
}
if (cp->name == NULL)
gerr(p);
}
}
static int ov2640_putreg(FAR struct i2c_master_s *i2c, uint8_t regaddr,
uint8_t regval)
{
struct i2c_config_s config;
uint8_t buffer[2];
int ret;
#ifdef CONFIG_OV2640_REGDEBUG
_err("%02x <- %02x\n", regaddr, regval);
#endif
/* Set up for the transfer */
buffer[0] = regaddr; /* Register address */
buffer[1] = regval; /* New register value */
/* Set up the I2C configuration */
config.frequency = CONFIG_OV2640_FREQUENCY;
config.address = CONFIG_OV2640_I2CADDR;
config.addrlen = 7;
/* And do it */
ret = i2c_write(i2c, &config, buffer, 2);
if (ret < 0)
{
gerr("ERROR: i2c_write failed: %d\n", ret);
return ret;
}
return OK;
}
static int nxterm_open(FAR struct file *filep)
{
FAR struct inode *inode = filep->f_inode;
FAR struct nxterm_state_s *priv = inode->i_private;
DEBUGASSERT(filep && filep->f_inode);
/* Get the driver structure from the inode */
inode = filep->f_inode;
priv = (FAR struct nxterm_state_s *)inode->i_private;
DEBUGASSERT(priv);
/* Verify that the driver is opened for write-only access */
#ifndef CONFIG_NXTERM_NXKBDIN
if ((filep->f_oflags & O_RDOK) != 0)
{
gerr("ERROR: Attempted open with read access\n");
return -EACCES;
}
#endif
/* Assign the driver structure to the file */
filep->f_priv = priv;
return OK;
}
inline void hi_audio_to_texture(Renderer* renderer, WaveformActor* actor, int b, Section* section, int n_chans, int block_size)
{
// borders: Source data blocks are correctly sized but an offset needs to be added.
// The left hand border is currently empty which is ok if there is no texture post-processing.
Waveform* waveform = actor->waveform;
int _b = b % MAX_BLOCKS_PER_TEXTURE;
// we are here as notification that audio has loaded so it is an error if not.
g_return_if_fail(waveform->priv->audio.buf16);
WfBuf16* audio_buf = waveform->priv->audio.buf16[b];
g_return_if_fail(audio_buf);
#define IO_RATIO 16
#define DELAY ((int)(TEX_BORDER_HI * IO_RATIO))
short max[n_chans];
short min[n_chans];
int c; for(c=0;c<n_chans;c++){
int B = _b * block_size + (c * block_size / 2);
int mm_level = 0;
int i, p; for(i=0, p=0; p<WF_PEAK_BLOCK_SIZE - DELAY; i++, p+= IO_RATIO){
short* d = &audio_buf->buf[c][p];
max[c] = 0;
min[c] = 0;
int k; for(k=0;k<IO_RATIO;k++){
max[c] = (d[k + c] > max[c]) ? d[k + c] : max[c];
min[c] = (d[k + c] < min[c]) ? d[k + c] : min[c];
}
bool ok = ng_gl2_set(section, B + ((NGRenderer*)renderer)->mmidx_max[mm_level] + ((int)TEX_BORDER_HI) + i, short_to_char(max[c]));
if(!ok) gerr("max b=%i i=%i p=%i %i size=%i", _b, i, p, B + ((NGRenderer*)renderer)->mmidx_max[mm_level] + i, section->buffer_size);
g_return_if_fail(ok);
ok = ng_gl2_set(section, B + ((NGRenderer*)renderer)->mmidx_min[mm_level] + ((int)TEX_BORDER_HI) + i, short_to_char(-min[c]));
if(!ok) gerr("min b=%i i=%i p=%i %i size=%i mm=%i", _b, i, p, b * block_size + ((NGRenderer*)renderer)->mmidx_min[mm_level] + i, section->buffer_size, ((NGRenderer*)renderer)->mmidx_min[mm_level]);
g_return_if_fail(ok);
}
other_lods(renderer, section, B);
}
}
void qemu_vga(void)
{
int ret = init_graph_vga(VGA_XRES, VGA_YRES, 1);
if (ret < 0)
{
gerr("ERROR: init_graph_vga returned %d\n",ret);
}
memset(g_pscreen, g_bg_color, VGA_XRES * VGA_YRES);
(void)register_driver("/dev/lcd", &g_vgaops, 0666, NULL);
}
FAR struct lcd_dev_s *qemu_vga_initialize(void)
{
int ret = init_graph_vga(VGA_XRES, VGA_YRES, 1);
if (ret < 0)
{
gerr("ERROR: init_graph_vga returned %d\n",ret);
}
memset(g_pscreen, 0, VGA_XRES * VGA_YRES);
return &g_lcddev;
}
int
main (int argc, char *argv[])
{
if(sizeof(off_t) != 8){ gerr("sizeof(off_t)=%zu\n", sizeof(off_t)); exit(1); }
test_init(tests, G_N_ELEMENTS(tests));
g_main_loop_run (g_main_loop_new (NULL, 0));
exit(1);
}
static uint8_t ov2640_getreg(FAR struct i2c_master_s *i2c, uint8_t regaddr)
{
struct i2c_config_s config;
uint8_t regval;
int ret;
/* Set up the I2C configuration */
config.frequency = CONFIG_OV2640_FREQUENCY;
config.address = CONFIG_OV2640_I2CADDR;
config.addrlen = 7;
/* Write the register address */
ret = i2c_write(i2c, &config, ®addr, 1);
if (ret < 0)
{
gerr("ERROR: i2c_write failed: %d\n", ret);
return 0;
}
/* Restart and read 8-bits from the register */
ret = i2c_read(i2c, &config, ®val, 1);
if (ret < 0)
{
gerr("ERROR: i2c_read failed: %d\n", ret);
return 0;
}
#ifdef CONFIG_OV2640_REGDEBUG
else
{
_err("%02x -> %02x\n", regaddr, regval);
}
#endif
return regval;
}
AGlActor*
list_view(WaveformActor* _)
{
instance_count++;
_init();
bool list_paint(AGlActor* actor)
{
ListView* view = (ListView*)actor;
#define row_height 20
#define N_ROWS_VISIBLE(A) (agl_actor__height(((AGlActor*)A)) / row_height)
int n_rows = N_ROWS_VISIBLE(actor);
int col[] = {0, 150, 260, 360, 420};
GtkTreeIter iter;
if(!gtk_tree_model_get_iter_first((GtkTreeModel*)samplecat.store, &iter)){ gerr ("cannot get iter."); return false; }
int i = 0;
for(;i<view->scroll_offset;i++){
gtk_tree_model_iter_next((GtkTreeModel*)samplecat.store, &iter);
}
int row_count = 0;
do {
if(row_count == view->selection - view->scroll_offset){
agl->shaders.plain->uniform.colour = 0x6677ff77;
agl_use_program((AGlShader*)agl->shaders.plain);
agl_rect_((AGlRect){0, row_count * row_height - 2, agl_actor__width(actor), row_height});
}
Sample* sample = samplecat_list_store_get_sample_by_iter(&iter);
if(sample){
char* len[32]; format_smpte((char*)len, sample->frames);
char* f[32]; samplerate_format((char*)f, sample->sample_rate);
char* val[4] = {sample->name, sample->sample_dir, (char*)len, (char*)f};
int c; for(c=0;c<G_N_ELEMENTS(val);c++){
agl_enable_stencil(0, 0, col[c + 1] - 6, actor->region.y2);
agl_print(col[c], row_count * row_height, 0, 0xffffffff, val[c]);
}
sample_unref(sample);
}
} while (++row_count < n_rows && gtk_tree_model_iter_next((GtkTreeModel*)samplecat.store, &iter));
agl_disable_stencil();
return true;
}
static int ov2640_reset(FAR struct i2c_master_s *i2c)
{
int ret;
ret = ov2640_putreglist(i2c, g_ov2640_reset, OV2640_RESET_NENTRIES);
if (ret < 0)
{
gerr("ERROR: ov2640_putreglist failed: %d\n", ret);
return ret;
}
up_mdelay(5);
return OK;
}
static int ovr2640_chipid(FAR struct i2c_master_s *i2c)
{
uint8_t pidl;
uint8_t pidh;
#ifdef CONFIG_DEBUG_GRAPHICS
uint8_t midh;
uint8_t midl;
#endif
int ret;
/* Check and show product ID and manufacturer ID */
ret = ov2640_putreg(i2c, 0xff, 0x01); /* Select the sensor address bank */
if (ret < 0)
{
gerr("ERROR: ov2640_putreg failed: %d\n", ret);
return ret;
}
pidl = ov2640_getreg(i2c, 0x0a); /* Product ID (MS) */
pidh = ov2640_getreg(i2c, 0x0b); /* Product ID (LS) */
#ifdef CONFIG_DEBUG_GRAPHICS
midh = ov2640_getreg(i2c, 0x1c); /* Manufacturer ID (high) = 0x7f */
midl = ov2640_getreg(i2c, 0x1d); /* Manufacturer ID (low) = 0xa2 */
#endif
if (pidl != OVR2640_PRODUCT_IDL || pidh != OVR2640_PRODUCT_IDH)
{
gerr("ERROR: Unsupported PID=%02x$02x MID=%02x%02x\n",
pidh, pidl, midh, midl);
return -ENOSYS;
}
ginfo("PID=%02x$02x MID=%02x%02x\n", pidh, pidl, midh, midl);
return OK;
}
void create_background(AGlActor* a)
{
//create an alpha-map gradient texture
AGlTextureActor* ta = (AGlTextureActor*)a;
if(ta->texture[0]) return;
int width = 256;
int height = 256;
char* pbuf = g_new0(char, width * height);
#if 1
int y; for(y=0;y<height;y++){
int x; for(x=0;x<width;x++){
*(pbuf + y * width + x) = ((x+y) * 0xff) / (width * 2);
}
}
#else
// this gradient is brighter in the middle. It only works for stereo.
int nc = 2;
int c; for(c=0;c<nc;c++){
int top = (height / nc) * c;
int bot = height / nc;
int mid = height / (2 * nc);
int y; for(y=0;y<mid;y++){
int x; for(x=0;x<width;x++){
int y_ = top + y;
int val = 0xff * (1.0 + sinf(((float)(-mid + 2 * y)) / mid));
*(pbuf + y_ * width + x) = ((val) / 8 + ((x+y_) * 0xff) / (width * 2)) / 2;
y_ = top + bot - y - 1;
*(pbuf + (y_) * width + x) = ((val) / 8 + ((x+y_) * 0xff) / (width * 2)) / 2;
}
}
}
#endif
agl_enable(AGL_ENABLE_TEXTURE_2D | AGL_ENABLE_BLEND);
glGenTextures(1, ta->texture);
if(glGetError() != GL_NO_ERROR){ gerr ("couldnt create bg_texture."); goto out; }
agl_load_alphamap(pbuf, ta->texture[0], width, height);
out:
g_free(pbuf);
}
/*
* load the contents of a peak file from an Ardour project.
*/
int
wf_load_ardour_peak(Waveform* wv, const char* peak_file)
{
g_return_val_if_fail(wv, 0);
int fp = open(peak_file, O_RDONLY);
if(!fp){ gwarn ("file open failure."); goto out; }
dbg(2, "%s", peak_file);
size_t n_frames = get_n_words(wv, peak_file);
uint32_t bytes = n_frames * peak_byte_depth * WF_PEAK_VALUES_PER_SAMPLE;
//read the whole peak file into memory:
float* read_buf = g_malloc(bytes);
if(read(fp, read_buf, bytes) != bytes) gerr ("read error. couldnt read %i bytes from %s", bytes, peak_file);
close(fp);
//convert from float to short
short* buf = waveform_peak_malloc(wv, n_frames * sizeof(short) * WF_PEAK_VALUES_PER_SAMPLE);
int i; for(i=0;i<n_frames;i++){
//ardour peak files have negative peak first. ABS is used because values occasionally have incorrect sign.
buf[2 * i ] = ABS(read_buf[2 * i + 1] * (1 << 15));
buf[2 * i + 1] = -(ABS(read_buf[2 * i ]) * (1 << 15));
}
g_free(read_buf);
#if 0
dbg(1, "peaks:");
for (i=0;i<20;i++) printf(" %i %i\n", buf[2 * i], buf[2 * i + 1]);
#endif
int ch_num = wv->priv->peak.buf[WF_LEFT] ? 1 : 0; //this makes too many assumptions. better to pass explicitly as argument.
wv->priv->peak.buf[ch_num] = buf;
wv->priv->peak.size = n_frames * WF_PEAK_VALUES_PER_SAMPLE;
#ifdef ENABLE_CHECKS
int k; for(k=0;k<n_frames;k++){
if(wv->priv->peak.buf[0][2*k + 0] < 0.0){ gwarn("positive peak not positive"); break; }
if(wv->priv->peak.buf[0][2*k + 1] > 0.0){ gwarn("negative peak not negative"); break; }
}
#endif
out:
return 1;
}
void store_content_changed(GtkListStore* store, gpointer data)
{
PF;
GtkTreeIter iter;
if(!gtk_tree_model_get_iter_first((GtkTreeModel*)store, &iter)){ gerr ("cannot get iter."); return; }
int row_count = 0;
do {
if(++row_count < 100){
Sample* sample = samplecat_list_store_get_sample_by_iter(&iter);
if(sample){
console__show_result(sample);
sample_unref(sample);
}
}
} while (gtk_tree_model_iter_next((GtkTreeModel*)store, &iter));
console__show_result_footer(row_count);
}
int
main (int argc, char *argv[])
{
set_log_handlers();
wf_debug = 1;
gtk_init(&argc, &argv);
GdkGLConfig* glconfig;
if(!(glconfig = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE))){
gerr ("Cannot initialise gtkglext."); return EXIT_FAILURE;
}
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
canvas = gtk_drawing_area_new();
gtk_widget_set_can_focus (canvas, true);
gtk_widget_set_size_request (canvas, GL_WIDTH + 2 * HBORDER, 128);
gtk_widget_set_gl_capability (canvas, glconfig, NULL, 1, GDK_GL_RGBA_TYPE);
gtk_widget_add_events (canvas, GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_container_add((GtkContainer*)window, (GtkWidget*)canvas);
agl = agl_get_instance();
scene = (AGlRootActor*)agl_actor__new_root(canvas);
wfc = wf_canvas_new((AGlRootActor*)scene);
char* filename = find_wav(WAV);
w1 = waveform_load_new(filename);
g_free(filename);
g_signal_connect((gpointer)canvas, "realize", G_CALLBACK(on_canvas_realise), NULL);
g_signal_connect((gpointer)canvas, "size-allocate", G_CALLBACK(on_allocate), NULL);
g_signal_connect((gpointer)canvas, "expose-event", G_CALLBACK(agl_actor__on_expose), scene);
gtk_widget_show_all(window);
add_key_handlers((GtkWindow*)window, NULL, (Key*)&keys);
gboolean window_on_delete(GtkWidget* widget, GdkEvent* event, gpointer user_data){
gtk_main_quit();
return false;
}
static int ov2640_putreglist(FAR struct i2c_master_s *i2c,
FAR const struct ovr2640_reg_s *reglist,
size_t nentries)
{
FAR const struct ovr2640_reg_s *entry;
int ret;
for (entry = reglist; nentries > 0; nentries--, entry++)
{
ret = ov2640_putreg(i2c, entry->regaddr, entry->regval);
if (ret < 0)
{
gerr("ERROR: ov2640_putreg failed: %d\n", ret);
return ret;
}
}
return OK;
}
static gboolean
__init ()
{
dbg(2, "...");
if(!gl_context){
gtk_gl_init(NULL, NULL);
if(wf_debug){
gint major, minor;
gdk_gl_query_version (&major, &minor);
g_print ("GtkGLExt version %d.%d\n", major, minor);
}
}
glconfig = gdk_gl_config_new_by_mode( GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE );
if (!glconfig) { gerr ("Cannot initialise gtkglext."); return false; }
return true;
}
int
main (int argc, char* argv[])
{
if(sizeof(off_t) != 8){ gerr("sizeof(off_t)=%zu\n", sizeof(off_t)); return EXIT_FAILURE; }
set_log_handlers();
wf_debug = 0;
gtk_init(&argc, &argv);
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
#if 0
agl_get_instance()->pref_use_shaders = false;
#endif
WaveformView* waveform = waveform_view_new(NULL);
#if 0
waveform_view_set_show_rms(waveform, false);
waveform_view_add_layer(waveform, grid_actor(waveform_view_get_actor(waveform)), 0);
#endif
gtk_widget_set_size_request((GtkWidget*)waveform, 512, 256);
gtk_container_add((GtkContainer*)window, (GtkWidget*)waveform);
gtk_widget_show_all(window);
char* filename = find_wav(WAV);
waveform_view_load_file(waveform, filename);
g_free(filename);
add_key_handlers((GtkWindow*)window, waveform, (Key*)&keys);
gboolean window_on_delete(GtkWidget* widget, GdkEvent* event, gpointer user_data){
gtk_main_quit();
return false;
}
int ov2640_initialize(FAR struct i2c_master_s *i2c)
{
int ret;
/* Reset the OVR2640 */
ret = ov2640_reset(i2c);
if (ret < 0)
{
gerr("ERROR: ov2640_reset failed: %d\n", ret);
goto errout;
}
/* Check the CHIP ID */
ret = ovr2640_chipid(i2c);
if (ret < 0)
{
gerr("ERROR: ovr2640_chipid failed: %d\n", ret);
goto errout;
}
/* Initialize the OV2640 hardware */
#ifdef CONFIG_OV2640_JPEG
/* Initialize for JPEG output */
ret = ov2640_putreglist(i2c, g_ov2640_jpeg_init, OV2640_JPEG_INIT_NENTRIES);
if (ret < 0)
{
gerr("ERROR: ov2640_putreglist failed: %d\n", ret);
goto errout;
}
ret = ov2640_putreglist(i2c, g_ov2640_yuv422, OV2640_YUV422_NENTRIES);
if (ret < 0)
{
gerr("ERROR: ov2640_putreglist failed: %d\n", ret);
goto errout;
}
ret = ov2640_putreglist(i2c, g_ov2640_jpeg, OV2640_JPEG_NENTRIES);
if (ret < 0)
{
gerr("ERROR: ov2640_putreglist failed: %d\n", ret);
goto errout;
}
ret = ov2640_putreg(i2c, 0xff, 0x01);
if (ret < 0)
{
gerr("ERROR: ov2640_putreg failed: %d\n", ret);
goto errout;
}
ret = ov2640_putreg(i2c, 0x15, 0x00);
if (ret < 0)
{
gerr("ERROR: ov2640_putreg failed: %d\n", ret);
goto errout;
}
#if defined(CONFIG_OV2640_JPEG_QCIF_RESOLUTION)
ret = ov2640_putreglist(i2c, g_ov2640_jpeg_qcif_resolution,
OV2640_JPEG_QCIF_RESOUTION_NENTRIES);
#elif defined(CONFIG_OV2640_JPEG_QVGA_RESOLUTION)
ret = ov2640_putreglist(i2c, g_ov2640_jpeg_qvga_resolution,
OV2640_JPEG_QVGA_RESOUTION_NENTRIES);
#elif defined(CONFIG_OV2640_JPEG_CIF_RESOLUTION)
ret = ov2640_putreglist(i2c, g_ov2640_jpeg_cif_resolution,
OV2640_JPEG_CIF_RESOUTION_NENTRIES);
#elif defined(CONFIG_OV2640_JPEG_VGA_RESOLUTION)
ret = ov2640_putreglist(i2c, g_ov2640_jpeg_vga_resolution,
OV2640_JPEG_VGA_RESOUTION_NENTRIES);
#elif defined(CONFIG_OV2640_JPEG_SVGA_RESOLUTION)
ret = ov2640_putreglist(i2c, g_ov2640_jpeg_svga_resolution,
OV2640_JPEG_SVGA_RESOUTION_NENTRIES);
#elif defined(CONFIG_OV2640_JPEG_XVGA_RESOLUTION)
ret = ov2640_putreglist(i2c, g_ov2640_jpeg_xvga_resolution,
OV2640_JPEG_XVGA_RESOUTION_NENTRIES);
#elif defined(CONFIG_OV2640_JPEG_SXVGA_RESOLUTION)
ret = ov2640_putreglist(i2c, g_ov2640_jpeg_sxvga_resolution,
OV2640_JPEG_SXVGA_RESOUTION_NENTRIES);
#elif defined(CONFIG_OV2640_JPEG_UXGA_RESOLUTION)
ret = ov2640_putreglist(i2c, g_ov2640_jpeg_uxga_resolution,
OV2640_JPEG_UXGA_RESOUTION_NENTRIES);
#else
# error Unspecified JPEG resolution
#endif
if (ret < 0)
{
gerr("ERROR: ov2640_putreglist failed: %d\n", ret);
goto errout;
}
#else /* CONFIG_OV2640_JPEG */
/* Setup initial register values */
ret = ov2640_putreglist(i2c, g_ov2640_initialregs,
OV2640_INITIALREGS_NENTRIES);
if (ret < 0)
{
gerr("ERROR: ov2640_putreglist failed: %d\n", ret);
goto errout;
}
/* Setup image resolution */
ret = ov2640_putreglist(i2c, g_ov2640_resolution_common,
OV2640_RESOLUTION_COMMON_NENTRIES);
if (ret < 0)
{
gerr("ERROR: ov2640_putreglist failed: %d\n", ret);
goto errout;
}
#if defined(CONFIG_OV2640_QCIF_RESOLUTION)
ret = ov2640_putreglist(i2c, g_ov2640_qcif_resolution,
OV2640_QCIF_RESOLUTION_NENTRIES);
#elif defined(CONFIG_OV2640_QVGA_RESOLUTION)
ret = ov2640_putreglist(i2c, g_ov2640_qvga_resolution,
OV2640_QVGA_RESOLUTION_NENTRIES);
#elif defined(CONFIG_OV2640_CIF_RESOLUTION)
ret = ov2640_putreglist(i2c, g_ov2640_cif_resolution,
OV2640_CIF_RESOLUTION_NENTRIES);
#elif defined(CONFIG_OV2640_VGA_RESOLUTION)
ret = ov2640_putreglist(i2c, g_ov2640_vga_resolution,
OV2640_VGA_RESOLUTION_NENTRIES);
#elif defined(CONFIG_OV2640_SVGA_RESOLUTION)
ret = ov2640_putreglist(i2c, g_ov2640_svga_resolution,
OV2640_SVGA_RESOLUTION_NENTRIES);
#elif defined(CONFIG_OV2640_XGA_RESOLUTION)
ret = ov2640_putreglist(i2c, g_ov2640_xga_resolution,
OV2640_XGA_RESOLUTION_NENTRIES);
#elif defined(CONFIG_OV2640_SXGA_RESOLUTION)
ret = ov2640_putreglist(i2c, g_ov2640_sxga_resolution,
OV2640_SXGA_RESOLUTION_NENTRIES);
#elif defined(CONFIG_OV2640_UXGA_RESOLUTION)
ret = ov2640_putreglist(i2c, g_ov2640_uxga_resolution,
OV2640_UXGA_RESOLUTION_NENTRIES);
#else
# error Unknown image resolution
#endif
if (ret < 0)
{
gerr("ERROR: ov2640_putreglist failed: %d\n", ret);
goto errout;
}
/* Color format register settings */
ret = ov2640_putreglist(i2c, g_ov2640_colorfmt_common,
OV2640_COLORFMT_COMMON_NENTRIES);
if (ret < 0)
{
gerr("ERROR: ov2640_putreglist failed: %d\n", ret);
goto errout;
}
#if defined(CONFIG_OV2640_YUV422_COLORFMT)
ret = ov2640_putreglist(i2c, g_ov2640_yuv422_colorfmt,
OV2640_YUV422_COLORFMT_NENTRIES);
#elif defined(CONFIG_OV2640_RGB565_COLORFMT)
ret = ov2640_putreglist(i2c, g_ov2640_rgb565_colorfmt,
OV2640_RGB565_COLORFMT_NENTRIES);
#else
# error Unknown color format
#endif
if (ret < 0)
{
gerr("ERROR: ov2640_putreglist failed: %d\n", ret);
goto errout;
}
#endif /* CONFIG_OV2640_JPEG */
return OK;
errout:
gerr("ERROR: Failed to initialize the OV2640: %d\n", ret);
(void)ov2640_reset(i2c);
return ret;
}
NXHANDLE nx_connectinstance(FAR const char *svrmqname)
{
FAR struct nxfe_conn_s *conn;
struct nxsvrmsg_s outmsg;
char climqname[NX_CLIENT_MXNAMELEN];
struct mq_attr attr;
int ret;
/* Sanity checking */
#ifdef CONFIG_DEBUG_FEATURES
if (!svrmqname)
{
set_errno(EINVAL);
return NULL;
}
#endif
/* Allocate the NX client structure */
conn = (FAR struct nxfe_conn_s *)lib_uzalloc(sizeof(struct nxfe_conn_s));
if (!conn)
{
set_errno(ENOMEM);
goto errout;
}
/* Create the client MQ name */
nxmu_semtake(&g_nxlibsem);
conn->cid = g_nxcid++;
nxmu_semgive(&g_nxlibsem);
sprintf(climqname, NX_CLIENT_MQNAMEFMT, conn->cid);
/* Open the client MQ for reading */
attr.mq_maxmsg = CONFIG_NX_MXCLIENTMSGS;
attr.mq_msgsize = NX_MXCLIMSGLEN;
attr.mq_flags = 0;
#ifdef CONFIG_NX_BLOCKING
conn->crdmq = mq_open(climqname, O_RDONLY|O_CREAT, 0666, &attr);
#else
conn->crdmq = mq_open(climqname, O_RDONLY|O_CREAT|O_NONBLOCK, 0666, &attr);
#endif
if (conn->crdmq == (mqd_t)-1)
{
gerr("ERROR: mq_open(%s) failed: %d\n", climqname, errno);
goto errout_with_conn;
}
/* Open the server MQ for writing */
attr.mq_maxmsg = CONFIG_NX_MXSERVERMSGS;
attr.mq_msgsize = NX_MXSVRMSGLEN;
attr.mq_flags = 0;
conn->cwrmq = mq_open(svrmqname, O_WRONLY|O_CREAT, 0666, &attr);
if (conn->cwrmq == (mqd_t)-1)
{
gerr("ERROR: mq_open(%s) failed: %d\n", svrmqname, errno);
goto errout_with_rmq;
}
/* Inform the server that this client exists */
outmsg.msgid = NX_SVRMSG_CONNECT;
outmsg.conn = conn;
ret = nxmu_sendserver(conn, &outmsg, sizeof(struct nxsvrmsg_s));
if (ret < 0)
{
gerr("ERROR: nxmu_sendserver failed: %d\n", errno);
goto errout_with_wmq;
}
#if 0
/* Now read until we get a response to this message. The server will
* respond with either (1) NX_CLIMSG_CONNECTED, in which case the state
* will change to NX_CLISTATE_CONNECTED, or (2) NX_CLIMSG_DISCONNECTED
* in which case, nx_message will fail with errno = EHOSTDOWN.
*/
do
{
ret = nx_eventhandler((NXHANDLE)conn);
if (ret < 0)
{
gerr("ERROR: nx_message failed: %d\n", errno);
goto errout_with_wmq;
}
usleep(300000);
}
while (conn->state != NX_CLISTATE_CONNECTED);
#endif
return (NXHANDLE)conn;
errout_with_wmq:
mq_close(conn->cwrmq);
errout_with_rmq:
mq_close(conn->crdmq);
errout_with_conn:
lib_ufree(conn);
errout:
return NULL;
}
int
main (int argc, char* argv[])
{
if(sizeof(off_t) != 8){ gerr("sizeof(off_t)=%zu\n", sizeof(off_t)); return EXIT_FAILURE; }
set_log_handlers();
gtk_init(&argc, &argv);
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
static GtkWidget* box; box = gtk_vbox_new(FALSE, 4);
gtk_container_add((GtkContainer*)window, box);
WaveformView* waveform[2] = {waveform_view_new(NULL),};
waveform_view_set_show_rms(waveform[0], false);
gtk_box_pack_start((GtkBox*)box, (GtkWidget*)waveform[0], TRUE, TRUE, 0);
gtk_widget_show_all(window);
//#define WAV "test/data/mono_0:10.wav"
#define WAV "test/data/stereo_1.wav"
char* filename = g_build_filename(g_get_current_dir(), WAV, NULL);
waveform_view_load_file(waveform[0], filename);
g_free(filename);
gboolean key_press(GtkWidget* widget, GdkEventKey* event, gpointer user_data)
{
WaveformView** waveform = user_data;
switch(event->keyval){
case 61:
waveform_view_set_zoom(waveform[0], waveform[0]->zoom * 1.5);
break;
case 45:
waveform_view_set_zoom(waveform[0], waveform[0]->zoom / 1.5);
break;
case KEY_Left:
case KEY_KP_Left:
dbg(0, "left");
waveform_view_set_start(waveform[0], waveform[0]->start_frame - 8192 / waveform[0]->zoom);
break;
case KEY_Right:
case KEY_KP_Right:
dbg(0, "right");
waveform_view_set_start(waveform[0], waveform[0]->start_frame + 8192 / waveform[0]->zoom);
break;
case GDK_KEY_2:
if(!waveform[1]){
// TODO fix issues with 2 widgets sharing the same drawable ?
gtk_box_pack_start((GtkBox*)box, (GtkWidget*)(waveform[1] = waveform_view_new(NULL)), TRUE, TRUE, 0);
char* filename = g_build_filename(g_get_current_dir(), WAV, NULL);
waveform_view_load_file(waveform[1], filename);
g_free(filename);
gtk_widget_show((GtkWidget*)waveform[1]);
}
dbg(0, "2");
break;
case GDK_KP_Enter:
break;
case 113:
exit(EXIT_SUCCESS);
break;
case GDK_Delete:
break;
default:
dbg(0, "%i", event->keyval);
break;
}
return TRUE;
}
int
main (int argc, char *argv[])
{
set_log_handlers();
wf_debug = 0;
memset(&app, 0, sizeof(app));
gtk_init(&argc, &argv);
if(!(glconfig = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE))){
gerr ("Cannot initialise gtkglext."); return EXIT_FAILURE;
}
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
canvas = gtk_drawing_area_new();
#ifdef HAVE_GTK_2_18
gtk_widget_set_can_focus (canvas, true);
#endif
gtk_widget_set_size_request (canvas, 480, 64);
gtk_widget_set_gl_capability (canvas, glconfig, NULL, 1, GDK_GL_RGBA_TYPE);
gtk_widget_add_events (canvas, GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_container_add((GtkContainer*)window, (GtkWidget*)canvas);
g_signal_connect((gpointer)canvas, "realize", G_CALLBACK(on_canvas_realise), NULL);
g_signal_connect((gpointer)canvas, "size-allocate", G_CALLBACK(on_allocate), NULL);
g_signal_connect((gpointer)canvas, "expose_event", G_CALLBACK(on_expose), NULL);
gtk_widget_show_all(window);
gboolean key_press(GtkWidget* widget, GdkEventKey* event, gpointer user_data)
{
switch(event->keyval){
case 61:
start_zoom(zoom * 1.5);
break;
case 45:
start_zoom(zoom / 1.5);
break;
case KEY_Left:
case KEY_KP_Left:
dbg(0, "left");
break;
case KEY_Right:
case KEY_KP_Right:
dbg(0, "right");
break;
case (char)'a':
toggle_animate();
break;
case GDK_KP_Enter:
break;
case 113:
exit(EXIT_SUCCESS);
break;
case GDK_Delete:
break;
default:
dbg(0, "%i", event->keyval);
break;
}
return TRUE;
}
g_signal_connect(window, "key-press-event", G_CALLBACK(key_press), NULL);
gboolean window_on_delete(GtkWidget* widget, GdkEvent* event, gpointer user_data){
gtk_main_quit();
return false;
}
bool
draw_wave_buffer_v_hi(Renderer* renderer, WaveformActor* actor, int block, bool is_first, bool is_last, double x_block0)
{
//for use at resolution 1, operates on audio data, NOT peak data.
// @b_region - sample range within the current block. b_region.start is relative to the Waveform, not the block.
// @rect - the canvas area corresponding exactly to the WfSampleRegion. XXX changed.
// variable names: variables prefixed with x_ relate to screen coordinates (pixels), variables prefixed with s_ related to sample frames.
const Waveform* w = actor->waveform;
const WaveformContext* wfc = actor->canvas;
const WfActorPriv* _a = actor->priv;
const RenderInfo* ri = &_a->render_info;
VHiRenderer* vhr = (VHiRenderer*)renderer;
const WfRectangle* rect = &ri->rect;
WfAudioData* audio = &w->priv->audio;
if(!audio->n_blocks || w->offline) return false;
WfBuf16* buf = audio->buf16[block];
if(!buf) return false;
if(is_last) vhr->block_region_v_hi.len = (ri->region.start + ri->region.len) % WF_SAMPLES_PER_TEXTURE;
//alternative calculation of block_region_v_hi - does it give same results? NO
uint64_t st = MAX((uint64_t)(ri->region.start), (uint64_t)((block) * ri->samples_per_texture));
uint64_t e = MIN((uint64_t)(ri->region.start + ri->region.len), (uint64_t)((block + 1) * ri->samples_per_texture));
WfSampleRegion block_region_v_hi2 = {st, e - st};
//dbg(0, "block_region_v_hi=%Lu(%Lu)-->%Lu len=%Lu (buf->size=%Lu r->region=%Lu-->%Lu)", st, (uint64_t)block_region_v_hi.start, e, (uint64_t)block_region_v_hi2.len, ((uint64_t)buf->size), ((uint64_t)region.start), ((uint64_t)region.start) + ((uint64_t)region.len));
WfSampleRegion b_region = block_region_v_hi2;
g_return_val_if_fail(b_region.len <= buf->size, false);
if(rect->left + rect->len < ri->viewport.left){
gerr("rect is outside viewport");
}
_v_hi_set_gl_state(actor);
//#define BIG_NUMBER 4096
#define BIG_NUMBER 8192 // temporarily increased pending cropping to viewport-left
Range sr = {{0,0},{0,0}, 0}; //TODO check we are consistent in that these values are all *within the current block*
Range xr = {{0,0},{0,0}, 0};
const double zoom = rect->len / (double)ri->region.len;
const float _block_wid = WF_SAMPLES_PER_TEXTURE * zoom;
float block_rect_start = is_first ? fmodf(rect->left, _block_wid) : x_block0; // TODO simplify. why 2 separate cases needed? ** try just using the first case
WfRectangle b_rect = {block_rect_start, rect->top, b_region.len * zoom, rect->height};
if(!(ri->viewport.right > b_rect.left)) gwarn("outside viewport: vp.r=%.2f b_rect.l=%.2f", ri->viewport.right, b_rect.left);
g_return_val_if_fail(ri->viewport.right > b_rect.left, false);
if(!(b_rect.left + b_rect.len > ri->viewport.left)) gwarn("outside viewport: vp.l=%.1f b_rect.l=%.1f b_rect.len=%.1f", ri->viewport.left, b_rect.left, b_rect.len);
g_return_val_if_fail(b_rect.left + b_rect.len > ri->viewport.left, false);
#ifdef MULTILINE_SHADER
#elif defined(VERTEX_ARRAYS)
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
int n_lines = MIN(BIG_NUMBER, ri->viewport.right - b_rect.left); // TODO the arrays possibly can be smaller - dont use b_rect.left, use x0
Quad quads[n_lines];
Vertex texture_coords[n_lines * 4];
int j; for(j=0;j<n_lines;j++){
texture_coords[j * 4 ] = (Vertex){0.0, 0.0};
texture_coords[j * 4 + 1] = (Vertex){1.0, 0.0};
texture_coords[j * 4 + 2] = (Vertex){1.0, 1.0};
texture_coords[j * 4 + 3] = (Vertex){0.0, 1.0};
}
glVertexPointer (TWO_COORDS_PER_VERTEX, GL_FLOAT, 0, quads);
glTexCoordPointer (TWO_COORDS_PER_VERTEX, GL_FLOAT, 0, texture_coords);
#endif
#ifndef MULTILINE_SHADER
uint32_t rgba = actor->fg_colour;
const float r = ((float)((rgba >> 24) ))/0x100;
const float g = ((float)((rgba >> 16) & 0xff))/0x100;
const float b = ((float)((rgba >> 8) & 0xff))/0x100;
const float alpha = ((float)((rgba ) & 0xff))/0x100;
#endif
#ifdef MULTILINE_SHADER
xr.border = TEX_BORDER_HI;
#else
xr.border = 0;
#endif
sr.border = xr.border / zoom;
sr.inner.l = b_region.start % WF_SAMPLES_PER_TEXTURE;
//const int x0 = MAX(0, floor(viewport->left - rect->left) - 3);
const int x0 = b_rect.left;
//const int x0 = MIN(b_rect.left, viewport->left - xr.border); // no, x and s should not be calculated independently.
// sr.inner.l = (x0 - x_block0) / zoom; //TODO crop to viewport-left
const int s0 = sr.outer.l = sr.inner.l - sr.border;
xr.inner.l = x0;
xr.outer.l = x0 - xr.border;
const int x_bregion_end = b_rect.left + (b_region.start + b_region.len) * zoom;
xr.inner.r = MIN(MIN(MIN(
x0 + BIG_NUMBER,
(int)(b_rect.left + b_rect.len)),
ri->viewport.right),
x_bregion_end);
const int x_stop = xr.inner.r + xr.border;
/*
if(x_stop < b_rect.left + b_rect.len){
dbg(0, "stopping early. x_bregion_end=%i x0+B=%i", x_bregion_end, x0 + BIG_NUMBER);
}
*/
//dbg(0, "rect=%.2f-->%.2f b_region=%Lu-->%Lu viewport=%.1f-->%.1f zoom=%.3f", b_rect.left, b_rect.left + b_rect.len, b_region.start, b_region.start + ((uint64_t)b_region.len), viewport->left, viewport->right, zoom);
#ifdef MULTILINE_SHADER
int mls_tex_w = x_stop - x0 + 2 * TEX_BORDER_HI;
int mls_tex_h = 2; // TODO if we really are not going to add the indirection for x (for zoom > 1), use a 1d texture.
int t_width = agl_power_of_two(mls_tex_w);
guchar* _pbuf = g_new0(guchar, t_width * mls_tex_h);
guchar* pbuf[] = {_pbuf, _pbuf + t_width};
#endif
sr.inner.r = s0 + (xr.inner.r - xr.inner.l) / zoom;
sr.outer.r = s0 /* TODO should include border? */+ ((double)x_stop - x0) / zoom;
//dbg(0, "x0=%i x_stop=%i s=%i,%i,%i,%i xre=%i", x0, x_stop, sr.outer.l, sr.inner.l, sr.inner.r, sr.outer.r, x_bregion_end);
// because we access adjacent samples, s_max is the absolute maximum index into the sample buffer (must be less than).
int s_max = /*s0 + */sr.outer.r + 4 + sr.border;
if(s_max > buf->size){
int over = s_max - buf->size;
if(over < 4 + sr.border) dbg(0, "TODO block overlap - need to access next block");
else gerr("error at block changeover. s_max=%i over=%i", s_max, over);
}else{
// its fairly normal to be limited by region, as the region can be set deliberately to match the viewport.
// (the region can either correspond to a defined Section/Part of the waveform, or dynamically created with the viewport
// -if it is a defined Section, we must not go beyond it. As we do not know which case we have, we must honour the region limit)
//uint64_t b_region_end1 = (region.start + region.len) % buf->size; //TODO this should be the same as b_region_end2 ? but appears to be too short
uint64_t b_region_end2 = (!((b_region.start + b_region.len) % WF_SAMPLES_PER_TEXTURE)) ? WF_SAMPLES_PER_TEXTURE : (b_region.start + b_region.len) % WF_SAMPLES_PER_TEXTURE;//buf->size;
//if(s_max > b_region_end2) gwarn("limited by region length. region_end=%Lu %Lu", (uint64_t)((region.start + region.len) % buf->size), b_region_end2);
//s_max = MIN(s_max, (region.start + region.len) % buf->size);
s_max = MIN(s_max, b_region_end2);
}
s_max = MIN(s_max, buf->size);
//note that there is never any need to be separately limited by b_region - that should be taken care of by buffer limitation?
int c; for(c=0;c<w->n_channels;c++){
if(!buf->buf[c]){ gwarn("audio buf not set. c=%i", c); continue; }
if(!buf->buf[c]) continue;
#ifdef MULTILINE_SHADER
int val0 = ((2*c + 1) * 128) / w->n_channels;
if(mls_tex_w > TEX_BORDER_HI + 7) //TODO improve this test - make sure index is not negative --- may not be needed (texture is bigger now (includes borders))
memset((void*)((uintptr_t)pbuf[c] + (uintptr_t)(mls_tex_w - TEX_BORDER_HI)) - 7, val0, TEX_BORDER_HI + 7); // zero the rhs border in case it is not filled with content.
memset((void*)((uintptr_t)pbuf[c]), val0, t_width);
#endif
#ifndef MULTILINE_SHADER
int oldx = x0 - 1;
int oldy = 0;
#endif
int s = 0;
int i = 0;
//int x; for(x = x0; x < x0 + BIG_NUMBER && /*rect->left +*/ x < viewport->right + border_right; x++, i++){
// note that when using texture borders, at the viewport left edge x is NOT zero, it is TEX_BORDER_HI.
int x; for(x = xr.inner.l; x < x_stop; x++, i++){
double s_ = ((double)x - xr.inner.l) / zoom;
double dist = s_ - s; // dist = distance in samples from one pixel to the next.
//if(i < 5) dbg(0, "x=%i s_=%.3f dist=%.2f", x, s_, dist);
if (dist > 2.0) {
// if(dist > 5.0) gwarn("dist %.2f", dist);
int ds = dist - 1;
dist -= ds;
s += ds;
}
//if(c == 0 && i < 5) dbg(0, " ss=%i", s0 + s);
#ifdef MULTILINE_SHADER
if (s0 + s < 0){ // left border and no valid data.
pbuf[c][i] = val0;
continue;
}
#endif
if (s0 + s >= (int)buf->size ) { gwarn("end of block reached: b_region.start=%i b_region.end=%"PRIi64" %i", s0, b_region.start + ((uint64_t)b_region.len), buf->size); break; }
/*
if (s + 3 >= b_region.len) {
gwarn("end of b_region reached: b_region.len=%i x=%i s0=%i s=%i", b_region.len, x, s0, s);
break;
}
*/
short* d = buf->buf[c];
double y1 = (s0 + s < s_max) ? d[s0 + s ] : 0; //TODO have a separately loop for the last 4 values.
double y2 = (s0 + s+1 < s_max) ? d[s0 + s+1] : 0;
double y3 = (s0 + s+2 < s_max) ? d[s0 + s+2] : 0;
double y4 = (s0 + s+3 < s_max) ? d[s0 + s+3] : 0;
double d0 = dist;
double d1 = dist - 1.0;
double d2 = dist - 2.0;
double d3 = dist - 3.0;
//TODO for MULTILINE_SHADER we probably dont want b_rect.height to affect y.
int y = (int)(
(
- (d1 * d2 * d3 * y1) / 6
+ (d0 * d2 * d3 * y2) / 2
- (d0 * d1 * d3 * y3) / 2
+ (d0 * d1 * d2 * y4) / 6
)
* wfc->v_gain * (b_rect.height / (2.0 * w->n_channels )) / (1 << 15)
);
//if(i < 10) printf(" x=%i s=%i %i y=%i dist=%.2f s=%i %.2f\n", x, s0 + s, d[s0 + s], y, dist, s, floor((x / zoom) - 1));
#if defined (MULTILINE_SHADER)
if(i >= mls_tex_w){ gwarn("tex index out of range %i %i", i, mls_tex_w); break; }
{
//int val = ((2*c + 1) * 128 + y) / w->n_channels;
//if(val < 0 || val > 256) gwarn("val out of range: %i", val); -- will be out of range when vgain is high.
pbuf[c][i] = val0 + MIN(y, 63); // the 63 is to stop it wrapping - would be nice to remove this.
//if(i >= 0 && i < 10) dbg(0, " s=%i y2=%.4f y=%i val=%i", s + s0, y2, y, ((2*c + 1) * 128 + y) / w->n_channels);
}
#elif defined(VERTEX_ARRAYS)
{
//float ys = y * rect->height / 256.0;
float x0 = oldx;
float y0 = b_rect.top - oldy + b_rect.height / 2;
float x1 = x;
float y1 = b_rect.top - y + b_rect.height / 2;
float len = sqrtf(powf((y1 - y0), 2) + powf((x1 - x0), 2));
float xoff = (y1 - y0) * 5.0 / len;
float yoff = (x1 - x0) * 5.0 / len;
quads[i] = (Quad){
(Vertex){x0 - xoff/2, y0 + yoff/2},
(Vertex){x1 - xoff/2, y1 + yoff/2},
(Vertex){x1 + xoff/2, y1 - yoff/2},
(Vertex){x0 + xoff/2, y0 - yoff/2},
};
//if(i > 40 && i < 50) dbg(0, "len=%.2f xoff=%.2f yoff=%.2f (%.2f, %.2f) (%.2f, %.2f)", len, xoff, yoff, quads[i].v0.x, quads[i].v0.y, quads[i].v1.x, quads[i].v1.y);
}
#else
// draw straight line from old pos to new pos
_draw_line(
oldx, b_rect.top - oldy + b_rect.height / 2,
x, b_rect.top - y + b_rect.height / 2,
r, g, b, alpha);
#endif
#ifndef MULTILINE_SHADER
oldx = x;
oldy = y;
#endif
}
dbg(2, "n_lines=%i x=%i-->%i", i, x0, x);
#if defined (MULTILINE_SHADER)
#elif defined(VERTEX_ARRAYS)
glColor4f(r, g, b, alpha);
glPushMatrix();
glTranslatef(0.0, (w->n_channels == 2 ? -b_rect.height/4 : 0.0) + c * b_rect.height/2, 0.0);
GLsizei count = (i - 0) * 4;
glDrawArrays(GL_QUADS, 0, count);
glPopMatrix();
#endif
} // end channel
#if defined (MULTILINE_SHADER)
#define TEXELS_PER_PIXEL 1.0
guint texture =_wf_create_lines_texture(pbuf[0], t_width, mls_tex_h);
float len = MIN(viewport->right - viewport->left, b_rect.len); //the texture contents are cropped by viewport so we should do the same when setting the rect width.
AGlQuad t = {
((float)TEX_BORDER_HI)/((float)t_width),
0.0,
((float)((x_stop - x0) * TEXELS_PER_PIXEL)) / (float)t_width,
1.0
};
wfc->priv->shaders.lines->uniform.texture_width = t_width;
agl_use_program((AGlShader*)wfc->priv->shaders.lines); // to set the uniform
glPushMatrix();
glTranslatef(b_rect.left, 0.0, 0.0);
agl_textured_rect_real(texture, 0.0, b_rect.top, len, b_rect.height, &t);
glPopMatrix();
g_free(_pbuf);
#elif defined(VERTEX_ARRAYS)
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
#endif
// increment for next block
vhr->block_region_v_hi.start = (vhr->block_region_v_hi.start / WF_PEAK_BLOCK_SIZE + 1) * WF_PEAK_BLOCK_SIZE;
vhr->block_region_v_hi.len = WF_PEAK_BLOCK_SIZE - vhr->block_region_v_hi.start % WF_PEAK_BLOCK_SIZE;
return true;
}
int
main (int argc, char *argv[])
{
if(sizeof(off_t) != 8){ gerr("sizeof(off_t)=%zu\n", sizeof(off_t)); return EXIT_FAILURE; }
set_log_handlers();
wf_debug = 1;
gtk_init(&argc, &argv);
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
WaveformView* waveform = waveform_view_new(NULL);
waveform_view_set_show_rms(waveform, false);
#if 0
waveform_view_set_show_grid(waveform, true);
#endif
gtk_container_add((GtkContainer*)window, (GtkWidget*)waveform);
gtk_widget_show_all(window);
char* filename = find_wav();
waveform_view_load_file(waveform, filename);
g_free(filename);
gboolean key_press(GtkWidget* widget, GdkEventKey* event, gpointer user_data)
{
WaveformView* waveform = user_data;
int n_visible_frames = ((float)waveform->waveform->n_frames) / waveform->zoom;
switch(event->keyval){
case 61:
waveform_view_set_zoom(waveform, waveform->zoom * 1.5);
break;
case 45:
waveform_view_set_zoom(waveform, waveform->zoom / 1.5);
break;
case KEY_Left:
case KEY_KP_Left:
dbg(1, "left");
waveform_view_set_start(waveform, waveform->start_frame - n_visible_frames / 10);
break;
case KEY_Right:
case KEY_KP_Right:
dbg(1, "right");
waveform_view_set_start(waveform, waveform->start_frame + n_visible_frames / 10);
break;
case GDK_KP_Enter:
break;
case (char)'<':
break;
case '>':
break;
case 113:
exit(EXIT_SUCCESS);
break;
case GDK_Delete:
break;
default:
dbg(1, "%i", event->keyval);
break;
}
return TRUE;
}
/*
* Load a single audio block for the case where the audio is on a local filesystem.
* For thread-safety, the Waveform is not modified.
*/
gboolean
waveform_load_audio_block(Waveform* waveform, WfBuf16* buf16, int block_num)
{
//TODO handle split stereo files
g_return_val_if_fail(waveform, false);
// which parts of the audio file are present?
// tier 1: 0, 128
// tier 2: 0, 64, 128, 196
// tier 3: 0, 32, 64, 96, 128, ... 196
// tier 4: 0, 16, ...
// tier 5: 0, 8, ...
// tier 6: 0, 4, ...
// tier 7: 0, 2, ...
// tier 8: 0, 1, ...
//guint n_peaks = ((n_frames * 1 ) / WF_PEAK_RATIO) << audio->n_tiers_present;
//int spacing = WF_PEAK_RATIO >> (audio->n_tiers_present - 1);
uint64_t start_pos = block_num * (WF_PEAK_BLOCK_SIZE - 2.0 * TEX_BORDER * 256.0);
uint64_t end_pos = start_pos + WF_PEAK_BLOCK_SIZE;
int n_chans = waveform_get_n_channels(waveform);
g_return_val_if_fail(n_chans, false);
SF_INFO sfinfo;
SNDFILE* sffile;
sfinfo.format = 0;
if(!(sffile = sf_open(waveform->filename, SFM_READ, &sfinfo))){
gwarn ("not able to open input file %s.", waveform->filename);
puts(sf_strerror(NULL));
return false;
}
if(start_pos > sfinfo.frames){ gerr("startpos too high. %Li > %Li block=%i", start_pos, sfinfo.frames, block_num); return false; }
if(end_pos > sfinfo.frames){ dbg(1, "*** last block: end_pos=%Lu max=%Lu", end_pos, sfinfo.frames); end_pos = sfinfo.frames; }
sf_seek(sffile, start_pos, SEEK_SET);
dbg(1, "block=%s%i%s (%i/%i) start=%Li end=%Li", wf_bold, block_num, wf_white, block_num+1, waveform_get_n_audio_blocks(waveform), start_pos, end_pos);
sf_count_t n_frames = MIN(buf16->size, end_pos - start_pos); //1st of these isnt needed?
g_return_val_if_fail(buf16 && buf16->buf[WF_LEFT], false);
#ifdef WF_DEBUG
buf16->start_frame = start_pos;
#endif
gboolean sf_read_float_to_short(SNDFILE* sffile, WfBuf16* buf, int ch, sf_count_t n_frames)
{
float readbuf[buf->size];
sf_count_t readcount;
if((readcount = sf_readf_float(sffile, readbuf, n_frames)) < n_frames){
gwarn("unexpected EOF: %s", waveform->filename);
gwarn(" start_frame=%Li n_frames=%Lu/%Lu read=%Li", start_pos, n_frames, sfinfo.frames, readcount);
return false;
}
//convert to short
int j; for(j=0;j<readcount;j++){
buf->buf[ch][j] = readbuf[j] * (1 << 15);
}
return true;
}
int vnc_raw(FAR struct vnc_session_s *session, FAR struct nxgl_rect_s *rect)
{
FAR struct rfb_framebufferupdate_s *update;
FAR const uint8_t *src;
nxgl_coord_t srcwidth;
nxgl_coord_t srcheight;
nxgl_coord_t destwidth;
nxgl_coord_t destheight;
nxgl_coord_t deststride;
nxgl_coord_t updwidth;
nxgl_coord_t updheight;
nxgl_coord_t width;
nxgl_coord_t x;
nxgl_coord_t y;
unsigned int bytesperpixel;
unsigned int maxwidth;
size_t size;
ssize_t nsent;
uint8_t colorfmt;
union
{
vnc_convert8_t bpp8;
vnc_convert16_t bpp16;
vnc_convert32_t bpp32;
} convert;
/* Set up characteristics of the client pixel format to use on this
* update. These can change at any time if a SetPixelFormat is
* received asynchronously.
*/
bytesperpixel = (session->bpp + 7) >> 3;
maxwidth = CONFIG_VNCSERVER_UPDATE_BUFSIZE / bytesperpixel;
/* Set up the color conversion */
colorfmt = session->colorfmt;
switch (colorfmt)
{
case FB_FMT_RGB8_222:
convert.bpp8 = vnc_convert_rgb8_222;
break;
case FB_FMT_RGB8_332:
convert.bpp8 = vnc_convert_rgb8_332;
break;
case FB_FMT_RGB16_555:
convert.bpp16 = vnc_convert_rgb16_555;
break;
case FB_FMT_RGB16_565:
convert.bpp16 = vnc_convert_rgb16_565;
break;
case FB_FMT_RGB32:
convert.bpp32 = vnc_convert_rgb32_888;
break;
default:
gerr("ERROR: Unrecognized color format: %d\n", session->colorfmt);
return -EINVAL;
}
/* Get with width and height of the source and destination rectangles.
* The source rectangle many be larger than the destination rectangle.
* In that case, we will have to emit multiple rectangles.
*/
DEBUGASSERT(rect->pt1.x <= rect->pt2.x);
srcwidth = rect->pt2.x - rect->pt1.x + 1;
DEBUGASSERT(rect->pt1.y <= rect->pt2.y);
srcheight = rect->pt2.y - rect->pt1.y + 1;
deststride = srcwidth * bytesperpixel;
if (deststride > maxwidth)
{
deststride = maxwidth;
}
destwidth = deststride / bytesperpixel;
destheight = CONFIG_VNCSERVER_UPDATE_BUFSIZE / deststride;
if (destheight > srcheight)
{
destheight = srcheight;
}
/* Format the rectangle header. We may have to send several update
* messages if the pre-allocated outbuf is smaller than the rectangle.
* Each update contains a small "sub-rectangle" of the origin update.
*
* Loop until all sub-rectangles have been output. Start with the
* top row and transfer rectangles horizontally across each swath.
* The height of the swath is destwidth (the last may be shorter).
*
* NOTE that the loop also terminates of the color format changes
* asynchronously.
*/
for (y = rect->pt1.y;
srcheight > 0 && colorfmt == session->colorfmt;
srcheight -= updheight, y += updheight)
{
/* updheight = Height to update on this pass through the loop.
* This will be destheight unless fewer than that number of rows
* remain.
*/
updheight = destheight;
if (updheight > srcheight)
{
updheight = srcheight;
}
/* Loop until this horizontal swath has sent to the VNC client.
* Start with the leftmost pixel and transfer rectangles
* horizontally with width of destwidth until all srcwidth
* columns have been transferred (the last rectangle may be
* narrower).
*
* NOTE that the loop also terminates of the color format
* changes asynchronously.
*/
for (width = srcwidth, x = rect->pt1.x;
width > 0 && colorfmt == session->colorfmt;
width -= updwidth, x += updwidth)
{
/* updwidth = Width to update on this pass through the loop.
* This will be destwidth unless fewer than that number of
* columns remain.
*/
updwidth = destwidth;
if (updwidth > width)
{
updwidth = width;
}
/* Transfer the frame buffer data into the rectangle,
* performing the necessary color conversions.
*/
if (bytesperpixel == 1)
{
size = vnc_copy8(session, y, x, updheight, updwidth,
convert.bpp8);
}
else if (bytesperpixel == 2)
{
size = vnc_copy16(session, y, x, updheight, updwidth,
convert.bpp16);
}
else /* bytesperpixel == 4 */
{
size = vnc_copy32(session, y, x, updheight, updwidth,
convert.bpp32);
}
/* Format the FramebufferUpdate message */
update = (FAR struct rfb_framebufferupdate_s *)session->outbuf;
update->msgtype = RFB_FBUPDATE_MSG;
update->padding = 0;
rfb_putbe16(update->nrect, 1);
rfb_putbe16(update->rect[0].xpos, x);
rfb_putbe16(update->rect[0].ypos, y);
rfb_putbe16(update->rect[0].width, updwidth);
rfb_putbe16(update->rect[0].height, updheight);
rfb_putbe32(update->rect[0].encoding, RFB_ENCODING_RAW);
DEBUGASSERT(size <= CONFIG_VNCSERVER_UPDATE_BUFSIZE);
/* We are ready to send the update packet to the VNC client */
size += SIZEOF_RFB_FRAMEBUFFERUPDATE_S(SIZEOF_RFB_RECTANGE_S(0));
src = session->outbuf;
/* At the very last most, make certain that the color format
* has not changed asynchronously.
*/
if (colorfmt == session->colorfmt)
{
/* Okay send until all of the bytes are out. This may
* loop for the case where TCP write buffering is enabled
* and there are a limited number of IOBs available.
*/
do
{
nsent = psock_send(&session->connect, src, size, 0);
if (nsent < 0)
{
int errcode = get_errno();
gerr("ERROR: Send FrameBufferUpdate failed: %d\n",
errcode);
DEBUGASSERT(errcode > 0);
return -errcode;
}
DEBUGASSERT(nsent <= size);
src += nsent;
size -= nsent;
}
while (size > 0);
updinfo("Sent {(%d, %d),(%d, %d)}\n",
x, y, x + updwidth -1, y + updheight - 1);
}
}
}
return OK;
}
int
main (int argc, char *argv[])
{
set_log_handlers();
wf_debug = 1;
gtk_init(&argc, &argv);
if(!(glconfig = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE))){
gerr ("Cannot initialise gtkglext."); return EXIT_FAILURE;
}
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
canvas = gtk_drawing_area_new();
#ifdef HAVE_GTK_2_18
gtk_widget_set_can_focus (canvas, true);
#endif
gtk_widget_set_size_request (canvas, 320, 128);
gtk_widget_set_gl_capability (canvas, glconfig, NULL, 1, GDK_GL_RGBA_TYPE);
gtk_widget_add_events (canvas, GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_container_add((GtkContainer*)window, (GtkWidget*)canvas);
agl_get_instance()->pref_use_shaders = USE_SHADERS;
scene = (AGlRootActor*)agl_actor__new_root(canvas);
char* filename = g_build_filename(g_get_current_dir(), "test/data/mono_0:10.wav", NULL);
w1 = waveform_load_new(filename);
g_free(filename);
wfc = wf_canvas_new(scene);
int n_frames = waveform_get_n_frames(w1);
WfSampleRegion region[] = {
{0, n_frames - 1},
{0, n_frames / 2 - 1},
{n_frames / 4, n_frames / 4 - 1},
{n_frames / 2, n_frames / 2 - 1},
};
uint32_t colours[4][2] = {
{0xffffff77, 0x0000ffff},
{0x66eeffff, 0x0000ffff},
{0xffdd66ff, 0x0000ffff},
{0x66ff66ff, 0x0000ffff},
};
int i; for(i=0;i<G_N_ELEMENTS(a);i++){
a[i] = wf_canvas_add_new_actor(wfc, w1);
agl_actor__add_child((AGlActor*)scene, (AGlActor*)a[i]);
wf_actor_set_region(a[i], ®ion[i]);
wf_actor_set_colour(a[i], colours[i][0]);
}
g_signal_connect((gpointer)canvas, "realize", G_CALLBACK(on_canvas_realise), NULL);
g_signal_connect((gpointer)canvas, "size-allocate", G_CALLBACK(on_allocate), NULL);
g_signal_connect((gpointer)canvas, "expose-event", G_CALLBACK(agl_actor__on_expose), scene);
gtk_widget_show_all(window);
add_key_handlers((GtkWindow*)window, NULL, (Key*)&keys);
bool window_on_delete(GtkWidget* widget, GdkEvent* event, gpointer user_data)
{
gtk_main_quit();
return false;
}
FAR struct nxterm_state_s *
nxterm_register(NXTERM handle, FAR struct nxterm_window_s *wndo,
FAR const struct nxterm_operations_s *ops, int minor)
{
FAR struct nxterm_state_s *priv;
FAR const struct nx_font_s *fontset;
char devname[NX_DEVNAME_SIZE];
NXHANDLE hfont;
int ret;
DEBUGASSERT(handle && wndo && ops && (unsigned)minor < 256);
/* Allocate the driver structure */
priv = (FAR struct nxterm_state_s *)kmm_zalloc(sizeof(struct nxterm_state_s));
if (!priv)
{
gerr("ERROR: Failed to allocate the NX driver structure\n");
return NULL;
}
/* Initialize the driver structure */
priv->ops = ops;
priv->handle = handle;
priv->minor = minor;
memcpy(&priv->wndo, wndo, sizeof(struct nxterm_window_s));
nxsem_init(&priv->exclsem, 0, 1);
#ifdef CONFIG_DEBUG_FEATURES
priv->holder = NO_HOLDER;
#endif
#ifdef CONFIG_NXTERM_NXKBDIN
/* The waitsem semaphore is used for signaling and, hence, should not have
* priority inheritance enabled.
*/
nxsem_init(&priv->waitsem, 0, 0);
nxsem_setprotocol(&priv->waitsem, SEM_PRIO_NONE);
#endif
/* Connect to the font cache for the configured font characteristics */
priv->fcache = nxf_cache_connect(wndo->fontid, wndo->fcolor[0],
wndo->wcolor[0], CONFIG_NXTERM_BPP,
CONFIG_NXTERM_CACHESIZE);
if (priv->fcache == NULL)
{
gerr("ERROR: Failed to connect to font cache for font ID %d: %d\n",
wndo->fontid, errno);
goto errout;
}
/* Get the handle of the font managed by the font cache */
hfont = nxf_cache_getfonthandle(priv->fcache);
if (hfont == NULL)
{
gerr("ERROR: Failed to get handlr for font ID %d: %d\n",
wndo->fontid, errno);
goto errout;
}
/* Get information about the font set being used and save this in the
* state structure
*/
fontset = nxf_getfontset(hfont);
priv->fheight = fontset->mxheight;
priv->fwidth = fontset->mxwidth;
priv->spwidth = fontset->spwidth;
/* Set up the text cache */
priv->maxchars = CONFIG_NXTERM_MXCHARS;
/* Set the initial display position */
nxterm_home(priv);
/* Show the cursor */
priv->cursor.code = CONFIG_NXTERM_CURSORCHAR;
nxterm_showcursor(priv);
/* Register the driver */
snprintf(devname, NX_DEVNAME_SIZE, NX_DEVNAME_FORMAT, minor);
ret = register_driver(devname, &g_nxterm_drvrops, 0666, priv);
if (ret < 0)
{
gerr("ERROR: Failed to register %s\n", devname);
}
return (NXTERM)priv;
errout:
kmm_free(priv);
return NULL;
}
int up_fbinitialize(int display)
{
FAR struct lcdfb_dev_s *priv;
FAR struct lcd_dev_s *lcd;
struct fb_videoinfo_s vinfo;
struct nxgl_rect_s rect;
int ret;
lcdinfo("display=%d\n", display);
DEBUGASSERT((unsigned)display < UINT8_MAX);
/* Allocate the framebuffer state structure */
priv = (FAR struct lcdfb_dev_s *)kmm_zalloc(sizeof(struct lcdfb_dev_s));
if (priv == NULL)
{
lcderr("ERROR: Failed to allocate state structure\n");
return -ENOMEM;
}
/* Initialize the LCD-independent fields of the state structure */
priv->display = display;
priv->vtable.getvideoinfo = lcdfb_getvideoinfo,
priv->vtable.getplaneinfo = lcdfb_getplaneinfo,
#ifdef CONFIG_FB_CMAP
priv->vtable.getcmap = lcdfb_getcmap,
priv->vtable.putcmap = lcdfb_putcmap,
#endif
#ifdef CONFIG_FB_HWCURSOR
priv->vtable.getcursor = lcdfb_getcursor,
priv->vtable.setcursor = lcdfb_setcursor,
#endif
#ifdef CONFIG_LCD_EXTERNINIT
/* Use external graphics driver initialization */
lcd = board_graphics_setup(display);
if (lcd == NULL)
{
gerr("ERROR: board_graphics_setup failed, devno=%d\n", display);
return EXIT_FAILURE;
}
#else
/* Initialize the LCD device */
ret = board_lcd_initialize();
if (ret < 0)
{
lcderr("ERROR: board_lcd_initialize() failed: %d\n", ret);
goto errout_with_state;
}
/* Get the device instance */
lcd = board_lcd_getdev(display);
if (lcd == NULL)
{
lcderr("ERROR: board_lcd_getdev failed, devno=%d\n", display);
ret = -ENODEV;
goto errout_with_lcd;
}
#endif
priv->lcd = lcd;
/* Initialize the LCD-dependent fields of the state structure */
DEBUGASSERT(lcd->getvideoinfo != NULL);
ret = lcd->getvideoinfo(lcd, &vinfo);
if (ret < 0)
{
lcderr("ERROR: LCD getvideoinfo() failed: %d\n", ret);
goto errout_with_lcd;
}
priv->xres = vinfo.xres;
priv->yres = vinfo.yres;
DEBUGASSERT(lcd->getplaneinfo != NULL);
ret = lcd->getplaneinfo(lcd, VIDEO_PLANE, &priv->pinfo);
if (ret < 0)
{
lcderr("ERROR: LCD getplaneinfo() failed: %d\n", ret);
goto errout_with_lcd;
}
/* Allocate (and clear) the framebuffer */
priv->stride = ((size_t)priv->xres * priv->pinfo.bpp + 7) >> 3;
priv->fblen = priv->stride * priv->yres;
priv->fbmem = (FAR uint8_t *)kmm_zalloc(priv->fblen);
if (priv->fbmem == NULL)
{
lcderr("ERROR: Failed to allocate frame buffer memory\n");
ret = -ENOMEM;
goto errout_with_lcd;
}
/* Add the state structure to the list of framebuffer interfaces */
priv->flink = g_lcdfb;
g_lcdfb = priv;
/* Write the entire framebuffer to the LCD */
rect.pt1.x = 0;
rect.pt1.y = 0;
rect.pt2.x = priv->xres - 1;
rect.pt2.y = priv->yres - 1;
ret = lcdfb_update(priv, &rect);
if (ret < 0)
{
lcderr("FB update failed: %d\n", ret);
}
/* Turn the LCD on at 75% power */
(void)priv->lcd->setpower(priv->lcd, ((3*CONFIG_LCD_MAXPOWER + 3)/4));
return OK;
errout_with_lcd:
#ifndef CONFIG_LCD_EXTERNINIT
board_lcd_uninitialize();
errout_with_state:
#endif
kmm_free(priv);
return ret;
}