return FALSE;
}
- GST_DEBUG(0, "got %d mmap'd frames\n", (int)this->avail);
+ GST_DEBUG(0, "got %d mmap'd frames", (int)this->avail);
/* g_print ("snd_pcm_mmap_begin() sets avail = %d\n", this->avail); */
g_return_if_fail (this->mmap_open == TRUE);
- GST_DEBUG(0, "releasing mmap'd data region: %d frames\n", (int)this->avail);
+ GST_DEBUG(0, "releasing mmap'd data region: %d frames", (int)this->avail);
if ((err = snd_pcm_mmap_commit (this->handle, this->offset, this->avail)) < 0) {
g_warning("gstalsa: mmap commit failed: %s", snd_strerror(err));
src->cur_sector++;
if (src->cur_sector == src->end_sector) {
- GST_DEBUG (0,"setting EOS\n");
+ GST_DEBUG (0,"setting EOS");
gst_element_set_eos(GST_ELEMENT(src));
buf = GST_BUFFER (gst_event_new (GST_EVENT_EOS));
/* fail if the device couldn't be found */
if (src->d == NULL) {
- GST_DEBUG (0,"couldn't open device\n");
+ GST_DEBUG (0,"couldn't open device");
return FALSE;
}
/* set various other parameters */
if (src->default_sectors != -1) {
if ((src->default_sectors < 0) || (src->default_sectors > 100)) {
- GST_DEBUG (0,"default sector read size must be 1 <= n <= 100\n");
+ GST_DEBUG (0,"default sector read size must be 1 <= n <= 100");
cdda_close (src->d);
src->d = NULL;
return FALSE;
}
if (src->search_overlap != -1) {
if ((src->search_overlap < 0) || (src->search_overlap > 75)) {
- GST_DEBUG (0,"search overlap must be 0 <= n <= 75\n");
+ GST_DEBUG (0,"search overlap must be 0 <= n <= 75");
cdda_close (src->d);
src->d = NULL;
return FALSE;
/* open the disc */
if (cdda_open (src->d)) {
- GST_DEBUG (0,"couldn't open disc\n");
+ GST_DEBUG (0,"couldn't open disc");
cdda_close (src->d);
src->d = NULL;
return FALSE;
/* create the paranoia struct and set it up */
src->p = paranoia_init (src->d);
if (src->p == NULL) {
- GST_DEBUG (0,"couldn't create paranoia struct\n");
+ GST_DEBUG (0,"couldn't create paranoia struct");
return FALSE;
}
src->cur_sector = src->start_sector;
paranoia_seek (src->p, src->cur_sector, SEEK_SET);
- GST_DEBUG (0,"successfully seek'd to beginning of disk\n");
+ GST_DEBUG (0,"successfully seek'd to beginning of disk");
GST_FLAG_SET (src, CDPARANOIA_OPEN);
GNOME_VFS_OPEN_WRITE, sink->erase,
GNOME_VFS_PERM_USER_READ | GNOME_VFS_PERM_USER_WRITE
| GNOME_VFS_PERM_GROUP_READ);
- GST_DEBUG (0, "open: %s\n", gnome_vfs_result_to_string(result));
+ GST_DEBUG (0, "open: %s", gnome_vfs_result_to_string(result));
if (result != GNOME_VFS_OK) {
if (sink->erase == FALSE) {
g_signal_emit (G_OBJECT (sink),
if (GST_FLAG_IS_SET (sink, GST_GNOMEVFSSINK_OPEN))
{
result = gnome_vfs_write(sink->handle, GST_BUFFER_DATA(buf), GST_BUFFER_SIZE (buf), &bytes_written);
- GST_DEBUG (0, "write: %s, written_bytes: %Lu\n", gnome_vfs_result_to_string(result), bytes_written);
+ GST_DEBUG (0, "write: %s, written_bytes: %Lu", gnome_vfs_result_to_string(result), bytes_written);
if (bytes_written < GST_BUFFER_SIZE (buf))
{
printf ("gnomevfssink : Warning : %d bytes should be written, only %Lu bytes written\n",
if (src->new_seek)
{
/* FIXME do a discont, flush event */
- GST_DEBUG (0,"new seek\n");
+ GST_DEBUG (0,"new seek");
src->new_seek = FALSE;
}
} else {
{
result = gnome_vfs_seek(src->handle,
GNOME_VFS_SEEK_START, src->curoffset);
- GST_DEBUG(0, "new_seek: %s\n",
+ GST_DEBUG(0, "new_seek: %s",
gnome_vfs_result_to_string(result));
/* FIXME do a discont, flush event */
src->new_seek = FALSE;
result = gnome_vfs_read(src->handle, GST_BUFFER_DATA(buf),
src->bytes_per_read, &readbytes);
- GST_DEBUG(0, "read: %s, readbytes: %Lu\n",
+ GST_DEBUG(0, "read: %s, readbytes: %Lu",
gnome_vfs_result_to_string(result), readbytes);
/* deal with EOS */
if (readbytes == 0)
gnome_vfs_file_info_unref(info);
}
- GST_DEBUG(0, "open %s\n", gnome_vfs_result_to_string(result));
+ GST_DEBUG(0, "open %s", gnome_vfs_result_to_string(result));
}
GST_FLAG_SET(src, GST_GNOMEVFSSRC_OPEN);
GstBuffer *buf;
do {
- GST_DEBUG (0, "vorbisdec: pull \n");
+ GST_DEBUG (0, "vorbisdec: pull ");
buf = gst_pad_pull (vorbisdec->sinkpad);
}
} while (buf == NULL);
- GST_DEBUG (0, "vorbisdec: pull done\n");
+ GST_DEBUG (0, "vorbisdec: pull done");
return buf;
}
}
}
- GST_DEBUG (0, "vorbisdec: push\n");
+ GST_DEBUG (0, "vorbisdec: push");
gst_pad_push (vorbisdec->srcpad, outbuf);
- GST_DEBUG (0, "vorbisdec: push done\n");
+ GST_DEBUG (0, "vorbisdec: push done");
vorbis_synthesis_read (&vd, bout); /* tell libvorbis how
many samples we
memcpy (GST_BUFFER_DATA (outbuf) + vorbisenc->og.header_len, vorbisenc->og.body,
vorbisenc->og.body_len);
- GST_DEBUG (0, "vorbisenc: encoded buffer of %d bytes\n", GST_BUFFER_SIZE (outbuf));
+ GST_DEBUG (0, "vorbisenc: encoded buffer of %d bytes", GST_BUFFER_SIZE (outbuf));
gst_pad_push (vorbisenc->srcpad, outbuf);
GstRiff *riff;
gst_riff_list *list;
- GST_DEBUG (0,"gst_riff_encoder: making %4.4s encoder\n", (char *)&type);
+ GST_DEBUG (0,"gst_riff_encoder: making %4.4s encoder", (char *)&type);
riff = (GstRiff *)g_malloc(sizeof(GstRiff));
g_return_val_if_fail(riff != NULL, NULL);
g_return_val_if_fail(riff->state == GST_RIFF_STATE_INITIAL, GST_RIFF_EINVAL);
- GST_DEBUG (0,"gst_riff_encoder: add avih\n");
+ GST_DEBUG (0,"gst_riff_encoder: add avih");
ADD_LIST(riff, 0xB8, GST_RIFF_LIST_hdrl);
g_return_val_if_fail(riff->state == GST_RIFF_STATE_HASAVIH ||
riff->state == GST_RIFF_STATE_HASSTRF, GST_RIFF_EINVAL);
- GST_DEBUG (0,"gst_riff_encoder: add strh type %08x (%4.4s)\n", fcc_type, (char *)&fcc_type);
+ GST_DEBUG (0,"gst_riff_encoder: add strh type %08x (%4.4s)", fcc_type, (char *)&fcc_type);
ADD_LIST(riff, 108, GST_RIFF_LIST_strl);
g_return_val_if_fail(riff->state == GST_RIFF_STATE_HASSTRH, GST_RIFF_EINVAL);
- GST_DEBUG (0,"gst_riff_encoder: add strf\n");
+ GST_DEBUG (0,"gst_riff_encoder: add strf");
ADD_CHUNK(riff, GST_RIFF_TAG_strf, size);
riff->state = GST_RIFF_STATE_MOVI;
}
- GST_DEBUG (0,"gst_riff_encoder: add chunk type %08x (%4.4s)\n", chunk_type, (char *)&chunk_type);
+ GST_DEBUG (0,"gst_riff_encoder: add chunk type %08x (%4.4s)", chunk_type, (char *)&chunk_type);
ADD_CHUNK(riff, chunk_type, size);
size = GST_BUFFER_SIZE(buf);
last = off + size;
- GST_DEBUG (0,"gst_riff_parser: offset new buffer 0x%08lx size 0x%08x\n", off, GST_BUFFER_SIZE(buf));
+ GST_DEBUG (0,"gst_riff_parser: offset new buffer 0x%08lx size 0x%08x", off, GST_BUFFER_SIZE(buf));
if (riff->dataleft) {
gulong newsize;
- GST_DEBUG (0,"gst_riff_parser: recovering left data\n");
+ GST_DEBUG (0,"gst_riff_parser: recovering left data");
newsize = riff->dataleft_size + size;
riff->dataleft = g_realloc(riff->dataleft, newsize);
memcpy(riff->dataleft+riff->dataleft_size, GST_BUFFER_DATA(buf), size);
/* if we have an incomplete chunk from the previous buffer */
if (riff->incomplete_chunk) {
guint leftover;
- GST_DEBUG (0,"gst_riff_parser: have incomplete chunk %08x filled\n", riff->incomplete_chunk_size);
+ GST_DEBUG (0,"gst_riff_parser: have incomplete chunk %08x filled", riff->incomplete_chunk_size);
leftover = riff->incomplete_chunk->size - riff->incomplete_chunk_size;
if (leftover <= size) {
- GST_DEBUG (0,"gst_riff_parser: we can fill it from %08x with %08x bytes = %08x\n",
+ GST_DEBUG (0,"gst_riff_parser: we can fill it from %08x with %08x bytes = %08x",
riff->incomplete_chunk_size, leftover,
riff->incomplete_chunk_size+leftover);
memcpy(riff->incomplete_chunk->data+riff->incomplete_chunk_size, GST_BUFFER_DATA(buf), leftover);
riff->incomplete_chunk = NULL;
}
else {
- GST_DEBUG (0,"gst_riff_parser: we cannot fill it %08x >= %08lx\n", leftover, size);
+ GST_DEBUG (0,"gst_riff_parser: we cannot fill it %08x >= %08lx", leftover, size);
memcpy(riff->incomplete_chunk->data+riff->incomplete_chunk_size, GST_BUFFER_DATA(buf), size);
riff->incomplete_chunk_size += size;
return 0;
if (riff->nextlikely & 0x01) riff->nextlikely++;
- GST_DEBUG (0,"gst_riff_parser: next 0x%08x last 0x%08lx offset %08lx\n",riff->nextlikely, last, off);
+ GST_DEBUG (0,"gst_riff_parser: next 0x%08x last 0x%08lx offset %08lx",riff->nextlikely, last, off);
/* loop while the next likely chunk header is in this buffer */
while ((riff->nextlikely+12) <= last) {
guint32 *words = (guint32 *)((guchar *)GST_BUFFER_DATA(buf) + riff->nextlikely - off );
while (riff->chunks) {
chunk = g_list_nth_data(riff->chunks, 0);
- GST_DEBUG (0,"gst_riff_parser: next 0x%08x offset 0x%08lx size 0x%08x\n",riff->nextlikely,
+ GST_DEBUG (0,"gst_riff_parser: next 0x%08x offset 0x%08lx size 0x%08x",riff->nextlikely,
chunk->offset, chunk->size);
if (riff->nextlikely >= chunk->offset+chunk->size) {
- GST_DEBUG (0,"gst_riff_parser: found END LIST\n");
+ GST_DEBUG (0,"gst_riff_parser: found END LIST");
/* we have the end of the chunk on the stack, remove it */
riff->chunks = g_list_remove(riff->chunks, chunk);
}
else break;
}
- GST_DEBUG (0,"gst_riff_parser: next likely chunk is at offset 0x%08x\n",riff->nextlikely);
+ GST_DEBUG (0,"gst_riff_parser: next likely chunk is at offset 0x%08x",riff->nextlikely);
chunk = (GstRiffChunk *)g_malloc(sizeof(GstRiffChunk));
g_return_val_if_fail(chunk != NULL, GST_RIFF_ENOMEM);
if (chunk->id == GST_RIFF_TAG_LIST) {
- GST_DEBUG (0,"found LIST %s\n", gst_riff_id_to_fourcc(chunk->form));
+ GST_DEBUG (0,"found LIST %s", gst_riff_id_to_fourcc(chunk->form));
riff->nextlikely += 12;
/* we push the list chunk on our 'stack' */
riff->chunks = g_list_prepend(riff->chunks,chunk);
}
else {
- GST_DEBUG (0,"gst_riff_parser: chunk id offset %08x is 0x%08x '%s' and is 0x%08x long\n",
+ GST_DEBUG (0,"gst_riff_parser: chunk id offset %08x is 0x%08x '%s' and is 0x%08x long",
riff->nextlikely, GUINT32_FROM_LE (words[0]),
gst_riff_id_to_fourcc(GUINT32_FROM_LE (words[0])), GUINT32_FROM_LE (words[1]));
if (riff->nextlikely > last) {
guint left = size - (riff->nextlikely - chunk->size - off);
- GST_DEBUG (0,"make incomplete buffer %08x\n", left);
+ GST_DEBUG (0,"make incomplete buffer %08x", left);
chunk->data = g_malloc(chunk->size);
memcpy(chunk->data, (gchar *)(words+2), left);
riff->incomplete_chunk = chunk;
}
if ((riff->nextlikely+12) > last && !riff->incomplete_chunk) {
guint left = last - riff->nextlikely;
- GST_DEBUG (0,"gst_riff_parser: not enough data next 0x%08x last 0x%08lx %08x %08lx\n",riff->nextlikely,
+ GST_DEBUG (0,"gst_riff_parser: not enough data next 0x%08x last 0x%08lx %08x %08lx",riff->nextlikely,
last, left, off);
riff->dataleft = g_malloc(left);
"law", GST_PROPS_INT (0),
"endianness", GST_PROPS_INT (G_BYTE_ORDER),
"signed", GST_PROPS_BOOLEAN (TRUE),
- "width", GST_PROPS_LIST (GST_PROPS_INT (8), GST_PROPS_LIST (16)),
- "depth", GST_PROPS_LIST (GST_PROPS_INT (8), GST_PROPS_LIST (16)),
+ "width", GST_PROPS_LIST (GST_PROPS_INT (8), GST_PROPS_INT (16)),
+ "depth", GST_PROPS_LIST (GST_PROPS_INT (8), GST_PROPS_INT (16)),
"rate", GST_PROPS_INT_RANGE (4000, 48000), /* FIXME */
"channels", GST_PROPS_INT_RANGE (1, 2)
),
"law", GST_PROPS_INT (0),
"endianness", GST_PROPS_INT (G_BYTE_ORDER),
"signed", GST_PROPS_BOOLEAN (TRUE),
- "width", GST_PROPS_LIST (GST_PROPS_INT (8), GST_PROPS_LIST (16)),
- "depth", GST_PROPS_LIST (GST_PROPS_INT (8), GST_PROPS_LIST (16)),
+ "width", GST_PROPS_LIST (GST_PROPS_INT (8), GST_PROPS_INT (16)),
+ "depth", GST_PROPS_LIST (GST_PROPS_INT (8), GST_PROPS_INT (16)),
"rate", GST_PROPS_INT_RANGE (4000, 48000), /* FIXME */
"channels", GST_PROPS_INT_RANGE (1, 2)
),
p = (GstPad*) sinkpads->data;
if (p != pad && p != adder->srcpad) {
if (!gst_pad_try_set_caps (p, caps)) {
- GST_DEBUG (0, "caps mismatch; disconnecting and removing pad %s:%s (peer %s:%s)\n",
+ GST_DEBUG (0, "caps mismatch; disconnecting and removing pad %s:%s (peer %s:%s)",
GST_DEBUG_PAD_NAME (p), GST_DEBUG_PAD_NAME (GST_PAD_PEER (p)));
gst_pad_disconnect (GST_PAD (GST_PAD_PEER (p)), p);
remove = g_list_prepend (remove, p);
/* get data from all of the sinks */
inputs = adder->input_channels;
- GST_DEBUG (0, "starting to cycle through channels\n");
+ GST_DEBUG (0, "starting to cycle through channels");
while (inputs) {
input = (GstAdderInputChannel *) inputs->data;
- GST_DEBUG (0, "looking into channel %p\n", input);
+ GST_DEBUG (0, "looking into channel %p", input);
/* get data from the bytestream of each input channel. we need to check for
events before passing on the data to the output buffer. */
/* if we get an EOS event from one of our sink pads, we assume that
pad's finished handling data. delete the bytestream, free up the
pad, and free up the memory associated with the input channel. */
- GST_DEBUG (0, "got an EOS event\n");
+ GST_DEBUG (0, "got an EOS event");
gst_bytestream_destroy (input->bytestream);
/* gst_object_unref (GST_OBJECT (input->sinkpad)); this causes problems */
/* here's where the data gets copied. this is a little nasty looking
because it's the same code pretty much 3 times, except each time uses
different data types and clamp limits. */
- GST_DEBUG (0, "copying %d bytes from channel %p to output data %p in buffer %p\n",
+ GST_DEBUG (0, "copying %d bytes from channel %p to output data %p in buffer %p",
GST_BUFFER_SIZE (buf_out), input, GST_BUFFER_DATA (buf_out), buf_out);
if (adder->format == GST_ADDER_FORMAT_INT) {
gst_bytestream_flush (input->bytestream, GST_BUFFER_SIZE (buf_out));
- GST_DEBUG (0, "done copying data\n");
+ GST_DEBUG (0, "done copying data");
}
inputs = g_slist_next (inputs);
/* send it out */
- GST_DEBUG (0, "pushing buf_out\n");
+ GST_DEBUG (0, "pushing buf_out");
gst_pad_push (adder->srcpad, buf_out);
} while (TRUE);
src->freq = g_value_get_float(value);
src->table_inc = src->table_size * src->freq / src->samplerate;
- /*GST_DEBUG(GST_CAT_PARAMS, "freq %f\n", src->freq); */
+ /*GST_DEBUG(GST_CAT_PARAMS, "freq %f", src->freq); */
}
static inline void
{
GstVideoscale *videoscale = GST_VIDEOSCALE (gst_pad_get_parent (pad));
- GST_DEBUG(0,"videoscale_negotiate_src\n");
+ GST_DEBUG(0,"videoscale_negotiate_src");
if(*caps==NULL){
return GST_PAD_NEGOTIATE_FAIL;
static GstPadNegotiateReturn
videoscale_negotiate_sink (GstPad *pad, GstCaps **caps, gpointer *data)
{
- GST_DEBUG(0,"videoscale_negotiate_sink\n");
+ GST_DEBUG(0,"videoscale_negotiate_sink");
if (*caps==NULL)
return GST_PAD_NEGOTIATE_FAIL;
{
GstVideoscale *videoscale;
- GST_DEBUG(0,"gst_videoscale_sinkconnect\n");
+ GST_DEBUG(0,"gst_videoscale_sinkconnect");
videoscale = GST_VIDEOSCALE (gst_pad_get_parent (pad));
if (!GST_CAPS_IS_FIXED (caps)) {
gst_videoscale_setup(videoscale);
- GST_DEBUG (0,"target size %d x %d\n",videoscale->targetwidth,
+ GST_DEBUG (0,"target size %d x %d",videoscale->targetwidth,
videoscale->targetheight);
- GST_DEBUG(0,"width %d\n",videoscale->targetwidth);
+ GST_DEBUG(0,"width %d",videoscale->targetwidth);
gst_pad_try_set_caps (videoscale->srcpad,
GST_CAPS_NEW (
"videoscale_src",
static void
gst_videoscale_init (GstVideoscale *videoscale)
{
- GST_DEBUG(0,"gst_videoscale_init\n");
+ GST_DEBUG(0,"gst_videoscale_init");
videoscale->sinkpad = gst_pad_new_from_template (
GST_PADTEMPLATE_GET (sink_templ), "sink");
/*gst_pad_set_negotiate_function(videoscale->sinkpad,videoscale_negotiate_sink); */
gulong size;
GstBuffer *outbuf;
- GST_DEBUG (0,"gst_videoscale_chain\n");
+ GST_DEBUG (0,"gst_videoscale_chain");
g_return_if_fail (pad != NULL);
g_return_if_fail (GST_IS_PAD (pad));
videoscale->format = gst_caps_get_int (gst_pad_get_caps(pad), "format");
gst_videoscale_setup(videoscale);
}
- GST_DEBUG (0,"gst_videoscale_chain: got buffer of %ld bytes in '%s'\n",size,
+ GST_DEBUG (0,"gst_videoscale_chain: got buffer of %ld bytes in '%s'",size,
GST_OBJECT_NAME (videoscale));
-GST_DEBUG(0,"size=%ld from=%dx%d to=%dx%d newsize=%d\n",
+GST_DEBUG(0,"size=%ld from=%dx%d to=%dx%d newsize=%d",
size,
videoscale->width, videoscale->height,
videoscale->targetwidth, videoscale->targetheight,
/*g_return_if_fail(videoscale->scale_cc != NULL); */
videoscale->scale_cc(videoscale, data, GST_BUFFER_DATA(outbuf));
- GST_DEBUG (0,"gst_videoscale_chain: pushing buffer of %d bytes in '%s'\n",GST_BUFFER_SIZE(outbuf),
+ GST_DEBUG (0,"gst_videoscale_chain: pushing buffer of %d bytes in '%s'",GST_BUFFER_SIZE(outbuf),
GST_OBJECT_NAME (videoscale));
gst_pad_push(videoscale->srcpad, outbuf);
g_return_if_fail(GST_IS_VIDEOSCALE(object));
src = GST_VIDEOSCALE(object);
- GST_DEBUG(0,"gst_videoscale_set_property\n");
+ GST_DEBUG(0,"gst_videoscale_set_property");
switch (prop_id) {
case ARG_WIDTH:
src->targetwidth = g_value_get_int (value);
switch (scale->method) {
case GST_VIDEOSCALE_POINT_SAMPLE:
scale->scaler = gst_videoscale_scale_point_sample;
- GST_DEBUG (0,"videoscale: scaling method POINT_SAMPLE\n");
+ GST_DEBUG (0,"videoscale: scaling method POINT_SAMPLE");
break;
case GST_VIDEOSCALE_NEAREST:
#ifdef HAVE_CPU_I386
#else
scale->scaler = gst_videoscale_scale_nearest;
#endif
- GST_DEBUG (0,"videoscale: scaling method NEAREST\n");
+ GST_DEBUG (0,"videoscale: scaling method NEAREST");
break;
case GST_VIDEOSCALE_BILINEAR:
scale->scaler = gst_videoscale_scale_plane_slow;
scale->filter = gst_videoscale_bilinear;
- GST_DEBUG (0,"videoscale: scaling method BILINEAR\n");
+ GST_DEBUG (0,"videoscale: scaling method BILINEAR");
break;
case GST_VIDEOSCALE_BICUBIC:
scale->scaler = gst_videoscale_scale_plane_slow;
scale->filter = gst_videoscale_bicubic;
- GST_DEBUG (0,"videoscale: scaling method BICUBIC\n");
+ GST_DEBUG (0,"videoscale: scaling method BICUBIC");
break;
default:
g_print("videoscale: unsupported scaling method %d\n", scale->method);
int sh = scale->height;
int dw = scale->targetwidth;
int dh = scale->targetheight;
- GST_DEBUG (0,"videoscale: scaling RGB %dx%d to %dx%d\n", sw, sh, dw, dh);
+ GST_DEBUG (0,"videoscale: scaling RGB %dx%d to %dx%d", sw, sh, dw, dh);
switch (scale->scale_bytes) {
case 2:
break;
}
- GST_DEBUG (0,"videoscale: %p %p\n", src, dest);
+ GST_DEBUG (0,"videoscale: %p %p", src, dest);
scale->scaler(scale, src, dest, sw, sh, dw, dh);
}
int dw = scale->targetwidth;
int dh = scale->targetheight;
- GST_DEBUG (0,"videoscale: scaling YUV420P %dx%d to %dx%d\n", sw, sh, dw, dh);
+ GST_DEBUG (0,"videoscale: scaling YUV420P %dx%d to %dx%d", sw, sh, dw, dh);
scale->scaler(scale, src, dest, sw, sh, dw, dh);
double dest;
int color;
- GST_DEBUG(0,"videoscale: scaling bilinear %f %f %dx%d\n", x, y, sw, sh);
+ GST_DEBUG(0,"videoscale: scaling bilinear %f %f %dx%d", x, y, sw, sh);
dest=(1-a)*(1-b)*RC(j,k)+
a*(1-b)*RC(j+1,k);
double t1, t2, t3, t4;
double a1, a2, a3, a4;
- GST_DEBUG (0,"videoscale: scaling bicubic %dx%d\n", sw, sh);
+ GST_DEBUG (0,"videoscale: scaling bicubic %dx%d", sw, sh);
a1 = -a*(1-a)*(1-a);
a2 = (1-2*a*a+a*a*a);
double xr, yr;
int x, y;
- GST_DEBUG (0,"videoscale: scale plane slow %dx%d %dx%d %g %g %p %p\n", sw, sh, dw, dh, zoomx, zoomy, src, dest);
+ GST_DEBUG (0,"videoscale: scale plane slow %dx%d %dx%d %g %g %p %p", sw, sh, dw, dh, zoomx, zoomy, src, dest);
for (y=0; y<dh; y++) {
yr = ((double)y)/zoomy;
for (x=0; x<dw; x++) {
xr = ((double)x)/zoomx;
- GST_DEBUG (0,"videoscale: scale plane slow %g %g %p\n", xr, yr, (src+(int)(x)+(int)((y)*sw)));
+ GST_DEBUG (0,"videoscale: scale plane slow %g %g %p", xr, yr, (src+(int)(x)+(int)((y)*sw)));
if (floor(xr) == xr && floor(yr) == yr){
- GST_DEBUG (0,"videoscale: scale plane %g %g %p %p\n", xr, yr, (src+(int)(x)+(int)((y)*sw)), dest);
+ GST_DEBUG (0,"videoscale: scale plane %g %g %p %p", xr, yr, (src+(int)(x)+(int)((y)*sw)), dest);
*dest++ = RC(xr, yr);
}
else {
int sum, xcount, ycount, loop;
unsigned char *srcp, *srcp2;
- GST_DEBUG (0,"videoscale: scaling nearest point sample %p %p %d\n", src, dest, dw);
+ GST_DEBUG (0,"videoscale: scaling nearest point sample %p %p %d", src, dest, dw);
ypos = 0x10000;
yinc = (sh<<16)/dh;
int ypos, yinc, y;
int xpos, xinc, x;
- GST_DEBUG (0, "videoscale: scaling nearest %p %p %d %d\n", src, dest, dw, scale->scale_bytes);
+ GST_DEBUG (0, "videoscale: scaling nearest %p %p %d %d", src, dest, dw, scale->scale_bytes);
ypos = 0x10000;
unsigned char *eip;
unsigned char load, store;
- GST_DEBUG (0,"videoscale: setup scaling %p\n", copy_row);
+ GST_DEBUG (0,"videoscale: setup scaling %p", copy_row);
switch (bpp) {
case 1:
pos += inc;
}
*eip++ = RETURN;
- GST_DEBUG (0,"scaler start/end %p %p %p\n", copy_row, eip, (void*)(eip-copy_row));
+ GST_DEBUG (0,"scaler start/end %p %p %p", copy_row, eip, (void*)(eip-copy_row));
}
v4lmjpegsink = GST_V4LMJPEGSINK (gst_pad_get_parent (pad));
if (v4lmjpegsink->clock) {
- GST_DEBUG (0,"videosink: clock wait: %llu\n", GST_BUFFER_TIMESTAMP(buf));
+ GST_DEBUG (0,"videosink: clock wait: %llu", GST_BUFFER_TIMESTAMP(buf));
jitter = gst_clock_current_diff(v4lmjpegsink->clock, GST_BUFFER_TIMESTAMP (buf));
if (jitter > 500000 || jitter < -500000)
- GST_DEBUG (0, "jitter: %lld\n", jitter);
+ GST_DEBUG (0, "jitter: %lld", jitter);
gst_element_clock_wait(GST_ELEMENT(v4lmjpegsink), v4lmjpegsink->clock, GST_BUFFER_TIMESTAMP(buf));
}