void my_blitstr(char *str,
t_bunny_pixelarray *pix,
t_bunny_pixelarray *text_pix,
t_text *text)
{
t_bunny_position pos[3];
int i;
int ratio;
if (!str || !pix || !text_pix || !text)
return ;
ps(pos, text);
if (!(ratio = text->police_size / 7))
ratio = 1;
i = 0;
while (str[i])
{
pos[0].x = text->x * str[i];
pos[1].x = text->x * (str[i] + 1);
if (str[i] == '\033')
analyse_codes(str, &i, text, pos);
else if ((str[i] > ' ' &&
pos[2].x >= 0 && pos[2].x < pix->clipable.clip_width)
&& (pos[2].x + 6 * ratio >= 0 &&
pos[2].x + 6 * ratio < pix->clipable.clip_width))
copy_area(pix, text_pix, pos, text);
i++;
pos[2].x += 6 * ratio;
}
}
static snd_pcm_sframes_t route_transfer(struct snd_pcm_plugin *plugin,
const struct snd_pcm_plugin_channel *src_channels,
struct snd_pcm_plugin_channel *dst_channels,
snd_pcm_uframes_t frames)
{
int nsrcs, ndsts, dst;
struct snd_pcm_plugin_channel *dvp;
int format;
if (snd_BUG_ON(!plugin || !src_channels || !dst_channels))
return -ENXIO;
if (frames == 0)
return 0;
nsrcs = plugin->src_format.channels;
ndsts = plugin->dst_format.channels;
format = plugin->dst_format.format;
dvp = dst_channels;
if (nsrcs <= 1) {
/* expand to all channels */
for (dst = 0; dst < ndsts; ++dst) {
copy_area(src_channels, dvp, frames, format);
dvp++;
}
return frames;
}
for (dst = 0; dst < ndsts && dst < nsrcs; ++dst) {
copy_area(src_channels, dvp, frames, format);
dvp++;
src_channels++;
}
if (dst < ndsts)
zero_areas(dvp, ndsts - dst, frames, format);
return frames;
}
static int
apply_image(int is_second, Gif_Stream *gfs, int imageno, uint16_t background)
{
int i, x, y, any_change;
Gif_Image *gfi = gfs->images[imageno];
Gif_Image *pgfi = imageno ? gfs->images[imageno - 1] : 0;
int width = gfi->width;
uint16_t map[256];
uint16_t *data = gdata[is_second];
uint16_t *last = glast[is_second];
Gif_Colormap *gfcm = gfi->local ? gfi->local : gfs->global;
/* set up colormap */
for (i = 0; i < 256; i++)
map[i] = 1;
if (gfs)
for (i = 0; i < gfcm->ncol; i++)
map[i] = gfcm->col[i].pixel;
if (gfi->transparent >= 0 && gfi->transparent < 256)
map[gfi->transparent] = TRANSP;
/* if this image's disposal is 'previous', save the post-disposal version in
'scratch' */
if (gfi->disposal == GIF_DISPOSAL_PREVIOUS) {
copy_area(scratch, data, gfi->left, gfi->top, gfi->width, gfi->height);
if (pgfi && pgfi->disposal == GIF_DISPOSAL_PREVIOUS)
copy_area(scratch, last, pgfi->left, pgfi->top, pgfi->width, pgfi->height);
else if (pgfi && pgfi->disposal == GIF_DISPOSAL_BACKGROUND)
fill_area(scratch, pgfi->left, pgfi->top, pgfi->width, pgfi->height, background);
}
/* uncompress and clip */
Gif_UncompressImage(gfs, gfi);
Gif_ClipImage(gfi, 0, 0, screen_width, screen_height);
any_change = imageno == 0;
{
int lf = 0, tp = 0, rt = 0, bt = 0;
expand_bounds(&lf, &tp, &rt, &bt, gfi);
if (pgfi && pgfi->disposal == GIF_DISPOSAL_PREVIOUS)
expand_bounds(&lf, &tp, &rt, &bt, pgfi);
else if (pgfi && pgfi->disposal == GIF_DISPOSAL_BACKGROUND) {
expand_bounds(&lf, &tp, &rt, &bt, pgfi);
fill_area(last, pgfi->left, pgfi->top, pgfi->width, pgfi->height, background);
} else
pgfi = 0;
for (y = tp; y < bt; ++y) {
uint16_t *outd = data + screen_width * y + lf;
if (!any_change)
memcpy(line, outd, (rt - lf) * sizeof(uint16_t));
if (pgfi && y >= pgfi->top && y < pgfi->top + pgfi->height)
memcpy(outd + pgfi->left - lf,
last + screen_width * y + pgfi->left,
pgfi->width * sizeof(uint16_t));
if (y >= gfi->top && y < gfi->top + gfi->height) {
uint16_t *xoutd = outd + gfi->left - lf;
const uint8_t *ind = gfi->img[y - gfi->top];
for (x = 0; x < width; ++x, ++ind, ++xoutd)
if (map[*ind] != TRANSP)
*xoutd = map[*ind];
}
if (!any_change && memcmp(line, outd, (rt - lf) * sizeof(uint16_t)) != 0)
any_change = 1;
}
}
Gif_ReleaseUncompressedImage(gfi);
Gif_ReleaseCompressedImage(gfi);
/* switch 'glast' with 'scratch' if necessary */
if (gfi->disposal == GIF_DISPOSAL_PREVIOUS) {
uint16_t *x = scratch;
scratch = glast[is_second];
glast[is_second] = x;
}
return any_change;
}
void ResourcePixmap::draw_data(Edit *edit,
int64_t edit_x,
int64_t edit_w,
int64_t pixmap_x,
int64_t pixmap_w,
int64_t pixmap_h,
int mode,
int indexes_only)
{
// Get new areas to fill in relative to pixmap
// Area to redraw relative to pixmap
int refresh_x = 0;
int refresh_w = 0;
// Ignore if called by resourcethread.
if(mode == 3) return;
int y = 0;
if(mwindow->edl->session->show_titles) y += mwindow->theme->get_image("title_bg_data")->get_h();
Track *track = edit->edits->track;
// If index can't be drawn, don't do anything.
int need_redraw = 0;
int64_t index_zoom = 0;
if(indexes_only)
{
IndexFile indexfile(mwindow);
if(!indexfile.open_index(edit->asset))
{
index_zoom = edit->asset->index_zoom;
indexfile.close_index();
}
if(index_zoom)
{
if(data_type == TRACK_AUDIO)
{
double asset_over_session = (double)edit->asset->sample_rate /
mwindow->edl->session->sample_rate;
asset_over_session;
if(index_zoom <= mwindow->edl->local_session->zoom_sample *
asset_over_session)
need_redraw = 1;
}
}
if(!need_redraw)
return;
}
// Redraw everything
if(edit->startsource != this->startsource ||
/* Incremental drawing is not possible with resource thread */
(data_type == TRACK_AUDIO /* &&
edit->asset->sample_rate != source_samplerate*/ ) ||
(data_type == TRACK_VIDEO /* &&
!EQUIV(edit->asset->frame_rate, source_framerate) */ ) ||
mwindow->edl->session->sample_rate != project_samplerate ||
mwindow->edl->session->frame_rate != project_framerate ||
mwindow->edl->local_session->zoom_sample != zoom_sample ||
mwindow->edl->local_session->zoom_track != zoom_track ||
this->pixmap_h != pixmap_h ||
(data_type == TRACK_AUDIO &&
mwindow->edl->local_session->zoom_y != zoom_y) ||
(mode == 2) ||
need_redraw)
{
// Shouldn't draw at all if zoomed in below index zoom.
refresh_x = 0;
refresh_w = pixmap_w;
}
else
{
// Start translated right
if(pixmap_w == this->pixmap_w && edit_x < this->edit_x && edit_w != pixmap_w)
{
refresh_w = this->edit_x - edit_x;
refresh_x = this->pixmap_w - refresh_w;
// Moved completely off the pixmap
if(refresh_w > this->pixmap_w)
{
refresh_w = this->pixmap_w;
refresh_x = 0;
}
else
{
copy_area(refresh_w,
y,
refresh_x,
mwindow->edl->local_session->zoom_track,
0,
y);
}
}
else
// Start translated left
if(pixmap_w == this->pixmap_w && edit_x > this->edit_x && edit_w != pixmap_w)
{
refresh_x = 0;
refresh_w = edit_x - this->edit_x;
// Moved completely off the pixmap
if(refresh_w > this->pixmap_w)
{
refresh_w = this->pixmap_w;
}
else
{
copy_area(0,
y,
this->pixmap_w - refresh_w,
mwindow->edl->local_session->zoom_track,
refresh_w,
y);
}
}
else
// Start translated right and pixmap came off of right side
if(pixmap_w < this->pixmap_w && edit_x < this->edit_x &&
this->edit_x + edit_w > this->pixmap_x + this->pixmap_w)
{
refresh_w = (this->edit_x + edit_w) - (this->pixmap_x + this->pixmap_w);
refresh_x = pixmap_w - refresh_w;
if(refresh_w >= pixmap_w)
{
refresh_x = 0;
refresh_w = pixmap_w;
}
else
{
copy_area(this->edit_x - edit_x,
y,
pixmap_w - refresh_w,
mwindow->edl->local_session->zoom_track,
0,
y);
}
}
else
// Start translated right and reduced in size on the right.
if(pixmap_w < this->pixmap_w && edit_x < this->edit_x)
{
refresh_x = 0;
refresh_w = 0;
copy_area(this->pixmap_w - pixmap_w,
y,
pixmap_w,
mwindow->edl->local_session->zoom_track,
0,
y);
}
else
// Start translated left and pixmap came off left side
if(edit_x >= 0 && this->edit_x < 0)
{
refresh_x = 0;
refresh_w = -this->edit_x;
if(refresh_w > pixmap_w)
{
refresh_w = pixmap_w;
}
else
{
copy_area(0,
y,
this->pixmap_w,
mwindow->edl->local_session->zoom_track,
refresh_w,
y);
}
}
else
// Start translated left and reduced in size on the right
if(pixmap_w < this->pixmap_w && edit_x > this->edit_x)
{
refresh_x = 0;
refresh_w = 0;
}
else
// Start translated right and left went into left side.
if(pixmap_w > this->pixmap_w && edit_x < 0 && this->edit_x > 0)
{
refresh_w = pixmap_w - (edit_x + this->pixmap_w);
refresh_x = pixmap_w - refresh_w;
// Moved completely off new pixmap
if(refresh_w > pixmap_w)
{
refresh_w = pixmap_w;
refresh_x = 0;
}
else
{
copy_area(-edit_x,
y,
refresh_x,
mwindow->edl->local_session->zoom_track,
0,
y);
}
}
else
// Start translated right and increased in size on the right
if(pixmap_w > this->pixmap_w && edit_x <= this->edit_x)
{
refresh_w = pixmap_w - this->pixmap_w;
refresh_x = pixmap_w - refresh_w;
}
else
// Start translated left and increased in size on the right
if(pixmap_w > this->pixmap_w && edit_x > this->edit_x)
{
refresh_x = 0;
refresh_w = edit_x - this->edit_x;
// Moved completely off new pixmap
if(refresh_w > this->pixmap_w)
{
refresh_w = pixmap_w;
refresh_x = 0;
}
// Shift and insert
else
{
copy_area(0,
y,
this->pixmap_w,
mwindow->edl->local_session->zoom_track,
refresh_w,
y);
}
}
}
// Update pixmap settings
this->edit_id = edit->id;
this->startsource = edit->startsource;
this->source_framerate = edit->asset->frame_rate;
this->source_samplerate = edit->asset->sample_rate;
this->project_framerate = edit->edl->session->frame_rate;
this->project_samplerate = edit->edl->session->sample_rate;
this->edit_x = edit_x;
this->pixmap_x = pixmap_x;
this->pixmap_w = pixmap_w;
this->pixmap_h = pixmap_h;
this->zoom_sample = mwindow->edl->local_session->zoom_sample;
this->zoom_track = mwindow->edl->local_session->zoom_track;
this->zoom_y = mwindow->edl->local_session->zoom_y;
// Draw in new background
if(refresh_w > 0)
mwindow->theme->draw_resource_bg(canvas,
this,
edit_x,
edit_w,
pixmap_x,
refresh_x,
y,
refresh_x + refresh_w,
mwindow->edl->local_session->zoom_track + y);
//printf("ResourcePixmap::draw_data 70\n");
// Draw media
if(track->draw)
{
switch(track->data_type)
{
case TRACK_AUDIO:
draw_audio_resource(edit, refresh_x, refresh_w);
break;
case TRACK_VIDEO:
draw_video_resource(edit,
edit_x,
edit_w,
pixmap_x,
pixmap_w,
refresh_x,
refresh_w,
mode);
break;
}
}
// Draw title
if(mwindow->edl->session->show_titles)
draw_title(edit, edit_x, edit_w, pixmap_x, pixmap_w);
}
/** MAIN */
int main( int argc, char **argv)
{
int i, frame_count;
int horz, vert; /* width and height of the frame */
uint8_t *frame[3]; /*pointer to the 3 color planes of the input frame */
struct area_s inarea;
struct color_yuv coloryuv;
int input_fd = 0; /* std in */
int output_fd = 1; /* std out */
int darker = 0; /* how much darker should the image be */
int copy_pixel = 0; /* how much pixels we should use for filling up the area */
int average_pixel = 0; /* how much pixel to use for average */
y4m_stream_info_t istream, ostream;
y4m_frame_info_t iframe;
inarea.width=0; inarea.height=0; inarea.voffset=0; inarea.hoffset=0;
coloryuv.luma = LUMA; /*Setting the luma to black */
coloryuv.chroma_b = CHROMA; /*Setting the chroma to center, means white */
coloryuv.chroma_r = CHROMA; /*Setting the chroma to center, means white */
(void)mjpeg_default_handler_verbosity(verbose);
/* processing commandline */
process_commandline(argc, argv, &inarea, &darker, ©_pixel, &coloryuv,
&average_pixel);
y4m_init_stream_info(&istream);
y4m_init_stream_info(&ostream);
y4m_init_frame_info(&iframe);
/* First read the header of the y4m stream */
i = y4m_read_stream_header(input_fd, &istream);
if ( i != Y4M_OK) /* a basic check if we really have y4m stream */
mjpeg_error_exit1("Input stream error: %s", y4m_strerr(i));
else
{
/* Here we copy the input stream info to the output stream info header */
y4m_copy_stream_info(&ostream, &istream);
/* Here we write the new output header to the output fd */
y4m_write_stream_header(output_fd, &ostream);
horz = y4m_si_get_width(&istream); /* get the width of the frame */
vert = y4m_si_get_height(&istream); /* get the height of the frame */
if ( (inarea.width + inarea.hoffset) > horz)
mjpeg_error_exit1("Input width and offset larger than framewidth,exit");
if ( (inarea.height + inarea.voffset) > vert)
mjpeg_error_exit1("Input height and offset larger than frameheight,exit");
/* Here we allocate the memory for on frame */
frame[0] = malloc( horz * vert );
frame[1] = malloc( (horz/2) * (vert/2) );
frame[2] = malloc( (horz/2) * (vert/2) );
/* Here we set the initial number of of frames */
/* We do not need it. Just for showing that is does something */
frame_count = 0 ;
/* This is the main loop here can filters effects, scaling and so
on be done with the video frames. Just up to your mind */
/* We read now a single frame with the header and check if it does not
have any problems or we have alreaddy processed the last without data */
while(y4m_read_frame(input_fd, &istream, &iframe, frame) == Y4M_OK)
{
frame_count++;
/* You can do something usefull here */
if (darker != 0)
set_darker(inarea, horz, vert, frame, darker);
else if (copy_pixel != 0)
copy_area(inarea, horz, vert, frame, copy_pixel);
else if (average_pixel != 0)
average_area(inarea, horz, vert, frame, average_pixel);
else
set_inactive(inarea, horz, vert, frame, &coloryuv);
/* Now we put out the read frame */
y4m_write_frame(output_fd, &ostream, &iframe, frame);
}
/* Cleaning up the data structures */
y4m_fini_stream_info(&istream);
y4m_fini_stream_info(&ostream);
y4m_fini_frame_info(&iframe);
}
/* giving back the memory to the system */
free(frame[0]);
frame[0] = 0;
free(frame[1]);
frame[1] = 0;
free(frame[2]);
frame[2] = 0;
exit(0); /* exiting */
}
