static block_t *BuildSsaFrame( const AVPacket *p_pkt, unsigned i_order )
{
if( p_pkt->size <= 0 )
return NULL;
char buffer[256];
const size_t i_buffer_size = __MIN( (int)sizeof(buffer) - 1, p_pkt->size );
memcpy( buffer, p_pkt->data, i_buffer_size );
buffer[i_buffer_size] = '\0';
/* */
int i_layer;
int h0, m0, s0, c0;
int h1, m1, s1, c1;
int i_position = 0;
if( sscanf( buffer, "Dialogue: %d,%d:%d:%d.%d,%d:%d:%d.%d,%n", &i_layer,
&h0, &m0, &s0, &c0, &h1, &m1, &s1, &c1, &i_position ) < 9 )
return NULL;
if( i_position <= 0 || (unsigned)i_position >= i_buffer_size )
return NULL;
char *p;
if( asprintf( &p, "%u,%d,%.*s", i_order, i_layer, p_pkt->size - i_position, p_pkt->data + i_position ) < 0 )
return NULL;
block_t *p_frame = block_heap_Alloc( p, strlen(p) + 1 );
if( p_frame )
p_frame->i_length = vlc_tick_from_sec((h1-h0) * 3600 +
(m1-m0) * 60 +
(s1-s0) * 1) +
VLC_TICK_FROM_MS (c1-c0) / 100;
return p_frame;
}
static int DemuxOnce (demux_t *demux, bool master)
{
demux_sys_t *sys = demux->p_sys;
mtime_t pts = date_Get (&sys->date);
lldiv_t d;
unsigned h, m, s, f;
d = lldiv (pts, CLOCK_FREQ);
f = d.rem * sys->date.i_divider_num / sys->date.i_divider_den / CLOCK_FREQ;
d = lldiv (d.quot, 60);
s = d.rem;
d = lldiv (d.quot, 60);
m = d.rem;
h = d.quot;
char *str;
int len = asprintf (&str, "%02u:%02u:%02u:%02u", h, m, s, f);
if (len == -1)
return -1;
block_t *block = block_heap_Alloc (str, len + 1);
if (unlikely(block == NULL))
return -1;
block->i_buffer = len;
assert(str[len] == '\0');
block->i_pts = block->i_dts = pts;
block->i_length = date_Increment (&sys->date, 1) - pts;
es_out_Send (demux->out, sys->es, block);
if (master)
es_out_SetPCR(demux->out, pts);
return 1;
}
/**
* Receives stream data.
*
* Dequeues pending incoming data for an HTTP/2 stream. If there is currently
* no data block, wait for one.
*
* \return a VLC data block, or NULL on stream error or end of stream
*/
static block_t *vlc_h2_stream_read(struct vlc_http_stream *stream)
{
struct vlc_h2_stream *s = (struct vlc_h2_stream *)stream;
struct vlc_h2_conn *conn = s->conn;
struct vlc_h2_frame *f;
vlc_h2_stream_lock(s);
while ((f = s->recv_head) == NULL && !s->recv_end && !s->interrupted)
{
mutex_cleanup_push(&conn->lock);
vlc_cond_wait(&s->recv_wait, &conn->lock);
vlc_cleanup_pop();
}
if (f == NULL)
{
vlc_h2_stream_unlock(s);
return NULL;
}
s->recv_head = f->next;
if (f->next == NULL)
{
assert(s->recv_tailp == &f->next);
s->recv_tailp = &s->recv_head;
}
/* Credit the receive window if missing credit exceeds 50%. */
uint_fast32_t credit = VLC_H2_INIT_WINDOW - s->recv_cwnd;
if (credit >= (VLC_H2_INIT_WINDOW / 2)
&& !vlc_h2_output_send(conn->out,
vlc_h2_frame_window_update(s->id, credit)))
s->recv_cwnd += credit;
vlc_h2_stream_unlock(s);
/* This, err, unconventional code to avoid copying data. */
block_t *block = block_heap_Alloc(f, sizeof (*f) + vlc_h2_frame_size(f));
if (unlikely(block == NULL))
{
free(f);
vlc_h2_stream_error(conn, s->id, VLC_H2_INTERNAL_ERROR);
return NULL;
}
size_t len;
uint8_t *buf = vlc_h2_frame_data_get(f, &len);
assert(block->i_buffer >= len);
assert(block->p_buffer <= buf);
assert(block->p_buffer + block->i_buffer >= buf + len);
block->p_buffer = buf;
block->i_buffer = len;
return block;
}
static int Demux( demux_t* p_demux )
{
demux_sys_t* p_sys = p_demux->p_sys;
/* Last one must be an end time */
while( p_sys->times.i_current + 1 < p_sys->times.i_count &&
tt_time_Convert( &p_sys->times.p_array[p_sys->times.i_current] ) <= p_sys->i_next_demux_time )
{
const int64_t i_playbacktime =
tt_time_Convert( &p_sys->times.p_array[p_sys->times.i_current] );
const int64_t i_playbackendtime =
tt_time_Convert( &p_sys->times.p_array[p_sys->times.i_current + 1] ) - 1;
if ( !p_sys->b_slave && p_sys->b_first_time )
{
es_out_Control( p_demux->out, ES_OUT_SET_PCR, VLC_TS_0 + i_playbacktime );
p_sys->b_first_time = false;
}
struct vlc_memstream stream;
if( vlc_memstream_open( &stream ) )
return VLC_DEMUXER_EGENERIC;
tt_node_ToText( &stream, (tt_basenode_t *) p_sys->p_rootnode,
&p_sys->times.p_array[p_sys->times.i_current] );
if( vlc_memstream_close( &stream ) == VLC_SUCCESS )
{
block_t* p_block = block_heap_Alloc( stream.ptr, stream.length );
if( p_block )
{
p_block->i_dts =
p_block->i_pts = VLC_TS_0 + i_playbacktime;
p_block->i_length = i_playbackendtime - i_playbacktime;
es_out_Send( p_demux->out, p_sys->p_es, p_block );
}
}
p_sys->times.i_current++;
}
if ( !p_sys->b_slave )
{
es_out_Control( p_demux->out, ES_OUT_SET_PCR, VLC_TS_0 + p_sys->i_next_demux_time );
p_sys->i_next_demux_time += CLOCK_FREQ / 8;
}
if( p_sys->times.i_current + 1 >= p_sys->times.i_count )
return VLC_DEMUXER_EOF;
return VLC_DEMUXER_SUCCESS;
}
block_t *DirBlock (access_t *p_access)
{
access_sys_t *p_sys = p_access->p_sys;
directory_t *current = p_sys->current;
if (p_access->info.b_eof)
return NULL;
if (current == NULL)
{ /* Startup: send the XSPF header */
static const char header[] =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<playlist version=\"1\" xmlns=\"http://xspf.org/ns/0/\" xmlns:vlc=\"http://www.videolan.org/vlc/playlist/ns/0/\">\n"
" <trackList>\n";
block_t *block = block_Alloc (sizeof (header) - 1);
if (!block)
goto fatal;
memcpy (block->p_buffer, header, sizeof (header) - 1);
/* "Open" the base directory */
current = malloc (sizeof (*current));
if (current == NULL)
{
block_Release (block);
goto fatal;
}
current->parent = NULL;
current->handle = p_sys->handle;
#ifndef HAVE_OPENAT
current->path = strdup (p_access->psz_filepath);
#endif
current->uri = p_sys->uri;
if (fstat (dirfd (current->handle), ¤t->st))
{
free (current);
block_Release (block);
goto fatal;
}
p_sys->handle = NULL;
p_sys->uri = NULL;
p_sys->current = current;
return block;
}
char *entry = vlc_readdir (current->handle);
if (entry == NULL)
{ /* End of directory, go back to parent */
closedir (current->handle);
p_sys->current = current->parent;
free (current->uri);
#ifndef HAVE_OPENAT
free (current->path);
#endif
free (current);
if (p_sys->current == NULL)
{ /* End of XSPF playlist */
char *footer;
int len = asprintf( &footer, " </trackList>\n" \
" <extension application=\"http://www.videolan.org/vlc/playlist/0\">\n" \
"%s" \
" </extension>\n" \
"</playlist>\n", p_sys->psz_xspf_extension );
if (unlikely(len == -1))
goto fatal;
block_t *block = block_heap_Alloc (footer, footer, len);
if (unlikely(block == NULL))
free (footer);
p_access->info.b_eof = true;
return block;
}
else
{
/* This was the end of a "subnode" */
/* Write the ID to the extension */
char *old_xspf_extension = p_sys->psz_xspf_extension;
if (old_xspf_extension == NULL)
goto fatal;
int len2 = asprintf( &p_sys->psz_xspf_extension, "%s </vlc:node>\n", old_xspf_extension );
if (len2 == -1)
goto fatal;
free( old_xspf_extension );
}
return NULL;
}
/* Skip current, parent and hidden directories */
if (entry[0] == '.')
{
free (entry);
return NULL;
}
/* Handle recursion */
if (p_sys->mode != MODE_COLLAPSE)
{
directory_t *sub = malloc (sizeof (*sub));
if (sub == NULL)
{
free (entry);
return NULL;
}
DIR *handle;
#ifdef HAVE_OPENAT
int fd = vlc_openat (dirfd (current->handle), entry, O_RDONLY);
if (fd != -1)
{
handle = fdopendir (fd);
if (handle == NULL)
close (fd);
}
else
handle = NULL;
#else
if (asprintf (&sub->path, "%s/%s", current->path, entry) != -1)
handle = vlc_opendir (sub->path);
else
handle = NULL;
#endif
if (handle != NULL)
{
sub->parent = current;
sub->handle = handle;
char *encoded = encode_URI_component (entry);
if ((encoded == NULL)
|| (asprintf (&sub->uri, "%s/%s", current->uri, encoded) == -1))
sub->uri = NULL;
free (encoded);
if ((p_sys->mode == MODE_NONE)
|| fstat (dirfd (handle), &sub->st)
|| has_inode_loop (sub)
|| (sub->uri == NULL))
{
free (entry);
closedir (handle);
free (sub->uri);
free (sub);
return NULL;
}
p_sys->current = sub;
/* Add node to xspf extension */
char *old_xspf_extension = p_sys->psz_xspf_extension;
if (old_xspf_extension == NULL)
{
free (entry);
goto fatal;
}
char *title = convert_xml_special_chars (entry);
free (entry);
if (title == NULL
|| asprintf (&p_sys->psz_xspf_extension, "%s"
" <vlc:node title=\"%s\">\n", old_xspf_extension,
title) == -1)
{
free (title);
goto fatal;
}
free (title);
free (old_xspf_extension);
return NULL;
}
else
free (sub);
}
/* Skip files with ignored extensions */
if (p_sys->ignored_exts != NULL)
{
const char *ext = strrchr (entry, '.');
if (ext != NULL)
{
size_t extlen = strlen (++ext);
for (const char *type = p_sys->ignored_exts, *end;
type[0]; type = end + 1)
{
end = strchr (type, ',');
if (end == NULL)
end = type + strlen (type);
if (type + extlen == end
&& !strncasecmp (ext, type, extlen))
{
free (entry);
return NULL;
}
if (*end == '\0')
break;
}
}
}
char *encoded = encode_URI_component (entry);
free (entry);
if (encoded == NULL)
goto fatal;
int len = asprintf (&entry,
" <track><location>%s/%s</location>\n" \
" <extension application=\"http://www.videolan.org/vlc/playlist/0\">\n" \
" <vlc:id>%d</vlc:id>\n" \
" </extension>\n" \
" </track>\n",
current->uri, encoded, p_sys->i_item_count++);
free (encoded);
if (len == -1)
goto fatal;
/* Write the ID to the extension */
char *old_xspf_extension = p_sys->psz_xspf_extension;
if (old_xspf_extension == NULL)
goto fatal;
int len2 = asprintf( &p_sys->psz_xspf_extension, "%s <vlc:item tid=\"%i\" />\n",
old_xspf_extension, p_sys->i_item_count-1 );
if (len2 == -1)
goto fatal;
free( old_xspf_extension );
block_t *block = block_heap_Alloc (entry, entry, len);
if (unlikely(block == NULL))
{
free (entry);
goto fatal;
}
return block;
fatal:
p_access->info.b_eof = true;
return NULL;
}
block_t *DirBlock (access_t *p_access)
{
access_sys_t *p_sys = p_access->p_sys;
directory_t *current = p_sys->current;
if (p_access->info.b_eof)
return NULL;
if (p_sys->header)
{ /* Startup: send the XSPF header */
static const char header[] =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<playlist version=\"1\" xmlns=\"http://xspf.org/ns/0/\" xmlns:vlc=\"http://www.videolan.org/vlc/playlist/ns/0/\">\n"
" <trackList>\n";
block_t *block = block_Alloc (sizeof (header) - 1);
if (!block)
goto fatal;
memcpy (block->p_buffer, header, sizeof (header) - 1);
p_sys->header = false;
return block;
}
if (current->i >= current->filec)
{ /* End of directory, go back to parent */
closedir (current->handle);
p_sys->current = current->parent;
free (current->uri);
free (current->filev);
#ifndef HAVE_OPENAT
free (current->path);
#endif
free (current);
if (p_sys->current == NULL)
{ /* End of XSPF playlist */
char *footer;
int len = asprintf (&footer, " </trackList>\n"
" <extension application=\"http://www.videolan.org/"
"vlc/playlist/0\">\n"
"%s"
" </extension>\n"
"</playlist>\n", p_sys->xspf_ext ? p_sys->xspf_ext : "");
if (unlikely(len == -1))
goto fatal;
block_t *block = block_heap_Alloc (footer, len);
p_access->info.b_eof = true;
return block;
}
else
{
/* This was the end of a "subnode" */
/* Write the ID to the extension */
char *old_xspf_ext = p_sys->xspf_ext;
if (old_xspf_ext != NULL
&& asprintf (&p_sys->xspf_ext, "%s </vlc:node>\n",
old_xspf_ext ? old_xspf_ext : "") == -1)
p_sys->xspf_ext = NULL;
free (old_xspf_ext);
}
return NULL;
}
char *entry = current->filev[current->i++];
/* Handle recursion */
if (p_sys->mode != MODE_COLLAPSE)
{
DIR *handle;
#ifdef HAVE_OPENAT
int fd = vlc_openat (dirfd (current->handle), entry,
O_RDONLY | O_DIRECTORY);
if (fd == -1)
{
if (errno == ENOTDIR)
goto notdir;
goto skip; /* File cannot be opened... forget it */
}
struct stat st;
if (fstat (fd, &st)
|| p_sys->mode == MODE_NONE
|| has_inode_loop (current, st.st_dev, st.st_ino)
|| (handle = fdopendir (fd)) == NULL)
{
close (fd);
goto skip;
}
#else
char *path;
if (asprintf (&path, "%s/%s", current->path, entry) == -1)
goto skip;
if ((handle = vlc_opendir (path)) == NULL)
goto notdir;
if (p_sys->mode == MODE_NONE)
goto skip;
#endif
directory_t *sub = malloc (sizeof (*sub));
if (unlikely(sub == NULL))
{
closedir (handle);
#ifndef HAVE_OPENAT
free (path);
#endif
goto skip;
}
sub->parent = current;
sub->handle = handle;
sub->filec = vlc_loaddir (handle, &sub->filev, visible, p_sys->compar);
if (sub->filec < 0)
sub->filev = NULL;
sub->i = 0;
#ifdef HAVE_OPENAT
sub->device = st.st_dev;
sub->inode = st.st_ino;
#else
sub->path = path;
#endif
p_sys->current = sub;
char *encoded = encode_URI_component (entry);
if (encoded == NULL
|| (asprintf (&sub->uri, "%s/%s", current->uri, encoded) == -1))
sub->uri = NULL;
free (encoded);
if (unlikely(sub->uri == NULL))
{
free (entry);
goto fatal;
}
/* Add node to XSPF extension */
char *old_xspf_ext = p_sys->xspf_ext;
EnsureUTF8 (entry);
char *title = convert_xml_special_chars (entry);
if (old_xspf_ext != NULL
&& asprintf (&p_sys->xspf_ext, "%s <vlc:node title=\"%s\">\n",
old_xspf_ext, title ? title : "?") == -1)
p_sys->xspf_ext = NULL;
free (old_xspf_ext);
free (title);
goto skip;
}
notdir:
/* Skip files with ignored extensions */
if (p_sys->ignored_exts != NULL)
{
const char *ext = strrchr (entry, '.');
if (ext != NULL)
{
size_t extlen = strlen (++ext);
for (const char *type = p_sys->ignored_exts, *end;
type[0]; type = end + 1)
{
end = strchr (type, ',');
if (end == NULL)
end = type + strlen (type);
if (type + extlen == end
&& !strncasecmp (ext, type, extlen))
{
free (entry);
return NULL;
}
if (*end == '\0')
break;
}
}
}
char *encoded = encode_URI_component (entry);
free (entry);
if (encoded == NULL)
goto fatal;
int len = asprintf (&entry,
" <track><location>%s/%s</location>\n" \
" <extension application=\"http://www.videolan.org/vlc/playlist/0\">\n" \
" <vlc:id>%d</vlc:id>\n" \
" </extension>\n" \
" </track>\n",
current->uri, encoded, p_sys->i_item_count++);
free (encoded);
if (len == -1)
goto fatal;
/* Write the ID to the extension */
char *old_xspf_ext = p_sys->xspf_ext;
if (old_xspf_ext != NULL
&& asprintf (&p_sys->xspf_ext, "%s <vlc:item tid=\"%i\" />\n",
old_xspf_ext, p_sys->i_item_count - 1) == -1)
p_sys->xspf_ext = NULL;
free (old_xspf_ext);
block_t *block = block_heap_Alloc (entry, len);
if (unlikely(block == NULL))
goto fatal;
return block;
fatal:
p_access->info.b_eof = true;
return NULL;
skip:
free (entry);
return NULL;
}
/**
* Processing callback
*/
static void Demux (void *data)
{
demux_t *demux = data;
demux_sys_t *sys = demux->p_sys;
xcb_connection_t *conn = sys->conn;
/* Determine capture region */
xcb_get_geometry_cookie_t gc;
xcb_query_pointer_cookie_t qc;
gc = xcb_get_geometry (conn, sys->window);
if (sys->follow_mouse)
qc = xcb_query_pointer (conn, sys->window);
xcb_get_geometry_reply_t *geo = xcb_get_geometry_reply (conn, gc, NULL);
if (geo == NULL)
{
msg_Err (demux, "bad X11 drawable 0x%08"PRIx32, sys->window);
discard:
if (sys->follow_mouse)
xcb_discard_reply (conn, gc.sequence);
return;
}
int w = sys->w;
int h = sys->h;
int x, y;
if (sys->follow_mouse)
{
xcb_query_pointer_reply_t *ptr =
xcb_query_pointer_reply (conn, qc, NULL);
if (ptr == NULL)
{
free (geo);
return;
}
if (w == 0 || w > geo->width)
w = geo->width;
x = ptr->win_x;
if (x < w / 2)
x = 0;
else if (x >= (int)geo->width - (w / 2))
x = geo->width - w;
else
x -= w / 2;
if (h == 0 || h > geo->height)
h = geo->height;
y = ptr->win_y;
if (y < h / 2)
y = 0;
else if (y >= (int)geo->height - (h / 2))
y = geo->height - h;
else
y -= h / 2;
}
else
{
int max;
x = sys->x;
max = (int)geo->width - x;
if (max <= 0)
goto discard;
if (w == 0 || w > max)
w = max;
y = sys->y;
max = (int)geo->height - y;
if (max <= 0)
goto discard;
if (h == 0 || h > max)
h = max;
}
/* Update elementary stream format (if needed) */
if (w != sys->cur_w || h != sys->cur_h)
{
if (sys->es != NULL)
es_out_Del (demux->out, sys->es);
/* Update composite pixmap */
if (sys->window != geo->root)
{
xcb_free_pixmap (conn, sys->pixmap); /* no-op first time */
xcb_composite_name_window_pixmap (conn, sys->window, sys->pixmap);
xcb_create_pixmap (conn, geo->depth, sys->pixmap,
geo->root, geo->width, geo->height);
}
sys->es = InitES (demux, w, h, geo->depth);
if (sys->es != NULL)
{
sys->cur_w = w;
sys->cur_h = h;
}
}
/* Capture screen */
xcb_drawable_t drawable =
(sys->window != geo->root) ? sys->pixmap : sys->window;
free (geo);
xcb_get_image_reply_t *img;
img = xcb_get_image_reply (conn,
xcb_get_image (conn, XCB_IMAGE_FORMAT_Z_PIXMAP, drawable,
x, y, w, h, ~0), NULL);
if (img == NULL)
return;
block_t *block = block_heap_Alloc (img, xcb_get_image_data (img),
xcb_get_image_data_length (img));
if (block == NULL)
return;
/* Send block - zero copy */
if (sys->es != NULL)
{
if (sys->pts == VLC_TS_INVALID)
sys->pts = mdate ();
block->i_pts = block->i_dts = sys->pts;
es_out_Control (demux->out, ES_OUT_SET_PCR, sys->pts);
es_out_Send (demux->out, sys->es, block);
sys->pts += sys->interval;
}
}
/**
* Processing callback
*/
static void Demux (void *data)
{
demux_t *demux = data;
demux_sys_t *p_sys = demux->p_sys;
xcb_connection_t *conn = p_sys->conn;
/* Update capture region (if needed) */
xcb_get_geometry_cookie_t gc = xcb_get_geometry (conn, p_sys->window);
int16_t x = p_sys->x, y = p_sys->y;
xcb_translate_coordinates_cookie_t tc;
if (p_sys->window != p_sys->root)
tc = xcb_translate_coordinates (conn, p_sys->window, p_sys->root,
x, y);
xcb_get_geometry_reply_t *geo = xcb_get_geometry_reply (conn, gc, NULL);
if (geo == NULL)
{
msg_Err (demux, "bad X11 drawable 0x%08"PRIx32, p_sys->window);
return;
}
uint16_t w = geo->width - x;
uint16_t h = geo->height - y;
free (geo);
if (p_sys->w > 0 && p_sys->w < w)
w = p_sys->w;
if (p_sys->h > 0 && p_sys->h < h)
h = p_sys->h;
if (p_sys->window != p_sys->root)
{
xcb_translate_coordinates_reply_t *coords =
xcb_translate_coordinates_reply (conn, tc, NULL);
if (coords == NULL)
return;
x = coords->dst_x;
y = coords->dst_y;
free (coords);
}
xcb_get_image_reply_t *img;
img = xcb_get_image_reply (conn,
xcb_get_image (conn, XCB_IMAGE_FORMAT_Z_PIXMAP, p_sys->root,
x, y, w, h, ~0), NULL);
if (img == NULL)
return;
/* Send block - zero copy */
block_t *block = block_heap_Alloc (img, xcb_get_image_data (img),
xcb_get_image_data_length (img));
if (block == NULL)
return;
vlc_mutex_lock (&p_sys->lock);
if (w != p_sys->fmt.video.i_visible_width
|| h != p_sys->fmt.video.i_visible_height)
{
if (p_sys->es != NULL)
es_out_Del (demux->out, p_sys->es);
p_sys->fmt.video.i_visible_width = p_sys->fmt.video.i_width = w;
p_sys->fmt.video.i_visible_height = p_sys->fmt.video.i_height = h;
p_sys->es = es_out_Add (demux->out, &p_sys->fmt);
}
/* Capture screen */
if (p_sys->es != NULL)
{
if (p_sys->pts == VLC_TS_INVALID)
p_sys->pts = mdate ();
block->i_pts = block->i_dts = p_sys->pts;
es_out_Control (demux->out, ES_OUT_SET_PCR, p_sys->pts);
es_out_Send (demux->out, p_sys->es, block);
p_sys->pts += p_sys->interval;
}
vlc_mutex_unlock (&p_sys->lock);
}
/**
* Processing callback
*/
static void Demux (void *opaque)
{
demux_t *demux = opaque;
demux_sys_t *sys = demux->p_sys;
xcb_connection_t *conn = sys->conn;
/* Determine capture region */
xcb_get_geometry_cookie_t gc;
xcb_query_pointer_cookie_t qc;
gc = xcb_get_geometry (conn, sys->window);
if (sys->follow_mouse)
qc = xcb_query_pointer (conn, sys->window);
xcb_get_geometry_reply_t *geo = xcb_get_geometry_reply (conn, gc, NULL);
if (geo == NULL)
{
msg_Err (demux, "bad X11 drawable 0x%08"PRIx32, sys->window);
discard:
if (sys->follow_mouse)
xcb_discard_reply (conn, gc.sequence);
return;
}
int w = sys->w;
int h = sys->h;
int x, y;
if (sys->follow_mouse)
{
xcb_query_pointer_reply_t *ptr =
xcb_query_pointer_reply (conn, qc, NULL);
if (ptr == NULL)
{
free (geo);
return;
}
if (w == 0 || w > geo->width)
w = geo->width;
x = ptr->win_x;
if (x < w / 2)
x = 0;
else if (x >= (int)geo->width - (w / 2))
x = geo->width - w;
else
x -= w / 2;
if (h == 0 || h > geo->height)
h = geo->height;
y = ptr->win_y;
if (y < h / 2)
y = 0;
else if (y >= (int)geo->height - (h / 2))
y = geo->height - h;
else
y -= h / 2;
}
else
{
int max;
x = sys->x;
max = (int)geo->width - x;
if (max <= 0)
goto discard;
if (w == 0 || w > max)
w = max;
y = sys->y;
max = (int)geo->height - y;
if (max <= 0)
goto discard;
if (h == 0 || h > max)
h = max;
}
/* Update elementary stream format (if needed) */
if (w != sys->cur_w || h != sys->cur_h)
{
if (sys->es != NULL)
es_out_Del (demux->out, sys->es);
/* Update composite pixmap */
if (sys->window != geo->root)
{
xcb_free_pixmap (conn, sys->pixmap); /* no-op first time */
xcb_composite_name_window_pixmap (conn, sys->window, sys->pixmap);
xcb_create_pixmap (conn, geo->depth, sys->pixmap,
geo->root, geo->width, geo->height);
}
sys->es = InitES (demux, w, h, geo->depth, &sys->bpp);
if (sys->es != NULL)
{
sys->cur_w = w;
sys->cur_h = h;
sys->bpp /= 8; /* bits -> bytes */
}
}
/* Capture screen */
xcb_drawable_t drawable =
(sys->window != geo->root) ? sys->pixmap : sys->window;
free (geo);
block_t *block = NULL;
#if HAVE_SYS_SHM_H
if (sys->shm)
{ /* Capture screen through shared memory */
size_t size = w * h * sys->bpp;
int id = shmget (IPC_PRIVATE, size, IPC_CREAT | 0777);
if (id == -1) /* XXX: fallback */
{
msg_Err (demux, "shared memory allocation error: %m");
goto noshm;
}
/* Attach the segment to X and capture */
xcb_shm_get_image_reply_t *img;
xcb_shm_get_image_cookie_t ck;
xcb_shm_attach (conn, sys->segment, id, 0 /* read/write */);
ck = xcb_shm_get_image (conn, drawable, x, y, w, h, ~0,
XCB_IMAGE_FORMAT_Z_PIXMAP, sys->segment, 0);
xcb_shm_detach (conn, sys->segment);
img = xcb_shm_get_image_reply (conn, ck, NULL);
xcb_flush (conn); /* ensure eventual detach */
if (img == NULL)
{
shmctl (id, IPC_RMID, 0);
goto noshm;
}
free (img);
/* Attach the segment to VLC */
void *shm = shmat (id, NULL, 0 /* read/write */);
shmctl (id, IPC_RMID, 0);
if (-1 == (intptr_t)shm)
{
msg_Err (demux, "shared memory attachment error: %m");
return;
}
block = block_shm_Alloc (shm, size);
if (unlikely(block == NULL))
shmdt (shm);
}
noshm:
#endif
if (block == NULL)
{ /* Capture screen through socket (fallback) */
xcb_get_image_reply_t *img;
img = xcb_get_image_reply (conn,
xcb_get_image (conn, XCB_IMAGE_FORMAT_Z_PIXMAP, drawable,
x, y, w, h, ~0), NULL);
if (img == NULL)
return;
uint8_t *data = xcb_get_image_data (img);
size_t datalen = xcb_get_image_data_length (img);
block = block_heap_Alloc (img, data + datalen - (uint8_t *)img);
if (block == NULL)
return;
block->p_buffer = data;
block->i_buffer = datalen;
}
/* Send block - zero copy */
if (sys->es != NULL)
{
block->i_pts = block->i_dts = mdate ();
es_out_Control (demux->out, ES_OUT_SET_PCR, block->i_pts);
es_out_Send (demux->out, sys->es, block);
}
}
